diff --git a/.arcconfig b/.arcconfig
new file mode 100644
index 0000000..edbc47a
--- /dev/null
+++ b/.arcconfig
@@ -0,0 +1,6 @@
+{
+  "project_id" : "libphutil",
+  "conduit_uri" : "http://tools.epriestley-conduit.dev1557.facebook.com/api/",
+  "lint_engine" : "PhutilLintEngine",
+  "copyright_holder" : "Facebook, Inc."
+}
diff --git a/.divinerconfig b/.divinerconfig
new file mode 100644
index 0000000..90e3d13
--- /dev/null
+++ b/.divinerconfig
@@ -0,0 +1,4 @@
+{
+  "name" : "libphutil"
+}
+
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..225c74c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+.DS_Store
+._*
+docs/
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..60686e6
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2011 Facebook, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/README b/README
new file mode 100644
index 0000000..1623e5b
--- /dev/null
+++ b/README
@@ -0,0 +1,33 @@
+PROJECT STATUS: CAVEAT EMPTOR
+
+This is an unstable preview release. I'm open sourcing some of Facebook's
+internal tools, but they'll be unstable for at least a couple months.
+-epriestley
+
+
+WHAT IS LIBPHUTIL?
+
+libphutil is a collection of utility classes and functions for PHP.
+
+Futures
+  Futures (also known as "promises") are objects which act as placeholders for
+  some future result of computation. They let you express parallel and
+  asynchronous execution with a natural syntax. There are two provided concrete
+  Future implementations:
+    ExecFuture: execute system commands with a Future-based API
+    HTTPFuture: execute simple HTTP requests with a Future-based API
+    execx(): exception-based alternative to exec() with more capabilities
+    
+Filesystem
+  The builtin PHP filesystem functions return error codes and emit warnings.
+  It is tedious to check these consistently. The Filesystem class provides a
+  simple API for common filesystem operations that throws exceptions on failure.
+
+xsprintf
+  This module allows you to build sprintf()-style functions that have arbitrary
+  conversions. This is particularly useful for escaping data correctly. Three
+  concrete implementations are provided:
+    csprintf: safely escape data for system commands
+    jsprintf: safely escape data for Javascript
+    qsprintf: safely escape data for MySQL
+
diff --git a/resources/git/commit-template.txt b/resources/git/commit-template.txt
new file mode 100644
index 0000000..81633ed
--- /dev/null
+++ b/resources/git/commit-template.txt
@@ -0,0 +1,10 @@
+<<Enter Revision Title>>
+
+Summary:
+
+Test Plan:
+
+Reviewers:
+
+CC:
+
diff --git a/src/__phutil_library_init__.php b/src/__phutil_library_init__.php
new file mode 100644
index 0000000..74c2a27
--- /dev/null
+++ b/src/__phutil_library_init__.php
@@ -0,0 +1,78 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+define('__LIBPHUTIL__', true);
+
+function phutil_require_module($library, $module) {
+  phutil_module_stack('push', $library, $module);
+  phutil_require_source('__init__.php');
+  phutil_module_stack('pop');
+}
+
+function phutil_require_source($source) {
+  $base = phutil_module_stack('peek');
+  require_once $base.'/'.$source;
+}
+
+function phutil_module_exists($library, $module) {
+  $path = __phutil_library_registry('find', $library).$module.'/__init__.php';
+  return @file_exists($path);
+}
+
+function phutil_module_stack($op, $library = null, $module = null) {
+  static $stack = array();
+  switch ($op) {
+    case 'push':
+      $stack[] = __phutil_library_registry('find', $library).$module;
+      break;
+    case 'peek':
+      return end($stack);
+    case 'pop':
+      array_pop($stack);
+      break;
+  }
+}
+
+function phutil_register_library($library, $path) {
+  if (basename($path) != '__phutil_library_init__.php') {
+    throw new Exception(
+      'Only directories with a __phutil_library_init__.php file may be '.
+      'registered as libphutil libraries.');
+  }
+  return __phutil_library_registry('register', $library, dirname($path));
+}
+
+function phutil_load_library($path) {
+  require_once $path.'/__phutil_library_init__.php';
+}
+
+phutil_register_library('phutil', __FILE__);
+
+function __phutil_library_registry($op, $library = null, $path = null) {
+  static $dict = array();
+  switch ($op) {
+    case 'register':
+      $dict[$library] = $path.'/';
+      break;
+    case 'find':
+      return $dict[$library];
+    case 'list':
+      return $dict;
+  }
+}
+
diff --git a/src/__phutil_library_map__.php b/src/__phutil_library_map__.php
new file mode 100644
index 0000000..8e67b3e
--- /dev/null
+++ b/src/__phutil_library_map__.php
@@ -0,0 +1,115 @@
+<?php
+
+/**
+ * This file is automatically generated. Use 'phutil_mapper.php' to rebuild it.
+ * @generated
+ */
+
+phutil_register_library_map(array(
+  'class' =>
+  array(
+    'CommandException' => 'future/exec',
+    'ConduitClient' => 'conduit/client',
+    'ConduitClientException' => 'conduit/client',
+    'ConduitFuture' => 'conduit/client',
+    'ExecFuture' => 'future/exec',
+    'FileFinder' => 'filesystem/filefinder',
+    'FileList' => 'filesystem/filelist',
+    'Filesystem' => 'filesystem',
+    'FilesystemException' => 'filesystem',
+    'Future' => 'future',
+    'FutureIterator' => 'future',
+    'HTTPFuture' => 'future/http',
+    'PhutilConsoleFormatter' => 'console',
+    'PhutilInteractiveEditor' => 'console/editor',
+    'PhutilLibraryMapRegistry' => 'autoload',
+    'PhutilMarkupEngine' => 'markup/engine',
+    'PhutilRemarkupBlockStorage' => 'markup/engine/remarkup/blockstorage',
+    'PhutilRemarkupEngine' => 'markup/engine/remarkup',
+    'PhutilRemarkupEngineBlockRule' => 'markup/engine/remarkup/blockrule/base',
+    'PhutilRemarkupEngineRemarkupCodeBlockRule' => 'markup/engine/remarkup/blockrule/remarkupcode',
+    'PhutilRemarkupEngineRemarkupCounterExampleBlockRule' => 'markup/engine/remarkup/blockrule/remarkupcounterexample',
+    'PhutilRemarkupEngineRemarkupDefaultBlockRule' => 'markup/engine/remarkup/blockrule/remarkupdefault',
+    'PhutilRemarkupEngineRemarkupHeaderBlockRule' => 'markup/engine/remarkup/blockrule/remarkupheader',
+    'PhutilRemarkupEngineRemarkupInlineBlockRule' => 'markup/engine/remarkup/blockrule/remarkupinline',
+    'PhutilRemarkupEngineRemarkupListBlockRule' => 'markup/engine/remarkup/blockrule/remarkuplist',
+    'PhutilRemarkupRule' => 'markup/engine/remarkup/markuprule/base',
+    'PhutilRemarkupRuleBold' => 'markup/engine/remarkup/markuprule/bold',
+    'PhutilRemarkupRuleEscapeHTML' => 'markup/engine/remarkup/markuprule/escapehtml',
+    'PhutilRemarkupRuleEscapeRemarkup' => 'markup/engine/remarkup/markuprule/escaperemarkup',
+    'PhutilRemarkupRuleHyperlink' => 'markup/engine/remarkup/markuprule/hyperlink',
+    'PhutilRemarkupRuleItalic' => 'markup/engine/remarkup/markuprule/italics',
+    'PhutilRemarkupRuleLinebreaks' => 'markup/engine/remarkup/markuprule/linebreaks',
+    'PhutilRemarkupRuleMonospace' => 'markup/engine/remarkup/markuprule/monospace',
+    'QsprintfQueryParameterException' => 'xsprintf/qsprintf',
+    'TempFile' => 'filesystem/tempfile',
+  ),
+  'function' =>
+  array(
+    'Futures' => 'future',
+    '_qsprintf_check_scalar_type' => 'xsprintf/qsprintf',
+    '_qsprintf_check_type' => 'xsprintf/qsprintf',
+    'array_select_keys' => 'utils',
+    'coalesce' => 'utils',
+    'csprintf' => 'xsprintf/csprintf',
+    'exec_manual' => 'future/exec',
+    'execx' => 'future/exec',
+    'id' => 'utils',
+    'idx' => 'utils',
+    'ipull' => 'utils',
+    'jsprintf' => 'xsprintf/jsprintf',
+    'mgroup' => 'utils',
+    'mpull' => 'utils',
+    'msort' => 'utils',
+    'mysql_escape_array_of_strings_for_in_clause' => 'xsprintf/qsprintf',
+    'mysql_escape_column_name' => 'xsprintf/qsprintf',
+    'mysql_escape_multiline_comment' => 'xsprintf/qsprintf',
+    'newv' => 'utils',
+    'nonempty' => 'utils',
+    'phutil_autoload_class' => 'autoload',
+    'phutil_autoload_function' => 'autoload',
+    'phutil_console_confirm' => 'console',
+    'phutil_console_format' => 'console',
+    'phutil_console_prompt' => 'console',
+    'phutil_console_wrap' => 'console',
+    'phutil_escape_html' => 'markup',
+    'phutil_find_class_descendants' => 'autoload',
+    'phutil_find_classes_declared_in_module' => 'autoload',
+    'phutil_get_library_name_for_root' => 'moduleutils',
+    'phutil_get_library_root' => 'moduleutils',
+    'phutil_get_library_root_for_path' => 'moduleutils',
+    'phutil_register_library_map' => 'autoload',
+    'phutil_render_tag' => 'markup',
+    'qsprintf' => 'xsprintf/qsprintf',
+    'vcsprintf' => 'xsprintf/csprintf',
+    'vjsprintf' => 'xsprintf/jsprintf',
+    'vqsprintf' => 'xsprintf/qsprintf',
+    'xsprintf' => 'xsprintf',
+    'xsprintf_command' => 'xsprintf/csprintf',
+    'xsprintf_javascript' => 'xsprintf/jsprintf',
+    'xsprintf_query' => 'xsprintf/qsprintf',
+  ),
+  'requires_class' =>
+  array(
+    'ConduitFuture' => 'HTTPFuture',
+    'ExecFuture' => 'Future',
+    'HTTPFuture' => 'Future',
+    'PhutilRemarkupEngine' => 'PhutilMarkupEngine',
+    'PhutilRemarkupEngineRemarkupCodeBlockRule' => 'PhutilRemarkupEngineBlockRule',
+    'PhutilRemarkupEngineRemarkupCounterExampleBlockRule' => 'PhutilRemarkupEngineBlockRule',
+    'PhutilRemarkupEngineRemarkupDefaultBlockRule' => 'PhutilRemarkupEngineBlockRule',
+    'PhutilRemarkupEngineRemarkupHeaderBlockRule' => 'PhutilRemarkupEngineBlockRule',
+    'PhutilRemarkupEngineRemarkupInlineBlockRule' => 'PhutilRemarkupEngineBlockRule',
+    'PhutilRemarkupEngineRemarkupListBlockRule' => 'PhutilRemarkupEngineBlockRule',
+    'PhutilRemarkupRuleBold' => 'PhutilRemarkupRule',
+    'PhutilRemarkupRuleEscapeHTML' => 'PhutilRemarkupRule',
+    'PhutilRemarkupRuleEscapeRemarkup' => 'PhutilRemarkupRule',
+    'PhutilRemarkupRuleHyperlink' => 'PhutilRemarkupRule',
+    'PhutilRemarkupRuleItalic' => 'PhutilRemarkupRule',
+    'PhutilRemarkupRuleLinebreaks' => 'PhutilRemarkupRule',
+    'PhutilRemarkupRuleMonospace' => 'PhutilRemarkupRule',
+  ),
+  'requires_interface' =>
+  array(
+  ),
+));
diff --git a/src/autoload/PhutilLibraryMapRegistry.php b/src/autoload/PhutilLibraryMapRegistry.php
new file mode 100644
index 0000000..94645be
--- /dev/null
+++ b/src/autoload/PhutilLibraryMapRegistry.php
@@ -0,0 +1,163 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilLibraryMapRegistry {
+
+  protected static $map = array();
+  protected static $library;
+
+  public static function findDescendantsOfClass($class) {
+    foreach (array_keys(__phutil_library_registry('list')) as $library) {
+      if (empty(self::$map[$library])) {
+        self::loadLibraryMap($library);
+      }
+    }
+    $children = array();
+    foreach (self::$map as $library => $map) {
+      foreach ($map['requires_class'] as $child => $parent) {
+        if ($parent == $class) {
+          $children[] = $child;
+        }
+      }
+      foreach ($map['requires_interface'] as $child => $parent) {
+        if ($parent == $class) {
+          $children[] = $child;
+        }
+      }
+    }
+
+    $descendants = array(
+      $children,
+    );
+    foreach ($children as $child) {
+      $descendants[] = self::findDescendantsOfClass($child);
+    }
+    return call_user_func_array('array_merge', $descendants);
+  }
+
+  public static function findClassesDeclaredInModule($library, $module) {
+    if (empty(self::$map[$library])) {
+      $map = self::loadLibraryMap($library);
+    } else {
+      $map = self::$map[$library];
+    }
+
+    $results = array();
+    foreach ($map['class'] as $class => $declared) {
+      if ($declared == $module) {
+        $results[] = $class;
+      }
+    }
+
+    return $results;
+  }
+
+  public static function register(array $map) {
+    self::$map[self::$library] = $map;
+  }
+
+  public static function loadLibraryMap($library) {
+    if (!empty(self::$map[$library])) {
+      return self::$map[$library];
+    }
+    self::$library = $library;
+    $root = __phutil_library_registry('find', $library);
+    $okay = @include_once $root.'/__phutil_library_map__.php';
+    if (!$okay) {
+      throw new Exception("Unable to load library map for '{$library}'.");
+    }
+    return self::$map[$library];
+  }
+
+  public static function findClass($library, $class, $search = true) {
+    return self::findSymbolOfType('class', $library, $class, $search);
+  }
+
+  public static function findFunction($library, $function, $search = true) {
+    return self::findSymbolOfType('function', $library, $function, $search);
+  }
+
+  public static function findSymbolOfType($type, $library, $symbol, $search) {
+    if ($library) {
+      $map = self::loadLibraryMap($library);
+      if (isset($map[$library][$type][$symbol])) {
+        return self::getSpec($type, $library, $symbol);
+      }
+    }
+
+    if (!$search) {
+      return false;
+    }
+
+    foreach (self::$map as $library => $map) {
+      if (isset($map[$type][$symbol])) {
+        return self::getSpec($type, $library, $symbol);
+      }
+    }
+
+    foreach (array_keys(__phutil_library_registry('list')) as $library) {
+      if (empty(self::$map[$library])) {
+        $map = self::loadLibraryMap($library);
+        if (isset($map[$type][$symbol])) {
+          return self::getSpec($type, $library, $symbol);
+        }
+      }
+    }
+
+    return false;
+  }
+
+  private static function getSpec($type, $library, $symbol) {
+    if ($type == 'function') {
+      return self::getFunctionSpec($library, $symbol);
+    } else {
+      return self::getClassSpec($library, $symbol);
+    }
+  }
+
+  private static function getFunctionSpec($library, $function) {
+    $map = self::$map[$library];
+    return array(
+      'library' => $library,
+      'module'  => $map['function'][$function],
+    );
+  }
+
+  private static function getClassSpec($library, $class) {
+    $map = self::$map[$library];
+    $module = $map['class'][$class];
+    $parent = null;
+    $interface = array();
+
+    if (!empty($map['requires_class'][$class])) {
+      $parent = $map['requires_class'][$class];
+    }
+
+    if (!empty($map['requires_interface'][$class])) {
+      $interface = $map['requires_interface'][$class];
+    }
+
+    return array(
+      'library'             => $library,
+      'module'              => $module,
+      'requires_class'      => $parent,
+      'requires_interface'  => $interface,
+    );
+  }
+
+}
diff --git a/src/autoload/__init__.php b/src/autoload/__init__.php
new file mode 100644
index 0000000..f0070c7
--- /dev/null
+++ b/src/autoload/__init__.php
@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_source('autoload.php');
+phutil_require_source('PhutilLibraryMapRegistry.php');
diff --git a/src/autoload/autoload.php b/src/autoload/autoload.php
new file mode 100644
index 0000000..2343c6e
--- /dev/null
+++ b/src/autoload/autoload.php
@@ -0,0 +1,82 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function phutil_autoload_class($class, $library = null) {
+  if (class_exists($class, false) || interface_exists($class, false)) {
+    return true;
+  }
+
+  $spec = PhutilLibraryMapRegistry::findClass($library, $class, $search = true);
+
+  if (!$spec) {
+    return false;
+  }
+
+  if ($spec['requires_class']) {
+    if (!class_exists($spec['requires_class'], $autoload = false)) {
+      phutil_autoload_class($spec['requires_class'], $spec['library']);
+    }
+  }
+
+  foreach ($spec['requires_interface'] as $interface) {
+    if (!interface_exists($interface, $autoload = false)) {
+      phutil_autoload_class($interface, $spec['library']);
+    }
+  }
+
+  // Foil static analysis.
+  $require = 'phutil_require_module';
+  $require($spec['library'], $spec['module']);
+
+  return (class_exists($class, false) || interface_exists($class, false));
+}
+
+function phutil_autoload_function($function, $library = null) {
+  if (function_exists($function)) {
+    return true;
+  }
+
+  $spec = PhutilLibraryMapRegistry::findFunction(
+    $library,
+    $function,
+    $search = true);
+
+  if (!$spec) {
+    return false;
+  }
+
+  // Foil static analysis.
+  $require = 'phutil_require_module';
+  $require($spec['library'], $spec['module']);
+
+  return function_exists($function);
+}
+
+function phutil_find_class_descendants($class) {
+  return PhutilLibraryMapRegistry::findDescendantsOfClass($class);
+}
+
+function phutil_find_classes_declared_in_module($library, $module) {
+  return PhutilLibraryMapRegistry::findClassesDeclaredInModule(
+    $library,
+    $module);
+}
+
+function phutil_register_library_map(array $map) {
+  PhutilLibraryMapRegistry::register($map);
+}
diff --git a/src/conduit/client/ConduitClient.php b/src/conduit/client/ConduitClient.php
new file mode 100644
index 0000000..9ba60bb
--- /dev/null
+++ b/src/conduit/client/ConduitClient.php
@@ -0,0 +1,93 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class ConduitClient {
+
+  protected $host;
+  protected $path;
+  protected $traceMode;
+  protected $connectionID;
+
+  public function setConnectionID($connection_id) {
+    $this->connectionID = $connection_id;
+    return $this;
+  }
+
+  public function getConnectionID() {
+    return $this->connectionID;
+  }
+
+  public function __construct($uri) {
+    $this->host = parse_url($uri, PHP_URL_HOST);
+    $this->path = parse_url($uri, PHP_URL_PATH);
+
+    if (!$this->host) {
+      throw new Exception("Conduit URI '{$uri}' must include a valid host.");
+    }
+
+    $this->path = trim($this->path, '/').'/';
+  }
+
+  public function callMethodSynchronous($method, array $params) {
+    return $this->callMethod($method, $params)->resolve();
+  }
+
+  public function callMethod($method, array $params) {
+
+    $meta = array();
+    if ($this->getConnectionID()) {
+      $meta['connectionID'] = $this->getConnectionID();
+    }
+
+    if ($meta) {
+      $params['__conduit__'] = $meta;
+    }
+
+    $start_time = microtime(true);
+    $future = new ConduitFuture(
+      'http://'.$this->host.'/'.$this->path.$method,
+      array(
+        'params' => json_encode($params),
+        'output' => 'json',
+      ));
+    $future->setMethod('POST');
+    $future->isReady();
+
+    if ($this->getTraceMode()) {
+      $future_name = $method;
+      $future->setTraceMode(true);
+      $future->setStartTime($start_time);
+      $future->setTraceName($future_name);
+      echo "[Conduit] >>> Send {$future_name}()...\n";
+    }
+
+    return $future;
+  }
+
+  public function setTraceMode($mode) {
+    $this->traceMode = $mode;
+    return $this;
+  }
+
+  protected function getTraceMode() {
+    if (!empty($this->traceMode)) {
+      return true;
+    }
+    return false;
+  }
+}
diff --git a/src/conduit/client/ConduitClientException.php b/src/conduit/client/ConduitClientException.php
new file mode 100644
index 0000000..987295f
--- /dev/null
+++ b/src/conduit/client/ConduitClientException.php
@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class ConduitClientException extends Exception {
+
+  protected $errorCode;
+
+  public function __construct($code, $info) {
+    parent::__construct("{$code}: {$info}");
+    $this->errorCode = $code;
+  }
+
+  public function getErrorCode() {
+    return $this->errorCode;
+  }
+
+}
diff --git a/src/conduit/client/ConduitFuture.php b/src/conduit/client/ConduitFuture.php
new file mode 100644
index 0000000..75cc4ca
--- /dev/null
+++ b/src/conduit/client/ConduitFuture.php
@@ -0,0 +1,75 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class ConduitFuture extends HTTPFuture {
+
+  protected $traceMode;
+  protected $traceName;
+  protected $startTime;
+  protected $endTime;
+
+  public function setTraceMode($trace_mode) {
+    $this->traceMode = $trace_mode;
+    return $this;
+  }
+
+  public function setTraceName($trace_name) {
+    $this->traceName = $trace_name;
+    return $this;
+  }
+
+  public function setStartTime($time) {
+    $this->startTime = $time;
+    return $this;
+  }
+
+  protected function getResult() {
+    $result = parent::getResult();
+
+    if (empty($this->endTime)) {
+      $this->endTime = microtime(true);
+      $time = (int)(1000 * ($this->endTime - $this->startTime));
+      $time = number_format($time).' ms';
+      if ($this->traceMode) {
+        echo "[Conduit] <<< Completed {$this->traceName} in {$time}.\n";
+      }
+    }
+
+    if ($result[0] !== 200) {
+      throw new Exception(
+        "Host returned an HTTP error response #{$result[0]} in response ".
+        "to a Conduit method call.");
+    }
+
+    $data = json_decode($result[1], true);
+    if (!is_array($data)) {
+      throw new Exception(
+        "Host returned HTTP/200, but invalid JSON data in response to ".
+        "a Conduit method call:\n{$result[1]}");
+    }
+
+    if ($data['error_code']) {
+      throw new ConduitClientException(
+        $data['error_code'],
+        $data['error_info']);
+    }
+
+    return $data['result'];
+  }
+
+}
diff --git a/src/conduit/client/__init__.php b/src/conduit/client/__init__.php
new file mode 100644
index 0000000..b90bf32
--- /dev/null
+++ b/src/conduit/client/__init__.php
@@ -0,0 +1,23 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_module('phutil', 'future/http');
+
+phutil_require_source('ConduitClient.php');
+phutil_require_source('ConduitFuture.php');
+phutil_require_source('ConduitClientException.php');
diff --git a/src/console/PhutilConsoleFormatter.php b/src/console/PhutilConsoleFormatter.php
new file mode 100644
index 0000000..e5b04dd
--- /dev/null
+++ b/src/console/PhutilConsoleFormatter.php
@@ -0,0 +1,68 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilConsoleFormatter {
+
+  private static $colorCodes = array(
+    'black'   => 0,
+    'red'     => 1,
+    'green'   => 2,
+    'yellow'  => 3,
+    'blue'    => 4,
+    'magenta' => 5,
+    'cyan'    => 6,
+    'white'   => 7,
+    'default' => 9,
+  );
+
+
+  public static function formatString($format /* ... */) {
+    $esc        = chr(27);
+    $bold       = $esc.'[1m'.'\\1'.$esc.'[m';
+    $underline  = $esc.'[4m'.'\\1'.$esc.'[m';
+    $invert     = $esc.'[7m'.'\\1'.$esc.'[m';
+
+    $colors = implode('|', array_keys(self::$colorCodes));
+
+    $format = preg_replace('/\*\*(.*)\*\*/sU',  $bold,      $format);
+    $format = preg_replace('/__(.*)__/sU',      $underline, $format);
+    $format = preg_replace('/##(.*)##/sU',      $invert,    $format);
+    $format = preg_replace_callback(
+      '@<(fg|bg):('.$colors.')>(.*)</\1>@sU',
+      array('PhutilConsoleFormatter', 'replaceColorCode'),
+      $format);
+
+    $args = func_get_args();
+    $args[0] = $format;
+
+    return call_user_func_array('sprintf', $args);
+  }
+
+  public static function replaceColorCode($matches) {
+    $codes = self::$colorCodes;
+    $offset = 30 + $codes[$matches[2]];
+    $default = 39;
+    if ($matches[1] == 'bg') {
+      $offset += 10;
+      $default += 10;
+    }
+
+    return chr(27).'['.$offset.'m'.$matches[3].chr(27).'['.$default.'m';
+  }
+
+}
diff --git a/src/console/__init__.php b/src/console/__init__.php
new file mode 100644
index 0000000..a1f4577
--- /dev/null
+++ b/src/console/__init__.php
@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_source('format.php');
+phutil_require_source('PhutilConsoleFormatter.php');
diff --git a/src/console/editor/PhutilInteractiveEditor.php b/src/console/editor/PhutilInteractiveEditor.php
new file mode 100644
index 0000000..87710c4
--- /dev/null
+++ b/src/console/editor/PhutilInteractiveEditor.php
@@ -0,0 +1,232 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Edit a document interactively, by launching $EDITOR (like vi or nano).
+ *
+ *   $result = id(new InteractiveEditor($document))
+ *     ->setName('shopping_list')
+ *     ->setLineOffset(15)
+ *     ->editInteractively();
+ *
+ * This will launch the user's $EDITOR to edit the specified '$document', and
+ * return their changes into '$result'.
+ *
+ * @task create  Creating a New Editor
+ * @task edit    Editing Interactively
+ * @task config  Configuring Options
+ */
+final class PhutilInteractiveEditor {
+
+  private $name     = '';
+  private $content  = '';
+  private $offset   = 0;
+  private $fallback = 'nano';
+
+
+/* -(  Creating a New Editor  )---------------------------------------------- */
+
+
+  /**
+   * Constructs an interactive editor, using the text of a document.
+   *
+   * @param  string  Document text.
+   * @return $this
+   *
+   * @task   create
+   */
+  public function __construct($content) {
+    $this->setContent($content);
+  }
+
+
+/* -(  Editing Interactively )----------------------------------------------- */
+
+
+  /**
+   * Launch an editor and edit the content. The edited content will be
+   * returned.
+   *
+   * @return string    Edited content.
+   * @throws Exception The editor exited abnormally or something untoward
+   *                   occurred.
+   *
+   * @task edit
+   */
+  public function editInteractively() {
+    $name = $this->getName();
+    $content = $this->getContent();
+
+    $tmp = Filesystem::createTemporaryDirectory('edit.');
+    $path = $tmp.DIRECTORY_SEPARATOR.$name;
+
+    try {
+      Filesystem::writeFile($path, $content);
+    } catch (Exception $ex) {
+      Filesystem::remove($tmp);
+      throw $ex;
+    }
+
+    $editor = $this->getEditor();
+    $offset = $this->getLineOffset();
+
+    $arg_editor = $editor;
+    $arg_offset = escapeshellarg($offset);
+    $arg_path   = escapeshellarg($path);
+
+    $err = 0;
+    passthru("{$arg_editor} +{$arg_offset} {$arg_path}", $err);
+
+    if ($err) {
+      Filesystem::remove($tmp);
+      throw new Exception("Editor exited with an error code (#{$err}).");
+    }
+
+    try {
+      $result = Filesystem::readFile($path);
+      Filesystem::remove($tmp);
+    } catch (Exception $ex) {
+      Filesystem::remove($tmp);
+      throw $ex;
+    }
+
+    $this->setContent($result);
+
+    return $this->getContent();
+  }
+
+
+/* -(  Configuring Options )------------------------------------------------- */
+
+
+  /**
+   * Set the line offset where the cursor should be positioned when the editor
+   * opens. By default, the cursor will be positioned at the start of the
+   * content.
+   *
+   * @param  int   Line number where the cursor should be positioned.
+   * @return $this
+   *
+   * @task config
+   */
+  public function setLineOffset($offset) {
+    $this->offset = (int)$offset;
+    return $this;
+  }
+
+
+  /**
+   * Get the current line offset. See setLineOffset().
+   *
+   * @return int   Current line offset.
+   *
+   * @task config
+   */
+  public function getLineOffset() {
+    return $this->offset;
+  }
+
+
+  /**
+   * Set the document name. Depending on the editor, this may be exposed to
+   * the user and can give them a sense of what they're editing.
+   *
+   * @param  string  Document name.
+   * @return $this
+   *
+   * @task config
+   */
+  public function setName($name) {
+    $name = preg_replace('/[^A-Z0-9._-]+/i', '', $name);
+    $this->name = $name;
+    return $this;
+  }
+
+
+  /**
+   * Get the current document name. See setName() for details.
+   *
+   * @return string  Current document name.
+   *
+   * @task config
+   */
+  public function getName() {
+    if (!strlen($this->name)) {
+      return 'untitled';
+    }
+    return $this->name;
+  }
+
+
+  /**
+   * Set the text content to be edited.
+   *
+   * @param  string  New content.
+   * @return $this
+   *
+   * @task config
+   */
+  public function setContent($content) {
+    $this->content = $content;
+    return $this;
+  }
+
+
+  /**
+   * Retrieve the current content.
+   *
+   * @return string
+   *
+   * @task config
+   */
+  public function getContent() {
+    return $this->content;
+  }
+
+  /**
+   * Set the fallback editor program to be used if the env variable $EDITOR
+   * is not available.
+   *
+   * @param  string  Command-line editing program (e.g. 'emacs', 'vi')
+   * @return $this
+   *
+   * @task config
+   */
+  public function setFallbackEditor($editor) {
+    $this->fallback = $editor;
+    return $this;
+  }
+
+  /**
+   * Get the name of the editor program to use. The value of the environmental
+   * variable $EDITOR will be used if available; otherwise, the best editor
+   * will be selected.
+   *
+   * @return string  Command-line editing program.
+   *
+   * @task config
+   */
+  public function getEditor() {
+    $editor = getenv('EDITOR');
+    if (!$editor) {
+      $editor = $this->fallback;
+    }
+
+    return $editor;
+  }
+}
diff --git a/src/console/editor/__init__.php b/src/console/editor/__init__.php
new file mode 100644
index 0000000..ae1e1cf
--- /dev/null
+++ b/src/console/editor/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'filesystem');
+
+
+phutil_require_source('PhutilInteractiveEditor.php');
diff --git a/src/console/format.php b/src/console/format.php
new file mode 100644
index 0000000..231e4d5
--- /dev/null
+++ b/src/console/format.php
@@ -0,0 +1,60 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function phutil_console_format($format /* ... */) {
+  $args = func_get_args();
+  return call_user_func_array(
+    array('PhutilConsoleFormatter', 'formatString'),
+    $args);
+}
+
+function phutil_console_confirm($prompt, $default_no = true) {
+
+  $prompt_options = $default_no ? '[y/N]' : '[Y/n]';
+
+  do {
+    $response = phutil_console_prompt($prompt.' '.$prompt_options);
+    $c = trim(strtolower($response));
+  } while ($c != 'y' && $c != 'n' && $c != '');
+  echo "\n";
+
+  if ($default_no) {
+    return ($c == 'y');
+  } else {
+    return ($c != 'n');
+  }
+}
+
+function phutil_console_prompt($prompt) {
+
+  $prompt = "\n\n    ".$prompt." ";
+  $prompt = phutil_console_wrap($prompt, 4);
+
+  echo $prompt;
+  $response = fgets(STDIN);
+
+  return rtrim($response, "\n");
+}
+
+function phutil_console_wrap($text, $indent = 0) {
+  $indent_string = '';
+  if ($indent) {
+    $indent_string = str_repeat(' ', $indent);
+  }
+  return wordwrap($text, 78 - $indent, "\n".$indent_string);
+}
diff --git a/src/docs/overview.diviner b/src/docs/overview.diviner
new file mode 100644
index 0000000..56854af
--- /dev/null
+++ b/src/docs/overview.diviner
@@ -0,0 +1,10 @@
+@title libphutil Overview
+
+This document provides a high-level introduction to libphutil.
+
+= Overview =
+
+libphutil is a collection of PHP utility classes and modules.
+
+This project is in an unstable state. See @{article:Project Status} for a 
+description of the project status.
\ No newline at end of file
diff --git a/src/filesystem/Filesystem.php b/src/filesystem/Filesystem.php
new file mode 100644
index 0000000..a2e6118
--- /dev/null
+++ b/src/filesystem/Filesystem.php
@@ -0,0 +1,685 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Simple wrapper class for common filesystem tasks like reading and writing
+ * files. When things go wrong, this class throws detailed exceptions with
+ * good information about what didn't work.
+ *
+ * Filesystem will resolve relative paths against PWD from the environment.
+ * When Filesystem is unable to complete an operation, it throws a
+ * FilesystemException.
+ *
+ * @task directory   Directories
+ * @task file        Files
+ * @task path        Paths
+ * @task assert      Assertions
+ */
+class Filesystem {
+
+
+/* -(  Files  )-------------------------------------------------------------- */
+
+
+  /**
+   * Read a file in a manner similar to file_get_contents(), but throw detailed
+   * exceptions on failure.
+   *
+   * @param  string  File path to read. This file must exist and be readable,
+   *                 or an exception will be thrown.
+   * @return string  Contents of the specified file.
+   *
+   * @task   file
+   */
+  public static function readFile($path) {
+    $path = self::resolvePath($path);
+
+    self::assertExists($path);
+    self::assertIsFile($path);
+    self::assertReadable($path);
+
+    $data = @file_get_contents($path);
+    if ($data === false) {
+      throw new FilesystemException(
+        $path,
+        "Failed to read file `{$path}'.");
+    }
+
+    return $data;
+  }
+
+
+  /**
+   * Write a file in a manner similar to file_put_contents(), but throw
+   * detailed exceptions on failure. If the file already exists, it will be
+   * overwritten.
+   *
+   * @param  string  File path to write. This file must be writable and its
+   *                 parent directory must exist.
+   * @param  string  Data to write.
+   *
+   * @task   file
+   */
+  public static function writeFile($path, $data) {
+    $path = self::resolvePath($path);
+    $dir  = dirname($path);
+
+    self::assertExists($dir);
+    self::assertIsDirectory($dir);
+
+    // File either needs to not exist and have a writable parent, or be
+    // writable itself.
+    $exists = true;
+    try {
+      self::assertNotExists($path);
+      $exists = false;
+    } catch (Exception $ex) {
+      self::assertWritable($path);
+    }
+
+    if (!$exists) {
+      self::assertWritable($dir);
+    }
+
+    if (@file_put_contents($path, $data) === false) {
+      throw new FilesystemException(
+        $path,
+        "Failed to write file `{$path}'.");
+    }
+  }
+
+
+  /**
+   * Append to a file without having to deal with file handles, with
+   * detailed exceptions on failure.
+   *
+   * @param  string  File path to write. This file must be writable or its
+   *                 parent directory must exist and be writable.
+   * @param  string  Data to write.
+   *
+   * @task   file
+   */
+  public static function appendFile($path, $data) {
+    $path = self::resolvePath($path);
+
+    // Use self::writeFile() if the file doesn't already exist
+    try {
+      self::assertExists($path);
+    } catch (FilesystemException $ex) {
+      self::writeFile($path, $data);
+      return;
+    }
+
+    // File needs to exist or the directory needs to be writable
+    $dir = dirname($path);
+    self::assertExists($dir);
+    self::assertIsDirectory($dir);
+    self::assertWritable($dir);
+
+    if (($fh = fopen($path, 'a')) === false) {
+      throw new FilesystemException(
+        $path, "Failed to open file `{$path}'.");
+    }
+    $dlen = strlen($data);
+    if (fwrite($fh, $data) !== $dlen) {
+      throw new FilesystemException(
+        $path,
+        "Failed to write {$dlen} bytes to `{$path}'.");
+    }
+    if (!fflush($fh) || !fclose($fh)) {
+      throw new FilesystemException(
+        $path,
+        "Failed closing file `{$path}' after write.");
+    }
+  }
+
+
+  /**
+   * Remove a file or directory.
+   *
+   * @param  string    File to a path or directory to remove.
+   * @return void
+   *
+   * @task   file
+   */
+  public static function remove($path) {
+    if (!strlen($path)) {
+      // Avoid removing PWD.
+      throw new Exception("No path provided to remove().");
+    }
+
+    $path = self::resolvePath($path);
+
+    if (!file_exists($path)) {
+      return;
+    }
+
+    //  PHP's builtin functions for this are such a mess that it's much easier
+    //  to exec out. :/
+    list($err, $stdout, $stderr) = exec_manual('rm -rf %s', $path);
+    if ($err) {
+      throw new FilesystemException(
+        $path,
+        "Unable to remove `{$path}'.");
+    }
+  }
+
+
+  /**
+   * Change the permissions of a file or directory.
+   *
+   * @param  string    Path to the file or directory.
+   * @param  int       Permission umask. Note that umask is in octal, so you
+   *                   should specify it as, e.g., `0777', not `777'.
+   * @return void
+   *
+   * @task   file
+   */
+  public static function changePermissions($path, $umask) {
+    $path = self::resolvePath($path);
+
+    self::assertExists($path);
+
+    if (!@chmod($path, $umask)) {
+      $readable_umask = sprintf("%04o", $umask);
+      throw new FilesystemException(
+        $path, "Failed to chmod `{$path}' to `{$readable_umask}'.");
+    }
+  }
+
+
+  /**
+   * Get the last modified time of a file
+   *
+   * @param string Path to file
+   * @return Time last modified
+   *
+   * @task file
+   */
+  public static function getModifiedTime($path) {
+    $path = self::resolvePath($path);
+    self::assertExists($path);
+    self::assertIsFile($path);
+    self::assertReadable($path);
+
+    $modified_time = @filemtime($path);
+
+    if ($modified_time === false) {
+      throw new FilesystemException(
+        $path,
+        'Failed to read modified time for '.$path);
+    }
+
+    return $modified_time;
+  }
+
+
+  /**
+   * Determine if a file is an image, approximately. This is a simple path
+   * test which exists primarily to reduce code duplication.
+   *
+   * @param   string  Path in question.
+   * @return  bool    True if the corresponding file is (probably) an image.
+   *
+   * @task file
+   */
+  public static function isImageFilename($path) {
+    $path = self::resolvePath($path);
+    return (bool)preg_match('/[.](jpe?g|gif|png)$/i', $path);
+  }
+
+
+/* -(  Directories  )-------------------------------------------------------- */
+
+
+  /**
+   * Create a directory in a manner similar to mkdir(), but throw detailed
+   * exceptions on failure.
+   *
+   * @param  string    Path to directory. The parent directory must exist and
+   *                   be writable.
+   * @param  int       Permission umask. Note that umask is in octal, so you
+   *                   should specify it as, e.g., `0777', not `777'. By
+   *                   default, these permissions are very liberal (0777).
+   * @param  boolean   Recursivly create directories.  Default to false
+   * @return string    Path to the created directory.
+   *
+   * @task   directory
+   */
+  public static function createDirectory($path, $umask = 0777,
+                                            $recursive = false) {
+    $path = self::resolvePath($path);
+
+    if (is_dir($path)) {
+      Filesystem::changePermissions($path, $umask);
+      return $path;
+    }
+
+    $dir = dirname($path);
+    if ($recursive && !file_exists($dir)) {
+      // Note: We could do this with the recursive third parameter of mkdir(),
+      // but then we loose the helpful FilesystemExceptions we normally get.
+      self::createDirectory($dir, $umask, true);
+    }
+
+    self::assertIsDirectory($dir);
+    self::assertExists($dir);
+    self::assertWritable($dir);
+    self::assertNotExists($path);
+
+    if (!mkdir($path, $umask)) {
+      throw new FilesystemException(
+        $path,
+        "Failed to create directory `{$path}'.");
+    }
+
+    // Need to change premissions explicitly because mkdir does something
+    // slightly different. mkdir(2) man page:
+    // 'The parameter mode specifies the permissions to use. It is modified by
+    // the process's umask in the usual way: the permissions of the created
+    // directory are (mode & ~umask & 0777)."'
+    Filesystem::changePermissions($path, $umask);
+
+    return $path;
+  }
+
+
+  /**
+   * Create a temporary directory and return the path to it. You are
+   * responsible for removing it (e.g., with Filesystem::remove())
+   * when you are done with it.
+   *
+   * @param  string    Optional directory prefix.
+   * @param  int       Permissions to create the directory with. By default,
+   *                   these permissions are very restrictive (0700).
+   * @return string    Path to newly created temporary directory.
+   *
+   * @task   directory
+   */
+  public static function createTemporaryDirectory($prefix = '', $umask = 0700) {
+    $prefix = preg_replace('/[^A-Z0-9._-]+/i', '', $prefix);
+
+    $tmp = sys_get_temp_dir();
+    if (!$tmp) {
+      throw new FilesystemException(
+        $tmp, 'Unable to determine system temporary directory.');
+    }
+
+    $base = $tmp.DIRECTORY_SEPARATOR.$prefix;
+
+    $tries = 3;
+    do {
+      $dir = $base.substr(base_convert(md5(mt_rand()), 16, 36), 0, 16);
+      try {
+        self::createDirectory($dir, $umask);
+        break;
+      } catch (FilesystemException $ex) {
+        //  Ignore.
+      }
+    } while (--$tries);
+
+    if (!$tries) {
+
+      $df = disk_free_space($tmp);
+      if ($df < 1024 * 1024) {
+        throw new FilesystemException(
+          $dir, "Failed to create a temporary directory: the disk is full.");
+      }
+
+      throw new FilesystemException(
+        $dir, "Failed to create a temporary directory.");
+    }
+
+    return $dir;
+  }
+
+
+  /**
+   * List files in a directory.
+   *
+   * @param  string    Path, absolute or relative to PWD.
+   * @param  bool      If false, exclude files beginning with a ".".
+   *
+   * @return array     List of files and directories in the specified
+   *                   directory, excluding `.' and `..'.
+   *
+   * @task   directory
+   */
+  public static function listDirectory($path, $include_hidden = true) {
+    $path = self::resolvePath($path);
+
+    self::assertExists($path);
+    self::assertIsDirectory($path);
+    self::assertReadable($path);
+
+    $list = @scandir($path);
+    if ($list === false) {
+      throw new Exception(
+        $path,
+        "Unable to list contents of directory `{$path}'.");
+    }
+
+    foreach ($list as $k => $v) {
+      if ($v == '.' || $v == '..' || (!$include_hidden && $v[0] == '.')) {
+        unset($list[$k]);
+      }
+    }
+
+    return array_values($list);
+  }
+
+
+  /**
+   * Return all directories between a path and "/". Iterating over them walks
+   * from the path to the root.
+   *
+   * @param  string Path, absolute or relative to PWD.
+   * @return list   List of parent paths, including the provided path.
+   * @task   directory
+   */
+  public static function walkToRoot($path) {
+    $path = self::resolvePath($path);
+    if ($path == '/') {
+      return array('/');
+    }
+
+    $walk = array();
+    $parts = explode('/', $path);
+    foreach ($parts as $k => $part) {
+      if (!strlen($part)) {
+        unset($parts[$k]);
+      }
+    }
+    do {
+      $walk[] = '/'.implode('/', $parts);
+      if (empty($parts)) {
+        break;
+      }
+      array_pop($parts);
+    } while (true);
+
+    return $walk;
+  }
+
+
+/* -(  Paths  )-------------------------------------------------------------- */
+
+
+  /**
+   * Canonicalize a path by resolving it relative to some directory (by
+   * default PWD), following parent symlinks and removing artifacts. If the
+   * path is itself a symlink it is left unresolved.
+   *
+   * @param  string    Path, absolute or relative to PWD.
+   * @return string    Canonical, absolute path.
+   *
+   * @task   path
+   */
+  public static function resolvePath($path, $relative_to = null) {
+    if (strncmp($path, '/', 1)) {
+      if (!$relative_to) {
+        $relative_to = $_SERVER['PWD'];
+      }
+      $path = $relative_to.'/'.$path;
+    }
+
+    if (is_link($path)) {
+      $parent_realpath = realpath(dirname($path));
+      if ($parent_realpath !== false) {
+        return $parent_realpath.'/'.basename($path);
+      }
+    }
+
+    $realpath = realpath($path);
+    if ($realpath !== false) {
+      return $realpath;
+    }
+
+    // This won't work if the file doesn't exist or is on an unreadable mount
+    // or something crazy like that. Try to resolve a parent so we at least
+    // cover the nonexistent file case.
+    $parts = explode('/', trim($path, '/'));
+    while (end($parts) !== false) {
+      array_pop($parts);
+      $attempt = '/'.implode('/', $parts);
+      $realpath = realpath($attempt);
+      if ($realpath !== false) {
+        $path = $realpath.substr($path, strlen($attempt));
+        break;
+      }
+    }
+
+    return $path;
+  }
+
+  /**
+   * Test whether a path is descendant from some root path after resolving all
+   * symlinks and removing artifacts. Both paths must exists for the relation
+   * to obtain. A path is always a descendant of itself as long as it exists.
+   *
+   * @param  string   Child path, absolute or relative to PWD.
+   * @param  string   Root path, absolute or relative to PWD.
+   * @return bool     True if resolved child path is in fact a descendant of
+   *                  resolved root path and both exist.
+   * @task   path
+   */
+  public static function isDescendant($path, $root) {
+
+    try {
+      self::assertExists($path);
+      self::assertExists($root);
+    } catch (FilesystemException $e) {
+      return false;
+    }
+    $fs = new FileList(array($root));
+    return $fs->contains($path);
+  }
+
+  /**
+   * Convert a canonical path to its most human-readable format. It is
+   * guaranteed that you can use resolvePath() to restore a path to its
+   * canonical format.
+   *
+   * @param  string    Path, absolute or relative to PWD.
+   * @param  string    Optionally, working directory to make files readable
+   *                   relative to.
+   * @return string    Human-readable path.
+   *
+   * @task   path
+   */
+  public static function readablePath($path, $pwd = null) {
+    if ($pwd === null) {
+      $pwd = $_SERVER['PWD'];
+    }
+
+    foreach (array($pwd, self::resolvePath($pwd)) as $parent) {
+      $parent = rtrim($parent, '/').'/';
+      $len = strlen($parent);
+      if (!strncmp($parent, $path, $len)) {
+        $path = substr($path, $len);
+        return $path;
+      }
+    }
+
+    return $path;
+  }
+
+  /**
+   * Determine whether or not a path exists in the filesystem. This differs from
+   * file_exists() in that it returns true for symlinks. This method does not
+   * attempt to resolve paths before testing them.
+   *
+   * @param   string  Test for the existence of this path.
+   * @return  bool    True if the path exists in the filesystem.
+   * @task    path
+   */
+  public static function pathExists($path) {
+    return file_exists($path) || is_link($path);
+  }
+
+
+  /**
+   * Determine if two paths are equivalent by resolving symlinks. This is
+   * different from resolving both paths and comparing them because
+   * resolvePath() only resolves symlinks in parent directories, not the
+   * path itself.
+   *
+   * @param string First path to test for equivalence.
+   * @param string Second path to test for equivalence.
+   * @return bool  True if both paths are equivalent, i.e. reference the same
+   *               entity in the filesystem.
+   * @task path
+   */
+  public static function pathsAreEquivalent($u, $v) {
+    $u = Filesystem::resolvePath($u);
+    $v = Filesystem::resolvePath($v);
+
+    $real_u = realpath($u);
+    $real_v = realpath($v);
+
+    if ($real_u) {
+      $u = $real_u;
+    }
+    if ($real_v) {
+      $v = $real_v;
+    }
+    return ($u == $v);
+  }
+
+
+/* -(  Assert  )------------------------------------------------------------- */
+
+  /**
+   * Assert that something (e.g., a file, directory, or symlink) is an
+   * absolute path to the specified location.
+   *
+   * @param  string    Assert that this path is absolute.
+   * @return void
+   *
+   * @task   assert
+   */
+  public static function assertAbsolute($path) {
+    if (empty($path) || $path[0] != '/') {
+      throw new FilesystemException(
+        $path,
+        "Filesystem entity `{$path}' is not absolute.");
+    }
+  }
+
+  /**
+   * Assert that something (e.g., a file, directory, or symlink) exists at a
+   * specified location.
+   *
+   * @param  string    Assert that this path exists.
+   * @return void
+   *
+   * @task   assert
+   */
+  public static function assertExists($path) {
+    if (!self::pathExists($path)) {
+      throw new FilesystemException(
+        $path,
+        "Filesystem entity `{$path}' does not exist.");
+    }
+  }
+
+
+  /**
+   * Assert that nothing exists at a specified location.
+   *
+   * @param  string    Assert that this path does not exist.
+   * @return void
+   *
+   * @task   assert
+   */
+  public static function assertNotExists($path) {
+    if (file_exists($path) || is_link($path)) {
+      throw new FilesystemException(
+        $path,
+        "Path `{$path}' already exists!");
+    }
+  }
+
+
+  /**
+   * Assert that a path represents a file, strictly (i.e., not a directory).
+   *
+   * @param  string    Assert that this path is a file.
+   * @return void
+   *
+   * @task   assert
+   */
+  public static function assertIsFile($path) {
+    if (!is_file($path)) {
+      throw new FilesystemException(
+        $path,
+        "Requested path `{$path}' is not a file.");
+    }
+  }
+
+
+  /**
+   * Assert that a path represents a directory, strictly (i.e., not a file).
+   *
+   * @param  string    Assert that this path is a directory.
+   * @return void
+   *
+   * @task   assert
+   */
+  public static function assertIsDirectory($path) {
+    if (!is_dir($path)) {
+      throw new FilesystemException(
+        $path,
+        "Requested path `{$path}' is not a directory.");
+    }
+  }
+
+
+  /**
+   * Assert that a file or directory exists and is writable.
+   *
+   * @param  string    Assert that this path is writable.
+   * @return void
+   *
+   * @task   assert
+   */
+  public static function assertWritable($path) {
+    if (!is_writable($path)) {
+      throw new FilesystemException(
+        $path,
+        "Requested path `{$path}' is not writable.");
+    }
+  }
+
+
+  /**
+   * Assert that a file or directory exists and is readable.
+   *
+   * @param  string    Assert that this path is readable.
+   * @return void
+   *
+   * @task   assert
+   */
+  public static function assertReadable($path) {
+    if (!is_readable($path)) {
+      throw new FilesystemException(
+        $path,
+        "Path `{$path}' is not readable.");
+    }
+  }
+}
diff --git a/src/filesystem/FilesystemException.php b/src/filesystem/FilesystemException.php
new file mode 100644
index 0000000..ff8d6ad
--- /dev/null
+++ b/src/filesystem/FilesystemException.php
@@ -0,0 +1,50 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Exception thrown by Filesystem to indicate an error accessing the file
+ * system.
+ */
+class FilesystemException extends Exception {
+
+  protected $path;
+
+  /**
+   * Create a new FilesystemException, providing a path and a message.
+   *
+   * @param  string  Path that caused the failure.
+   * @param  string  Description of the failure.
+   */
+  public function __construct($path, $message) {
+    $this->path = $path;
+    parent::__construct($message);
+  }
+
+
+  /**
+   * Retrieve the path associated with the exception. Generally, this is
+   * something like a path that couldn't be read or written, or a path that
+   * was expected to exist but didn't.
+   *
+   * @return string  Path associated with the exception.
+   */
+  public function getPath() {
+    return $this->path;
+  }
+
+}
diff --git a/src/filesystem/__init__.php b/src/filesystem/__init__.php
new file mode 100644
index 0000000..758ebbf
--- /dev/null
+++ b/src/filesystem/__init__.php
@@ -0,0 +1,14 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'filesystem/filelist');
+phutil_require_module('phutil', 'future/exec');
+
+
+phutil_require_source('Filesystem.php');
+phutil_require_source('FilesystemException.php');
diff --git a/src/filesystem/filefinder/FileFinder.php b/src/filesystem/filefinder/FileFinder.php
new file mode 100644
index 0000000..375157c
--- /dev/null
+++ b/src/filesystem/filefinder/FileFinder.php
@@ -0,0 +1,148 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * PHP API for `find`.
+ */
+class FileFinder {
+
+  protected $root;
+  protected $exclude = array();
+  protected $paths = array();
+  protected $suffix = array();
+  protected $type;
+  protected $generateChecksums = false;
+
+  public function __construct($root) {
+    $this->root = $root;
+  }
+
+  public function excludePath($path) {
+    $this->exclude[] = $path;
+    return $this;
+  }
+
+  public function withSuffix($suffix) {
+    $this->suffix[] = '*.'.$suffix;
+    return $this;
+  }
+
+  public function withPath($path) {
+    $this->paths[] = $path;
+    return $this;
+  }
+
+  public function withType($type) {
+    $this->type = $type;
+    return $this;
+  }
+
+  public function setGenerateChecksums($generate) {
+    $this->generateChecksums = $generate;
+    return $this;
+  }
+
+  public function find() {
+    $args = array();
+    $command = array();
+
+    $command[] = '(cd %s; ';
+    $args[] = $this->root;
+
+    $command[] = 'find .';
+
+    if ($this->exclude) {
+      $command[] = $this->generateList('path', $this->exclude).' -prune';
+      $command[] = '-o';
+    }
+
+    if ($this->type) {
+      $command[] = '-type %s';
+      $args[] = $this->type;
+    }
+
+    if ($this->suffix) {
+      $command[] = $this->generateList('name', $this->suffix);
+    }
+
+    if ($this->paths) {
+      $command[] = $this->generateList('wholename', $this->paths);
+    }
+
+    $command[] = '-print0';
+
+    if ($this->generateChecksums) {
+      static $md5sum_binary = null;
+      if ($md5sum_binary == null) {
+
+        $options = array(
+          'md5sum' => 'md5sum',
+          'md5'    => 'md5 -r',
+        );
+        foreach ($options as $bin => $choose) {
+          list($err) = exec_manual('which %s', $bin);
+          if ($err == 0) {
+            $md5sum_binary = $choose;
+            break;
+          }
+        }
+        if ($md5sum_binary === null) {
+          throw new Exception(
+            "Unable to locate the md5/md5sum binary for this system.");
+        }
+      }
+      $command[] = ' | xargs -0 -n512 '.$md5sum_binary;
+    }
+
+    $command[] = ')';
+
+    list($stdout) = call_user_func_array(
+      'execx',
+      array_merge(
+        array(implode(' ', $command)),
+        $args));
+
+    if (!$this->generateChecksums) {
+      return explode("\0", trim($stdout));
+    } else {
+      $stdout = trim($stdout);
+      $map = array();
+      foreach (explode("\n", $stdout) as $line) {
+        $file = substr($line, 34);
+        if ($file == '-') {
+          continue;
+        }
+        // This mess is to make this class work on both mainline Linux systems
+        // and OSX, which has subtly different 'find' semantics.
+        $file = $this->root.ltrim($file, '.');
+        $map[$file] = substr($line, 0, 32);
+      }
+      return $map;
+    }
+  }
+
+  protected function generateList($flag, array $items) {
+    $items = array_map('escapeshellarg', $items);
+    foreach ($items as $key => $item) {
+      $items[$key] = '-'.$flag.' '.$item;
+    }
+    $items = implode(' -o ', $items);
+    return '\\( '.$items.' \\)';
+  }
+}
+
diff --git a/src/filesystem/filefinder/__init__.php b/src/filesystem/filefinder/__init__.php
new file mode 100644
index 0000000..81a048a
--- /dev/null
+++ b/src/filesystem/filefinder/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'future/exec');
+
+
+phutil_require_source('FileFinder.php');
diff --git a/src/filesystem/filelist/FileList.php b/src/filesystem/filelist/FileList.php
new file mode 100644
index 0000000..b7285bb
--- /dev/null
+++ b/src/filesystem/filelist/FileList.php
@@ -0,0 +1,89 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A list of files, e.g. from command line arguments.
+ */
+class FileList {
+
+  protected $files = array();
+  protected $dirs  = array();
+
+  /**
+   * Build a new FileList from an array of paths, e.g. from $argv.
+   *
+   * @param  list  List of relative or absolute file paths.
+   */
+  public function __construct($paths) {
+    foreach ($paths as $path) {
+      $path = Filesystem::resolvePath($path);
+      if (is_dir($path)) {
+        $path = rtrim($path, '/').'/';
+        $this->dirs[$path] = true;
+      }
+      $this->files[] = $path;
+    }
+  }
+
+
+  /**
+   * Determine if a path is one of the paths in the list. Note that an empty
+   * file list is considered to contain every file.
+   *
+   * @param  string  Relative or absolute system file path.
+   * @param  bool    If true, consider the path to be contained in the list if
+   *                 the list contains a parent directory. If false, require
+   *                 that the path be part of the list explicitly.
+   * @return bool    If true, the file is in the list.
+   */
+  public function contains($path, $allow_parent_directory = true) {
+
+    if ($this->isEmpty()) {
+      return true;
+    }
+
+    $path = Filesystem::resolvePath($path);
+    if (is_dir($path)) {
+      $path .= '/';
+    }
+
+    foreach ($this->files as $file) {
+      if ($file == $path) {
+        return true;
+      }
+      if ($allow_parent_directory) {
+        $len = strlen($file);
+        if (isset($this->dirs[$file]) && !strncmp($file, $path, $len)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+
+  /**
+   *  Check if the file list is empty -- that is, it contains no files.
+   *
+   *  @return   bool  If true, the list is empty.
+   */
+  public function isEmpty() {
+    return !$this->files;
+  }
+
+}
diff --git a/src/filesystem/filelist/__init__.php b/src/filesystem/filelist/__init__.php
new file mode 100644
index 0000000..7a542ef
--- /dev/null
+++ b/src/filesystem/filelist/__init__.php
@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_module('phutil', 'filesystem');
+
+phutil_require_source('FileList.php');
diff --git a/src/filesystem/tempfile/TempFile.php b/src/filesystem/tempfile/TempFile.php
new file mode 100644
index 0000000..61f5a61
--- /dev/null
+++ b/src/filesystem/tempfile/TempFile.php
@@ -0,0 +1,69 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Simple wrapper to guarantee temp file will be deleted on
+ * object destruction. Used like a string to path:
+ *
+ *    $temp = new TempFile();
+ *    Filesystem::writeFile($temp, 'Hello World');
+ *    echo "wrote data to path: {$temp}";
+ *
+ * The extra parameter $dir can be used to specify which temporary diretcory
+ * you want to create your file inside.  If not specified, it will create a
+ * temp directory for your temp file.
+ *
+ * The class tries to be smart about what you mean to do.  For example, if you
+ * don't specify a $dir to write to but give a filename, then it thinks you need
+ * a temporary file of that exact filename.  If however you do specify a
+ * temporary directory to write to, then it assumes you can't guarantee that
+ * $filename is unique and that you want this class to handle the automatic
+ * destruction of $filename when done.
+ *
+ * Throws Filesystem exceptions for errors.
+ */
+class TempFile {
+  protected $dir;
+  protected $file;
+
+  public function __construct($filename = null, $dir = null) {
+    $this->dir  = Filesystem::createTemporaryDirectory();
+    if ($filename === null) {
+      $this->file = tempnam($this->dir, getmypid().'-');
+    } else {
+      $this->file = $this->dir.'/'.$filename;
+    }
+
+    Filesystem::writeFile($this, '');
+  }
+
+  public function __toString() {
+    return $this->file;
+  }
+
+  public function __destruct() {
+    Filesystem::remove($this->dir);
+    // Note that the function tempnam() doesn't guarantee it will return a
+    // file inside the dir you passed to the function.
+    @unlink($this->file);
+  }
+
+  public function preserve() {
+    $this->destroy = false;
+  }
+}
diff --git a/src/filesystem/tempfile/__init__.php b/src/filesystem/tempfile/__init__.php
new file mode 100644
index 0000000..c4e7a89
--- /dev/null
+++ b/src/filesystem/tempfile/__init__.php
@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_module('phutil', 'filesystem');
+phutil_require_source('TempFile.php');
diff --git a/src/future/Future.php b/src/future/Future.php
new file mode 100644
index 0000000..0dc2950
--- /dev/null
+++ b/src/future/Future.php
@@ -0,0 +1,200 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * A 'future' or 'promise' is an object which acts as a proxy for the output
+ * of some process which hasn't completed yet. For instance, you might create
+ * a future that references the result of a system command. While the command
+ * is executing asynchronously, you can do other computation in your PHP
+ * process and pass around the future as a reference to the eventual results
+ * of the expensive computation. When you need those results, you resolve the
+ * future. If the result isn't ready yet, this makes the PHP process block
+ * until the external process has completed.
+ *
+ * Futures are a little bit tricky to understand, but provide a very simple
+ * way to express parallel execution.
+ */
+abstract class Future {
+
+  protected static $handlerInstalled = null;
+
+  protected $result;
+  protected $exception;
+
+  /**
+   * Is this future's process complete? Specifically, can this future be
+   * resolved without blocking?
+   *
+   * @return bool  If true, the external process is complete and resolving this
+   *               future will not block.
+   */
+  abstract public function isReady();
+
+  /**
+   * Resolve a future and return its result, blocking until the result is ready
+   * if necessary.
+   *
+   * @param  float Optional timeout after which resolution will pause and
+   *               execution will return to the caller.
+   * @return mixed Future result, or null if the timeout is hit.
+   */
+  public function resolve($timeout = null) {
+    $start = microtime(true);
+    $wait  = 1;
+    do {
+      $this->checkException();
+      if ($this->isReady()) {
+        break;
+      }
+
+      $read = $this->getReadSockets();
+      $write = $this->getWriteSockets();
+
+      if ($timeout !== null) {
+        $elapsed = microtime(true) - $start;
+        if ($elapsed > $timeout) {
+          $this->checkException();
+          return null;
+        } else {
+          $wait = $timeout - $elapsed;
+        }
+      }
+
+      if ($read || $write) {
+        self::waitForSockets($read, $write, $wait);
+      }
+    } while (true);
+
+    $this->checkException();
+    return $this->getResult();
+  }
+
+  public function setException(Exception $ex) {
+    $this->exception = $ex;
+    return $this;
+  }
+
+  public function getException() {
+    return $this->exception;
+  }
+
+
+  /**
+   * If an exception was set by setException(), throw it.
+   */
+  private function checkException() {
+    if ($this->exception) {
+      throw $this->exception;
+    }
+  }
+
+
+  /**
+   * Retrieve a list of sockets which we can wait to become readable while
+   * a future is resolving. If your future has sockets which can be select()ed,
+   * return them here (or in getWriteSockets()) to make the resolve loop do a
+   * select(). If you do not return sockets in either case, you'll get a busy
+   * wait.
+   *
+   * @return list  A list of sockets which we expect to become readable.
+   */
+  public function getReadSockets() {
+    return array();
+  }
+
+
+  /**
+   * Retrieve a list of sockets which we can wait to become writable while a
+   * future is resolving. See getReadSockets().
+   *
+   * @return list  A list of sockets which we expect to become writable.
+   */
+  public function getWriteSockets() {
+    return array();
+  }
+
+
+  /**
+   * Wait for activity on one of several sockets.
+   *
+   * @param  list  List of sockets expected to become readable.
+   * @param  list  List of sockets expected to become writable.
+   * @param  float Timeout, in seconds.
+   * @return void
+   */
+  public static function waitForSockets(
+    array $read_list,
+    array $write_list,
+    $timeout = 1) {
+    if (!self::$handlerInstalled) {
+      //  If we're spawning child processes, we need to install a signal handler
+      //  here to catch cases like execing '(sleep 60 &) &' where the child
+      //  exits but a socket is kept open. But we don't actually need to do
+      //  anything because the SIGCHLD will interrupt the stream_select(), as
+      //  long as we have a handler registered.
+      if (function_exists('pcntl_signal')) {
+        if (!pcntl_signal(SIGCHLD, array('Future', 'handleSIGCHLD'))) {
+          throw new Exception('Failed to install signal handler!');
+        }
+      }
+      self::$handlerInstalled = true;
+    }
+
+    $timeout_sec = (int)$timeout;
+    $timeout_usec = (int)(1000000 * ($timeout - $timeout_sec));
+
+    $exceptfds = array();
+    $ok = @stream_select(
+      $read_list,
+      $write_list,
+      $exceptfds,
+      $timeout,
+      $timeout_usec);
+
+    if ($ok === false) {
+      // Hopefully, means we received a SIGCHLD. In the worst case, we degrade
+      // to a busy wait.
+    }
+  }
+
+  public static function handleSIGCHLD($signo) {
+    // This function is a dummy, we just need to have some handler registered
+    // so that PHP will get interrupted during stream_select(). If we don't
+    // register a handler, stream_select() won't fail.
+  }
+
+
+  /**
+   * Retrieve the final result of the future. This method will be called after
+   * the future is ready (as per isReady()) but before results are passed back
+   * to the caller. The major use of this function is that you can override it
+   * in subclasses to do postprocessing or error checking, which is
+   * particularly useful if building application-specific futures on top of
+   * primitive transport futures (like CurlFuture and ExecFuture) which can
+   * make it tricky to hook this logic into the main pipeline.
+   *
+   * @return mixed   Final resolution of this future.
+   */
+  protected function getResult() {
+    return $this->result;
+  }
+
+  public function start() {
+    $this->isReady();
+  }
+}
diff --git a/src/future/FutureIterator.php b/src/future/FutureIterator.php
new file mode 100644
index 0000000..50dfb15
--- /dev/null
+++ b/src/future/FutureIterator.php
@@ -0,0 +1,251 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function Futures($futures) {
+  return new FutureIterator($futures);
+}
+
+/**
+ * FutureIterator aggregates @{class:Future}s and allows you to respond to them
+ * in the order they resolve. This is useful because it minimizes the amount of
+ * time your program spends waiting on parallel processes.
+ *
+ *  $futures = array(
+ *    'a.txt' => new ExecFuture('wc -c a.txt'),
+ *    'b.txt' => new ExecFuture('wc -c b.txt'),
+ *    'c.txt' => new ExecFuture('wc -c c.txt'),
+ *  );
+ *  foreach (Futures($futures) as $key => $future) {
+ *    // IMPORTANT: keys are preserved but the order of elements is not. This
+ *    // construct iterates over the futures in the order they resolve, so the
+ *    // fastest future is the one you'll get first. This allows you to start
+ *    // doing followup processing as soon as possible.
+ *
+ *    list($stdout) = $future->resolvex();
+ *    do_some_processing($stdout);
+ *  }
+ *
+ *
+ */
+class FutureIterator implements Iterator {
+
+  protected $wait     = array();
+  protected $work     = array();
+  protected $futures  = array();
+  protected $key;
+
+  protected $limit;
+
+  protected $timeout;
+  protected $isTimeout = false;
+
+  public function __construct(array $futures) {
+    foreach ($futures as $future) {
+      if (!$future instanceof Future) {
+        throw new Exception('Futures must all be objects implementing Future.');
+      }
+    }
+    $this->futures = $futures;
+  }
+
+  /**
+   * Set a maximum amount of time you want to wait before the iterator will
+   * yield a result. If no future has resolved yet, the iterator will yield
+   * null for key and value. Among other potential uses, you can use this to
+   * show some busy indicator:
+   *
+   *   foreach (Futures($futures)->setUpdateInterval(1) as $future) {
+   *     if ($future === null) {
+   *       echo "Still working...\n";
+   *     } else {
+   *       // ...
+   *     }
+   *   }
+   *
+   * This will echo "Still working..." once per second as long as futures are
+   * resolving. By default, FutureIterator never yields null.
+   *
+   * @param float Maximum number of seconds to block waiting on futures before
+   *              yielding null.
+   * @return this
+   */
+  public function setUpdateInterval($interval) {
+    $this->timeout = $interval;
+    return $this;
+  }
+
+  public function rewind() {
+    $this->wait = array_keys($this->futures);
+    $this->work = null;
+    $this->updateWorkingSet();
+    $this->next();
+  }
+
+  protected function getWorkingSet() {
+    if ($this->work === null) {
+      return $this->wait;
+    }
+
+    return $this->work;
+  }
+
+  protected function updateWorkingSet() {
+    if (!$this->limit) {
+      $this->work = null;
+    }
+
+    $old = $this->work;
+    $this->work = array_slice($this->wait, 0, $this->limit, true);
+
+    //  If we're using a limit, our futures are sleeping and need to be polled
+    //  to begin execution, so poll any futures which weren't in our working set
+    //  before.
+    foreach ($this->work as $work => $key) {
+      if (!isset($old[$work])) {
+        $this->futures[$key]->isReady();
+      }
+    }
+  }
+
+  public function next() {
+    $this->key = null;
+    if (!count($this->wait)) {
+      return;
+    }
+
+    $read_sokcets = array();
+    $write_sockets = array();
+
+    $start = microtime(true);
+    $wait_time = 1;
+    $timeout = $this->timeout;
+    $this->isTimeout = false;
+
+    $check = $this->getWorkingSet();
+    $resolve = null;
+    do {
+      $read_sockets    = array();
+      $write_sockets   = array();
+      $can_use_sockets = true;
+      foreach ($check as $wait => $key) {
+        $future = $this->futures[$key];
+        try {
+          if ($future->getException()) {
+            $resolve = $wait;
+            continue;
+          }
+          if ($future->isReady()) {
+            if ($resolve === null) {
+              $resolve = $wait;
+            }
+            continue;
+          }
+
+          $got_sockets = false;
+          $socks = $future->getReadSockets();
+          if ($socks) {
+            $got_sockets = true;
+            foreach ($socks as $socket) {
+              $read_sockets[] = $socket;
+            }
+          }
+
+          $socks = $future->getWriteSockets();
+          if ($socks) {
+            $got_sockets = true;
+            foreach ($socks as $socket) {
+              $write_sockets[] = $socket;
+            }
+          }
+
+          // If any currently active future had neither read nor write sockets,
+          // we can't wait for the current batch of items using sockets.
+          if (!$got_sockets) {
+            $can_use_sockets = false;
+          }
+        } catch (Exception $ex) {
+          $this->futures[$key]->setException($ex);
+          $resolve = $wait;
+          break;
+        }
+      }
+      if ($resolve === null) {
+        if ($can_use_sockets) {
+
+          if ($timeout !== null) {
+            $elapsed = microtime(true) - $start;
+            if ($elapsed > $timeout) {
+              $this->isTimeout = true;
+              return;
+            } else {
+              $wait_time = $timeout - $elapsed;
+            }
+          }
+
+          Future::waitForSockets($read_sockets, $write_sockets, $wait_time);
+        } else {
+          usleep(1000);
+        }
+      }
+    } while ($resolve === null);
+
+    $this->key = $this->wait[$resolve];
+    unset($this->wait[$resolve]);
+    $this->updateWorkingSet();
+  }
+
+
+  public function current() {
+    if ($this->isTimeout) {
+      return null;
+    }
+    return $this->futures[$this->key];
+  }
+
+  public function key() {
+    if ($this->isTimeout) {
+      return null;
+    }
+    return $this->key;
+  }
+
+  public function valid() {
+    if ($this->isTimeout) {
+      return true;
+    }
+    return ($this->key !== null);
+  }
+
+  public function resolveAll() {
+    foreach ($this as $_) {
+      // This implicitly forces all the futures to resolve.
+    }
+  }
+
+  /**
+   * Limits the number of simultaneous tasks.
+   *
+   * @param int Maximum number of simultaneous jobs allowed.
+   * @return this
+   */
+  public function limit($max) {
+    $this->limit = $max;
+    return $this;
+  }
+
+}
diff --git a/src/future/__init__.php b/src/future/__init__.php
new file mode 100644
index 0000000..7c15f3c
--- /dev/null
+++ b/src/future/__init__.php
@@ -0,0 +1,20 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_source('Future.php');
+phutil_require_source('FutureIterator.php');
diff --git a/src/future/exec/CommandException.php b/src/future/exec/CommandException.php
new file mode 100644
index 0000000..a37d2b8
--- /dev/null
+++ b/src/future/exec/CommandException.php
@@ -0,0 +1,53 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Exception thrown when a system command fails.
+ */
+class CommandException extends Exception {
+
+  protected $command;
+  protected $stdout;
+  protected $stderr;
+  protected $error;
+
+  public function __construct($message, $command, $error, $stdout, $stderr) {
+    parent::__construct($message);
+    $this->command = $command;
+    $this->error = $error;
+    $this->stdout = $stdout;
+    $this->stderr = $stderr;
+  }
+
+  public function getCommand() {
+    return $this->command;
+  }
+
+  public function getError() {
+    return $this->error;
+  }
+
+  public function getStdout() {
+    return $this->stdout;
+  }
+
+  public function getStderr() {
+    return $this->stderr;
+  }
+}
+
diff --git a/src/future/exec/ExecFuture.php b/src/future/exec/ExecFuture.php
new file mode 100644
index 0000000..92c9806
--- /dev/null
+++ b/src/future/exec/ExecFuture.php
@@ -0,0 +1,358 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Execute system commands in parallel using futures.
+ *
+ *  // execx() API: synchronous, throws on nonzero exit code
+ *  list($stdout, $stderr) = execx('wc -l %s', $file);
+ *
+ *  // exec_manual() API: synchronous, returns exit code
+ *  list($err, $stdout, $stderr) = exec_manual('wc -l %s', $file);
+ *
+ *  // Raw ExecFuture API: asynchronous
+ *  $future = new ExecFuture(
+ *    csprintf('wc -l %s'),
+ *    $file);
+ *
+ *  list($err, $stdout, $stderr) = $future->resolve();
+ *
+ *  // ...or, throw on nonzero exit with 'resolvex()'.
+ *  list($stdout, $stderr) = $future->resolvex();
+ */
+
+class ExecFuture extends Future {
+
+  const TIMED_OUT_EXIT_CODE = 142;
+
+  protected $pipes        = array();
+  protected $proc         = null;
+  protected $start        = null;
+  protected $timeout      = null;
+
+  protected $stdout       = null;
+  protected $stderr       = null;
+  protected $stdin        = null;
+  protected $closePipe    = false;
+
+  protected $stdoutPos    = 0;
+  protected $stderrPos    = 0;
+  protected $command      = null;
+
+  protected $stdoutSizeLimit = PHP_INT_MAX;
+  protected $stderrSizeLimit = PHP_INT_MAX;
+
+  protected static $echoMode = array();
+  protected static $descriptorSpec = array(
+    0 => array('pipe', 'r'),  // stdin
+    1 => array('pipe', 'w'),  // stdout
+    2 => array('pipe', 'w'),  // stderr
+  );
+
+
+  public static function pushEchoMode($mode) {
+    self::$echoMode[] = $mode;
+  }
+
+  public static function popEchoMode() {
+    array_pop(self::$echoMode);
+  }
+
+  public static function peekEchoMode() {
+    return end(self::$echoMode);
+  }
+
+  public function setStdoutSizeLimit($limit) {
+    $this->stdoutSizeLimit = $limit;
+  }
+
+  public function getStdoutSizeLimit() {
+    return $this->stdoutSizeLimit;
+  }
+
+  public function setStderrSizeLimit($limit) {
+    $this->stderrSizeLimit = $limit;
+  }
+
+  public function getStderrSizeLimit() {
+    return $this->stderrSizeLimit;
+  }
+
+  public function __construct($command) {
+    $argv = func_get_args();
+    $this->command = call_user_func_array('csprintf', $argv);
+  }
+
+  public function __destruct() {
+    foreach ($this->pipes as $pipe) {
+      if (isset($pipe)) {
+        @fclose($pipe);
+      }
+    }
+    $this->pipes  = array(null, null, null);
+    if ($this->proc) {
+      @proc_close($this->proc);
+      $this->proc = null;
+    }
+    $this->stdin  = null;
+  }
+
+  public function getCommand() {
+    return $this->command;
+  }
+
+  public function read() {
+    if ($this->start) {
+      $this->isReady(); // Sync
+    }
+
+    $result = array(
+      (string)substr($this->stdout, $this->stdoutPos),
+      (string)substr($this->stderr, $this->stderrPos),
+    );
+
+    $this->stdoutPos = strlen($this->stdout);
+    $this->stderrPos = strlen($this->stderr);
+
+    return $result;
+  }
+
+  public function write($data, $keep_pipe = false) {
+    $this->stdin .= $data;
+
+    if (!$keep_pipe) {
+      $this->closePipe = true;
+    }
+
+    if ($this->start) {
+      $this->isReady(); // Sync
+    }
+
+    return $this;
+  }
+
+  public function getReadSockets() {
+    list($stdin, $stdout, $stderr) = $this->pipes;
+    $sockets = array();
+    if (isset($stdout) && !feof($stdout)) {
+      $sockets[] = $stdout;
+    }
+    if (isset($stderr) && !feof($stderr)) {
+      $sockets[] = $stderr;
+    }
+    return $sockets;
+  }
+
+  /**
+   * Reads some bytes from a stream, discarding output once a certain amount
+   * has been accumulated.
+   *
+   * @param resource $stream
+   *    Stream to read from.
+   * @param int $limit
+   *    Maximum number of bytes to return from $stream. If additional bytes
+   *    are available, they will be read and discarded.
+   * @param string $description
+   *    Human-readable description of stream, for exception message.
+   * @return string
+   *    The data read from the stream.
+   * @throws Exception
+   *    The stream was not readable.
+   */
+  protected function readAndDiscard($stream, $limit, $description) {
+    $output = '';
+
+    do {
+      $data = fread($stream, 4096);
+      if (false === $data) {
+        throw new Exception('Failed to read from '.$description);
+      }
+
+      $read_bytes = strlen($data);
+
+      if ($read_bytes > 0 && $limit > 0) {
+        if ($read_bytes > $limit) {
+          $data = substr($data, 0, $limit);
+        }
+        $output .= $data;
+        $limit -= strlen($data);
+      }
+    } while ($read_bytes > 0);
+
+    return $output;
+  }
+
+  public function getWriteSockets() {
+    list($stdin, $stdout, $stderr) = $this->pipes;
+    $sockets = array();
+    if (isset($stdin) && strlen($this->stdin) && !feof($stdin)) {
+      $sockets[] = $stdin;
+    }
+    return $sockets;
+  }
+
+  public function isReady() {
+
+    if (!$this->pipes) {
+
+      if (self::peekEchoMode()) {
+        echo "  >>> \$ {$this->command}\n";
+      }
+
+      $pipes = array();
+      $proc = proc_open($this->command, self::$descriptorSpec, $pipes);
+      if (!is_resource($proc)) {
+        throw new Exception('Failed to open process.');
+      }
+
+      $this->start = time();
+      $this->pipes = $pipes;
+      $this->proc  = $proc;
+
+      list($stdin, $stdout, $stderr) = $pipes;
+
+      if ((!stream_set_blocking($stdout, false)) ||
+          (!stream_set_blocking($stderr, false)) ||
+          (!stream_set_blocking($stdin,  false))) {
+        $this->__destruct();
+        throw new Exception('Failed to set streams nonblocking.');
+      }
+
+      return false;
+    }
+
+    if (!$this->proc) {
+      return true;
+    }
+
+    list($stdin, $stdout, $stderr) = $this->pipes;
+
+    if (isset($this->stdin) && strlen($this->stdin)) {
+      $bytes = fwrite($stdin, $this->stdin);
+      if ($bytes === false) {
+        throw new Exception('Unable to write to stdin!');
+      } else if ($bytes) {
+        $this->stdin = substr($this->stdin, $bytes);
+      }
+
+      if (!strlen($this->stdin) && $this->closePipe) {
+        @fclose($stdin);
+        $this->pipes[0] = null;
+      }
+    } else {
+      // make sure to remove any references to the pipe in the case when stdin
+      // length was zero. avoid the overhead of calling fclose() as it is not
+      // necessary.
+      $this->pipes[0] = null;
+    }
+
+    //  Read status before reading pipes so that we can never miss data that
+    //  arrives between our last read and the process exiting.
+    $status = proc_get_status($this->proc);
+
+    $this->stdout .= $this->readAndDiscard(
+      $stdout,
+      $this->getStdoutSizeLimit() - strlen($this->stdout),
+      'stdout');
+    $this->stderr .= $this->readAndDiscard(
+      $stderr,
+      $this->getStderrSizeLimit() - strlen($this->stderr),
+      'stderr');
+
+    if (!$status['running']) {
+      $this->result = array(
+        $status['exitcode'],
+        $this->stdout,
+        $this->stderr,
+      );
+      $this->__destruct();
+      return true;
+    }
+
+    if ($this->timeout && ((time() - $this->start) >= $this->timeout)) {
+      if (defined('SIGKILL')) {
+        $signal = SIGKILL;
+      } else {
+        $signal = 9;
+      }
+      proc_terminate($this->proc, $signal);
+      $this->result = array(
+        self::TIMED_OUT_EXIT_CODE,
+        $this->stdout,
+        $this->stderr."\n".
+        "(This process was prematurely terminated by timeout.)");
+     $this->__destruct();
+     return true;
+    }
+
+  }
+
+  public function setTimeout($seconds) {
+    $this->timeout = $seconds;
+    return $this;
+  }
+
+  public function resolve($timeout = null) {
+    if (null === $timeout) {
+      $timeout = $this->timeout;
+    }
+    return parent::resolve($timeout);
+  }
+
+  public function resolvex($timeout = null) {
+    list($err, $stdout, $stderr) = $this->resolve($timeout);
+    if ($err) {
+      $cmd = $this->command;
+      throw new CommandException(
+        "Command '{$cmd}' failed with error #{$err}:\n".
+        "stdout:\n{$stdout}\n".
+        "stderr:\n{$stderr}\n",
+        $cmd,
+        $err,
+        $stdout,
+        $stderr);
+    }
+    return array($stdout, $stderr);
+  }
+
+  public function resolveJSON($timeout = null) {
+    list($stdout, $stderr) = $this->resolvex($timeout);
+    if (strlen($stderr)) {
+      $cmd = $this->command;
+      throw new CommandException(
+        "JSON command '{$cmd}' emitted text to stderr when none was expected: ".
+        $stderr,
+        $cmd,
+        0,
+        $stdout,
+        $stderr);
+    }
+    $object = json_decode($stdout, true);
+    if (!is_array($object)) {
+      $cmd = $this->command;
+      throw new CommandException(
+        "JSON command '{$cmd}' did not produce a valid JSON object on stdout: ".
+        $stdout,
+        $cmd,
+        0,
+        $stdout,
+        $stderr);
+    }
+    return $object;
+  }
+}
diff --git a/src/future/exec/__init__.php b/src/future/exec/__init__.php
new file mode 100644
index 0000000..3ead0d7
--- /dev/null
+++ b/src/future/exec/__init__.php
@@ -0,0 +1,16 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'future');
+phutil_require_module('phutil', 'utils');
+phutil_require_module('phutil', 'xsprintf/csprintf');
+
+
+phutil_require_source('CommandException.php');
+phutil_require_source('ExecFuture.php');
+phutil_require_source('execx.php');
diff --git a/src/future/exec/execx.php b/src/future/exec/execx.php
new file mode 100644
index 0000000..3f0bcce
--- /dev/null
+++ b/src/future/exec/execx.php
@@ -0,0 +1,73 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Execute a command and capture stdout and stderr. If the command exits with
+ * a nonzero error code, a CommandException will be thrown. If you need to
+ * manually handle error conditions, use exec_manual().
+ *
+ *   list ($stdout, $stderr) = execx('ls %s', $file);
+ *
+ * @param  string  sprintf()-style command pattern to execute.
+ * @param  ...     Arguments to sprintf pattern.
+ * @return array   List of stdout and stderr.
+ */
+function execx($cmd /*, ... */) {
+  $args = func_get_args();
+  $future = newv('ExecFuture', $args);
+  return $future->resolvex();
+}
+
+
+/**
+ * Execute a command and capture stdout, stderr, and the return value.
+ *
+ *   list ($err, $stdout, $stderr) = exec_manual('ls %s', $file);
+ *
+ * When invoking this function, you MUST **manually** handle the error
+ * condition. Error flows can often be simplified by using execx() instead,
+ * which throws an exception when it encounters an error.
+ *
+ * @param  string  sprintf()-style command pattern to execute.
+ * @param  ...     Arguments to sprintf pattern.
+ * @return array   List of return code, stdout, and stderr.
+ */
+function exec_manual($cmd /*, ... */) {
+  $args = func_get_args();
+
+  if (ExecFuture::peekEchoMode()) {
+    ExecFuture::pushEchoMode(false);
+
+    echo "  >>> \$ {$cmd} ... ";
+    $t_start = microtime(true);
+
+      $ef = newv('ExecFuture', $args);
+      $result = $ef->resolve();
+
+    $t_end = microtime(true);
+    $duration = number_format((int)(1000 * ($t_end - $t_start))).' ms';
+    echo " {$duration}\n";
+
+    ExecFuture::popEchoMode();
+  } else {
+    $ef = newv('ExecFuture', $args);
+    $result = $ef->resolve();
+  }
+
+  return $result;
+}
diff --git a/src/future/http/HTTPFuture.php b/src/future/http/HTTPFuture.php
new file mode 100644
index 0000000..074cc4c
--- /dev/null
+++ b/src/future/http/HTTPFuture.php
@@ -0,0 +1,360 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Socket-based HTTP future, for making HTTP requests using future semantics.
+ * This is an alternative to :CURLFuture which has better resolution behavior
+ * (select()-based wait instead of busy wait) but fewer features. You should
+ * prefer this class to :CURLFuture unless you need its advanced features (like
+ * HTTP/1.1, chunked transfer encoding, gzip, etc.).
+ *
+ * Example Usage
+ *
+ *    $future = new HTTPFuture('http://www.example.com/');
+ *    list($http_response_code, $response_body, $headers) = $future->resolve();
+ */
+class HTTPFuture extends Future {
+
+  /** Remote host returned something other than an HTTP response. */
+  const ERROR_MALFORMED_RESPONSE  = 1000;
+
+  /** Future walltime exceeded the allowable walltime (see setTimeout()). */
+  const ERROR_TIMEOUT             = 1001;
+
+  /** Connection was aborted before writing was complete. */
+  const ERROR_CONNECTION_ABORTED  = 1002;
+
+  /** Connection was refused by remote host. */
+  const ERROR_CONNECTION_REFUSED  = 1003;
+
+  /** Connection failed entirely, hostname is probably invalid. */
+  const ERROR_CONNECTION_FAILED   = 1004;
+
+  protected $method   = 'GET';
+  protected $uri;
+  protected $data;
+  protected $host;
+  protected $port     = 80;
+  protected $timeout  = 30.0;
+  /**
+   * Whether to log debugging output to scribe.  Hopefully, this will be a
+   * short-term measure.
+   */
+  private $debug = false;
+  /**
+   * A string intended to uniquely identify this HTTPFuture for debugging
+   * purposes.
+   */
+  private $debugFutureID = null;
+
+  protected $socket;
+  protected $writeBuffer;
+  protected $response;
+  protected $headers  = array();
+
+  protected $stateConnected     = false;
+  protected $stateWriteComplete = false;
+  protected $stateReady         = false;
+  protected $stateStartTime;
+
+  public function __construct($uri, array $data = array()) {
+    $this->data = $data;
+
+    $parts = parse_url($uri);
+    if (!$parts) {
+      throw new Exception("Could not parse URI '{$uri}'.");
+    }
+
+    if (empty($parts['scheme']) || $parts['scheme'] !== 'http') {
+      throw new Exception(
+        "URI '{$uri}' must be fully qualified with 'http://' scheme.");
+    }
+
+    if (!isset($parts['host'])) {
+      throw new Exception(
+        "URI '{$uri}' must be fully qualified and include host name.");
+    }
+
+    $this->host = $parts['host'];
+    $this->headers['Host'] = $this->host;
+
+    if (!empty($parts['port'])) {
+      $this->port = $parts['port'];
+    }
+
+    if (isset($parts['user']) || isset($parts['pass'])) {
+      throw new Exception(
+        "HTTP Basic Auth is not supported by HTTPFuture.");
+    }
+
+    if (isset($parts['path'])) {
+      $this->uri = $parts['path'];
+    } else {
+      $this->uri = '/';
+    }
+
+    if (isset($parts['query'])) {
+      $this->uri .= '?'.$parts['query'];
+    }
+
+  }
+
+  public function getURI() {
+    return $this->uri;
+  }
+
+  public function setHeader($header, $value) {
+    $this->headers[$header] = $value;
+    return $this;
+  }
+
+  public function setTimeout($timeout) {
+    $this->timeout = $timeout;
+    return $this;
+  }
+
+  public function setMethod($method) {
+    if ($method !== 'GET' && $method !== 'POST') {
+      throw new Exception('Only GET and POST are supported HTTP methods.');
+    }
+    $this->method = $method;
+    return $this;
+  }
+
+  public function __destruct() {
+    if ($this->socket) {
+      @fclose($this->socket);
+      $this->socket = null;
+    }
+  }
+
+  public function getReadSockets() {
+    if ($this->socket) {
+      return array($this->socket);
+    }
+    return array();
+  }
+
+  public function getWriteSockets() {
+    if (strlen($this->writeBuffer)) {
+      return array($this->socket);
+    }
+    return array();
+  }
+
+  public function getDefaultUserAgent() {
+    return 'HTTPFuture/1.0';
+  }
+
+  public function isReady() {
+    if ($this->stateReady) {
+      return true;
+    }
+
+    if (!$this->socket) {
+      $this->stateStartTime = microtime(true);
+      $this->socket = $this->buildSocket();
+      if (!$this->socket) {
+        return $this->stateReady;
+      }
+    }
+
+    if (!$this->stateConnected) {
+      $read   = array();
+      $write  = array($this->socket);
+      $except = array();
+      $select = stream_select($read, $write, $except, $tv_sec = 0);
+      if ($write) {
+        $this->stateConnected = true;
+      }
+    }
+
+    if ($this->stateConnected) {
+      if (strlen($this->writeBuffer)) {
+        $bytes = @fwrite($this->socket, $this->writeBuffer);
+        if ($bytes === false) {
+          throw new Exception("Failed to write to buffer.");
+        } else if ($bytes) {
+          $this->writeBuffer = substr($this->writeBuffer, $bytes);
+        }
+      }
+
+      if (!strlen($this->writeBuffer)) {
+        $this->stateWriteComplete = true;
+      }
+
+      while (($data = fread($this->socket, 32768)) || strlen($data)) {
+        $this->response .= $data;
+      }
+
+      if ($data === false) {
+        throw new Exception("Failed to read socket.");
+      }
+    }
+
+    return $this->checkSocket();
+  }
+
+  protected function buildSocket() {
+
+    $errno = null;
+    $errstr = null;
+    $socket = @stream_socket_client(
+      'tcp://'.$this->host.':'.$this->port,
+      $errno,
+      $errstr,
+      $ignored_connection_timeout = 1.0,
+      STREAM_CLIENT_CONNECT | STREAM_CLIENT_ASYNC_CONNECT);
+
+    if (!$socket) {
+      $this->stateReady = true;
+      $this->result = $this->buildErrorResult(self::ERROR_CONNECTION_FAILED);
+      return null;
+    }
+
+    $ok = stream_set_blocking($socket, 0);
+    if (!$ok) {
+      throw new Exception("Failed to set stream nonblocking.");
+    }
+
+    $this->writeBuffer = $this->buildHTTPRequest();
+
+    return $socket;
+  }
+
+  protected function checkSocket() {
+
+    $timeout = false;
+    $now = microtime(true);
+    if ($now - $this->stateStartTime > $this->timeout) {
+      $timeout = true;
+    }
+
+    if (!feof($this->socket) && !$timeout) {
+      return false;
+    }
+
+    if ($timeout) {
+      $result = $this->buildErrorResult(self::ERROR_TIMEOUT);
+    } else if (!$this->stateConnected) {
+      $result = $this->buildErrorResult(self::ERROR_CONNECTION_REFUSED);
+    } else if (!$this->stateWriteComplete) {
+      $result = $this->buildErrorResult(self::ERROR_CONNECTION_FAILED);
+    } else {
+      $result = $this->parseHTTPResponse($this->response);
+    }
+
+    $this->result     = $result;
+    $this->stateReady = true;
+
+    return true;
+  }
+
+  protected function buildErrorResult($error) {
+    return array($error, null, array());
+  }
+
+  protected function parseHTTPResponse($response) {
+
+    static $rex_base = "@^(?<head>.*?)\r?\n\r?\n(?<body>.*)$@s";
+    static $rex_head = "@^HTTP/\S+ (?<code>\d+) .*?(?:\r?\n(?<headers>.*))?$@s";
+    static $rex_header = '@^(?<name>.*?):\s*(?<value>.*)$@';
+
+    static $malformed = array(
+      self::ERROR_MALFORMED_RESPONSE,
+      null,
+      array(),
+    );
+
+    $matches = null;
+    if (!preg_match($rex_base, $response, $matches)) {
+      return $malformed;
+    }
+
+    $head = $matches['head'];
+    $body = $matches['body'];
+
+    if (!preg_match($rex_head, $head, $matches)) {
+      return $malformed;
+    }
+
+    $response_code = (int)$matches['code'];
+
+    $headers = array();
+    if (isset($matches['headers'])) {
+      $head_raw = $matches['headers'];
+      if (strlen($head_raw)) {
+        $headers_raw = preg_split("/\r?\n/", $head_raw);
+        foreach ($headers_raw as $header) {
+          $m = null;
+          if (preg_match($rex_header, $header, $m)) {
+            $headers[] = array($m['name'], $m['value']);
+          } else {
+            $headers[] = array($header, null);
+          }
+        }
+      }
+    }
+
+    return array(
+      $response_code,
+      $body,
+      $headers,
+    );
+  }
+
+  public function buildHTTPRequest() {
+    $data = http_build_query($this->data);
+    $length = strlen($data);
+
+    $force_headers = array();   // These are always sent.
+    $default_headers = array(); // These can be overridden with setHeader().
+
+    $uri = $this->uri;
+    if ($this->method == 'GET') {
+      if ($data) {
+        if (strpos($uri, '?') !== false) {
+          $uri .= '&'.$data;
+        } else {
+          $uri .= '?'.$data;
+        }
+      }
+      $data = null;
+      $length = 0;
+    } else {
+      $force_headers['Content-Type'] = 'application/x-www-form-urlencoded';
+      $data .= "\r\n";
+    }
+
+    $force_headers['Content-Length'] = $length;
+    $default_headers['User-Agent'] = $this->getDefaultUserAgent();
+
+    $headers = $force_headers + $this->headers + $default_headers;
+
+    foreach ($headers as $key => $header) {
+      $headers[$key] = $key.': '.$header."\r\n";
+    }
+
+    return
+      "{$this->method} {$uri} HTTP/1.0\r\n".
+      implode('', $headers).
+      "\r\n".
+      $data;
+  }
+
+}
diff --git a/src/future/http/__init__.php b/src/future/http/__init__.php
new file mode 100644
index 0000000..ad5947c
--- /dev/null
+++ b/src/future/http/__init__.php
@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_module('phutil', 'future');
+
+phutil_require_source('HTTPFuture.php');
diff --git a/src/markup/__init__.php b/src/markup/__init__.php
new file mode 100644
index 0000000..ed0a6cd
--- /dev/null
+++ b/src/markup/__init__.php
@@ -0,0 +1,10 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+
+phutil_require_source('render.php');
diff --git a/src/markup/engine/PhutilMarkupEngine.php b/src/markup/engine/PhutilMarkupEngine.php
new file mode 100644
index 0000000..d163a8f
--- /dev/null
+++ b/src/markup/engine/PhutilMarkupEngine.php
@@ -0,0 +1,22 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+abstract class PhutilMarkupEngine {
+  abstract public function setConfig($key, $value);
+  abstract public function markupText($text);
+}
diff --git a/src/markup/engine/__init__.php b/src/markup/engine/__init__.php
new file mode 100644
index 0000000..5d9a9ca
--- /dev/null
+++ b/src/markup/engine/__init__.php
@@ -0,0 +1,10 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+
+phutil_require_source('PhutilMarkupEngine.php');
diff --git a/src/markup/engine/remarkup/PhutilRemarkupEngine.php b/src/markup/engine/remarkup/PhutilRemarkupEngine.php
new file mode 100644
index 0000000..ee9d02f
--- /dev/null
+++ b/src/markup/engine/remarkup/PhutilRemarkupEngine.php
@@ -0,0 +1,100 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+final class PhutilRemarkupEngine extends PhutilMarkupEngine {
+
+  private $blockRules = array();
+  private $config = array();
+
+  public function setConfig($key, $value) {
+    $this->config[$key] = $value;
+    return $this;
+  }
+
+  public function getConfig($key, $default = null) {
+    return idx($this->config, $key, $default);
+  }
+
+  public function setBlockRules(array $rules) {
+    $this->blockRules = $rules;
+    return $this;
+  }
+
+  public function storeText($text) {
+    return $this->storage->store($text);
+  }
+
+  public function markupText($text) {
+    $this->storage = new PhutilRemarkupBlockStorage();
+
+    $block_rules = $this->blockRules;
+    if (empty($block_rules)) {
+      throw new Exception("Remarkup engine not configured with block rules.");
+    }
+    foreach ($block_rules as $rule) {
+      $rule->setEngine($this);
+    }
+
+    // Apply basic block and paragraph normalization to the text.
+    $text = preg_replace("/\r\n?/", "\n", $text);
+    $text = preg_replace("/[ \t]*$/m", '', $text);
+    $text = preg_split("/\n\n/", $text);
+
+    $blocks = array();
+    $last   = null;
+    foreach ($text as $block) {
+      $match = false;
+      foreach ($block_rules as $key => $block_rule) {
+        $pattern = $block_rule->getBlockPattern();
+        if (!preg_match($pattern, trim($block, "\n"))) {
+          continue;
+        }
+        if (($last !== null) &&
+            ($key == $last) &&
+            $block_rule->shouldMergeBlocks()) {
+          end($blocks);
+          $last_block_key = key($blocks);
+          $blocks[$last_block_key]['block'] .= "\n\n".$block;
+        } else {
+          $blocks[] = array(
+            'rule'  => $block_rule,
+            'block' => $block,
+          );
+        }
+        $last = $key;
+        $match = true;
+        break;
+      }
+      if (!$match) {
+        throw new Exception("Block in text did not match any block rule.");
+      }
+    }
+
+    $output = array();
+    foreach ($blocks as $block) {
+      $output[] = $block['rule']->markupText($block['block']);
+    }
+
+    $output = implode("\n\n", $output);
+    $output = $this->storage->restore($output);
+
+    unset($this->storage);
+
+    return $output;
+  }
+}
diff --git a/src/markup/engine/remarkup/__init__.php b/src/markup/engine/remarkup/__init__.php
new file mode 100644
index 0000000..1983e82
--- /dev/null
+++ b/src/markup/engine/remarkup/__init__.php
@@ -0,0 +1,14 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine');
+phutil_require_module('phutil', 'markup/engine/remarkup/blockstorage');
+phutil_require_module('phutil', 'utils');
+
+
+phutil_require_source('PhutilRemarkupEngine.php');
diff --git a/src/markup/engine/remarkup/__tests__/data/entities.txt b/src/markup/engine/remarkup/__tests__/data/entities.txt
new file mode 100755
index 0000000..1fb18a2
--- /dev/null
+++ b/src/markup/engine/remarkup/__tests__/data/entities.txt
@@ -0,0 +1,3 @@
+< > & "
+~~~~~~~~~~
+<p>&lt; &gt; &amp; &quot;</p>
\ No newline at end of file
diff --git a/src/markup/engine/remarkup/__tests__/data/leading-newline.txt b/src/markup/engine/remarkup/__tests__/data/leading-newline.txt
new file mode 100644
index 0000000..f8ba33b
--- /dev/null
+++ b/src/markup/engine/remarkup/__tests__/data/leading-newline.txt
@@ -0,0 +1,4 @@
+
+a
+~~~~~~~~~~
+<p>a</p>
\ No newline at end of file
diff --git a/src/markup/engine/remarkup/__tests__/data/link-brackets.txt b/src/markup/engine/remarkup/__tests__/data/link-brackets.txt
new file mode 100755
index 0000000..407d1d4
--- /dev/null
+++ b/src/markup/engine/remarkup/__tests__/data/link-brackets.txt
@@ -0,0 +1,3 @@
+<http://www.zany.com/omg/space url/>
+~~~~~~~~~~
+<p><a href="http://www.zany.com/omg/space url/" target="_blank">http://www.zany.com/omg/space url/</a></p>
\ No newline at end of file
diff --git a/src/markup/engine/remarkup/__tests__/data/link-with-punctuation.txt b/src/markup/engine/remarkup/__tests__/data/link-with-punctuation.txt
new file mode 100644
index 0000000..6d6f612
--- /dev/null
+++ b/src/markup/engine/remarkup/__tests__/data/link-with-punctuation.txt
@@ -0,0 +1,5 @@
+http://www.example.com/,
+http://www.example.com/..
+http://www.example.com/!!!
+~~~~~~~~~~
+<p><a href="http://www.example.com/" target="_blank">http://www.example.com/</a>,<br /><a href="http://www.example.com/" target="_blank">http://www.example.com/</a>..<br /><a href="http://www.example.com/" target="_blank">http://www.example.com/</a>!!!</p>
\ No newline at end of file
diff --git a/src/markup/engine/remarkup/__tests__/data/link-with-tilde.txt b/src/markup/engine/remarkup/__tests__/data/link-with-tilde.txt
new file mode 100644
index 0000000..c15a9a7
--- /dev/null
+++ b/src/markup/engine/remarkup/__tests__/data/link-with-tilde.txt
@@ -0,0 +1,3 @@
+http://www.example.com/~
+~~~~~~~~~~
+<p><a href="http://www.example.com/~" target="_blank">http://www.example.com/~</a></p>
\ No newline at end of file
diff --git a/src/markup/engine/remarkup/__tests__/data/link.txt b/src/markup/engine/remarkup/__tests__/data/link.txt
new file mode 100755
index 0000000..c48fba9
--- /dev/null
+++ b/src/markup/engine/remarkup/__tests__/data/link.txt
@@ -0,0 +1,3 @@
+http://www.example.com/
+~~~~~~~~~~
+<p><a href="http://www.example.com/" target="_blank">http://www.example.com/</a></p>
\ No newline at end of file
diff --git a/src/markup/engine/remarkup/__tests__/data/list.txt b/src/markup/engine/remarkup/__tests__/data/list.txt
new file mode 100755
index 0000000..c1c2ff7
--- /dev/null
+++ b/src/markup/engine/remarkup/__tests__/data/list.txt
@@ -0,0 +1,8 @@
+  - < > & "
+
+text block
+~~~~~~~~~~
+<ul>
+<li>&lt; &gt; &amp; &quot;</li>
+</ul>
+<p>text block</p>
\ No newline at end of file
diff --git a/src/markup/engine/remarkup/__tests__/data/monospaced.txt b/src/markup/engine/remarkup/__tests__/data/monospaced.txt
new file mode 100644
index 0000000..aed134a
--- /dev/null
+++ b/src/markup/engine/remarkup/__tests__/data/monospaced.txt
@@ -0,0 +1,3 @@
+##ls --color > /dev/null##
+~~~~~~~~~~
+<p><tt>ls --color &gt; /dev/null</tt></p>
\ No newline at end of file
diff --git a/src/markup/engine/remarkup/__tests__/data/simple.txt b/src/markup/engine/remarkup/__tests__/data/simple.txt
new file mode 100755
index 0000000..d7ed317
--- /dev/null
+++ b/src/markup/engine/remarkup/__tests__/data/simple.txt
@@ -0,0 +1,3 @@
+hello
+~~~~~~~~~~
+<p>hello</p>
\ No newline at end of file
diff --git a/src/markup/engine/remarkup/blockrule/base/PhutilRemarkupEngineBlockRule.php b/src/markup/engine/remarkup/blockrule/base/PhutilRemarkupEngineBlockRule.php
new file mode 100644
index 0000000..4281164
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/base/PhutilRemarkupEngineBlockRule.php
@@ -0,0 +1,57 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+abstract class PhutilRemarkupEngineBlockRule {
+
+  private $storage;
+  private $engine;
+  private $rules;
+
+  abstract public function getBlockPattern();
+  abstract public function shouldMergeBlocks();
+  abstract public function markupText($text);
+
+  final public function setEngine(PhutilRemarkupEngine $engine) {
+    $this->engine = $engine;
+    return $this;
+  }
+
+  final protected function getEngine() {
+    return $this->engine;
+  }
+
+  public function setMarkupRules(array $rules) {
+    $this->rules = $rules;
+    return $this;
+  }
+
+  final private function getMarkupRules() {
+    return $this->rules;
+  }
+
+  final protected function applyRules($text) {
+    $engine = $this->getEngine();
+    foreach ($this->getMarkupRules() as $rule) {
+      $rule->setEngine($engine);
+      $text = $rule->apply($text);
+    }
+    return $text;
+  }
+
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/base/__init__.php b/src/markup/engine/remarkup/blockrule/base/__init__.php
new file mode 100644
index 0000000..c3938a7
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/base/__init__.php
@@ -0,0 +1,10 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+
+phutil_require_source('PhutilRemarkupEngineBlockRule.php');
diff --git a/src/markup/engine/remarkup/blockrule/remarkupcode/PhutilRemarkupEngineRemarkupCodeBlockRule.php b/src/markup/engine/remarkup/blockrule/remarkupcode/PhutilRemarkupEngineRemarkupCodeBlockRule.php
new file mode 100644
index 0000000..52c5cf8
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupcode/PhutilRemarkupEngineRemarkupCodeBlockRule.php
@@ -0,0 +1,48 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupEngineRemarkupCodeBlockRule
+  extends PhutilRemarkupEngineBlockRule {
+
+  public function getBlockPattern() {
+    return "/^\s{2,}/";
+  }
+
+  public function shouldMergeBlocks() {
+    return true;
+  }
+
+  public function markupText($text) {
+    // Normalize the text back to a 0-level indent.
+    $min_indent = 80;
+    $lines = explode("\n", $text);
+    foreach ($lines as $line) {
+      for ($ii = 0; $ii < strlen($line); $ii++) {
+        if ($line[$ii] != ' ') {
+          $min_indent = min($ii, $min_indent);
+          break;
+        }
+      }
+    }
+    if ($min_indent) {
+      $indent_string = str_repeat(' ', $min_indent);
+      $text = preg_replace('/^'.$indent_string.'/m', '', $text);
+    }
+    return '<code>'.$this->applyRules($text).'</code>';
+  }
+}
diff --git a/src/markup/engine/remarkup/blockrule/remarkupcode/__init__.php b/src/markup/engine/remarkup/blockrule/remarkupcode/__init__.php
new file mode 100644
index 0000000..4758cf9
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupcode/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/blockrule/base');
+
+
+phutil_require_source('PhutilRemarkupEngineRemarkupCodeBlockRule.php');
diff --git a/src/markup/engine/remarkup/blockrule/remarkupcounterexample/PhutilRemarkupEngineRemarkupCounterExampleBlockRule.php b/src/markup/engine/remarkup/blockrule/remarkupcounterexample/PhutilRemarkupEngineRemarkupCounterExampleBlockRule.php
new file mode 100644
index 0000000..7b658d5
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupcounterexample/PhutilRemarkupEngineRemarkupCounterExampleBlockRule.php
@@ -0,0 +1,36 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupEngineRemarkupCounterExampleBlockRule
+  extends PhutilRemarkupEngineBlockRule {
+
+  public function getBlockPattern() {
+    return "/^  COUNTEREXAMPLE\n/";
+  }
+
+  public function willMarkupText($text) {
+    // Remove the initial 'COUNTEREXAMPLE' line.
+    $text = explode("\n", $text);
+    array_shift($text);
+    return implode("\n", $text);
+  }
+
+  public function shouldMergeBlocks() {
+    return false;
+  }
+}
diff --git a/src/markup/engine/remarkup/blockrule/remarkupcounterexample/__init__.php b/src/markup/engine/remarkup/blockrule/remarkupcounterexample/__init__.php
new file mode 100644
index 0000000..9848ad7
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupcounterexample/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/blockrule/base');
+
+
+phutil_require_source('PhutilRemarkupEngineRemarkupCounterExampleBlockRule.php');
diff --git a/src/markup/engine/remarkup/blockrule/remarkupdefault/PhutilRemarkupEngineRemarkupDefaultBlockRule.php b/src/markup/engine/remarkup/blockrule/remarkupdefault/PhutilRemarkupEngineRemarkupDefaultBlockRule.php
new file mode 100644
index 0000000..3985a85
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupdefault/PhutilRemarkupEngineRemarkupDefaultBlockRule.php
@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupEngineRemarkupDefaultBlockRule
+  extends PhutilRemarkupEngineBlockRule {
+
+  public function getBlockPattern() {
+    return "/.*/";
+  }
+
+  public function shouldMergeBlocks() {
+    return false;
+  }
+
+  public function markupText($text) {
+    $lines = explode("\n", $text);
+    foreach ($lines as $key => $line) {
+      $lines[$key] = $this->applyRules($line."\n");
+    }
+    return '<p>'.implode('', $lines).'</p>';
+  }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/remarkupdefault/__init__.php b/src/markup/engine/remarkup/blockrule/remarkupdefault/__init__.php
new file mode 100644
index 0000000..41b7bf2
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupdefault/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/blockrule/base');
+
+
+phutil_require_source('PhutilRemarkupEngineRemarkupDefaultBlockRule.php');
diff --git a/src/markup/engine/remarkup/blockrule/remarkupheader/PhutilRemarkupEngineRemarkupHeaderBlockRule.php b/src/markup/engine/remarkup/blockrule/remarkupheader/PhutilRemarkupEngineRemarkupHeaderBlockRule.php
new file mode 100644
index 0000000..cc40f0e
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupheader/PhutilRemarkupEngineRemarkupHeaderBlockRule.php
@@ -0,0 +1,42 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupEngineRemarkupHeaderBlockRule
+  extends PhutilRemarkupEngineBlockRule {
+
+  public function getBlockPattern() {
+    return '/^(={1,5})(.*?)\\1?\s*$/';
+  }
+
+  public function shouldMergeBlocks() {
+    return false;
+  }
+
+  public function markupText($text) {
+    $level = 1;
+    for ($ii = 0; $ii < min(5, strlen($text)); $ii++) {
+      if ($text[$ii] == '=') {
+        ++$level;
+      }
+    }
+    $text = trim($text, ' =');
+
+    return '<h'.$level.'>'.$this->applyRules($text).'</h'.$level.'>';
+  }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/remarkupheader/__init__.php b/src/markup/engine/remarkup/blockrule/remarkupheader/__init__.php
new file mode 100644
index 0000000..1692dae
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupheader/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/blockrule/base');
+
+
+phutil_require_source('PhutilRemarkupEngineRemarkupHeaderBlockRule.php');
diff --git a/src/markup/engine/remarkup/blockrule/remarkupinline/PhutilRemarkupEngineRemarkupInlineBlockRule.php b/src/markup/engine/remarkup/blockrule/remarkupinline/PhutilRemarkupEngineRemarkupInlineBlockRule.php
new file mode 100644
index 0000000..637e8bb
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupinline/PhutilRemarkupEngineRemarkupInlineBlockRule.php
@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupEngineRemarkupInlineBlockRule
+  extends PhutilRemarkupEngineBlockRule {
+
+  public function getBlockPattern() {
+    return "/.*/";
+  }
+
+  public function shouldMergeBlocks() {
+    return true;
+  }
+
+  public function markupText($text) {
+    return $this->applyRules($text);
+  }
+
+}
diff --git a/src/markup/engine/remarkup/blockrule/remarkupinline/__init__.php b/src/markup/engine/remarkup/blockrule/remarkupinline/__init__.php
new file mode 100644
index 0000000..4626563
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkupinline/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/blockrule/base');
+
+
+phutil_require_source('PhutilRemarkupEngineRemarkupInlineBlockRule.php');
diff --git a/src/markup/engine/remarkup/blockrule/remarkuplist/PhutilRemarkupEngineRemarkupListBlockRule.php b/src/markup/engine/remarkup/blockrule/remarkuplist/PhutilRemarkupEngineRemarkupListBlockRule.php
new file mode 100644
index 0000000..afdd27e
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkuplist/PhutilRemarkupEngineRemarkupListBlockRule.php
@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupEngineRemarkupListBlockRule
+  extends PhutilRemarkupEngineBlockRule {
+
+  public function getBlockPattern() {
+    return '/^\s+-\s+/';
+  }
+
+  public function shouldMergeBlocks() {
+    return true;
+  }
+
+  public function markupText($text) {
+    $items = preg_split('/^\s*-\s+/m', $text);
+    foreach ($items as $key => $item) {
+      if (!strlen($item)) {
+        unset($items[$key]);
+      } else {
+        $items[$key] = '<li>'.$this->applyRules($item).'</li>';
+      }
+    }
+    return '<ul>'.implode("\n", $items).'</ul>';
+  }
+}
diff --git a/src/markup/engine/remarkup/blockrule/remarkuplist/__init__.php b/src/markup/engine/remarkup/blockrule/remarkuplist/__init__.php
new file mode 100644
index 0000000..5762cac
--- /dev/null
+++ b/src/markup/engine/remarkup/blockrule/remarkuplist/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/blockrule/base');
+
+
+phutil_require_source('PhutilRemarkupEngineRemarkupListBlockRule.php');
diff --git a/src/markup/engine/remarkup/blockstorage/PhutilRemarkupBlockStorage.php b/src/markup/engine/remarkup/blockstorage/PhutilRemarkupBlockStorage.php
new file mode 100644
index 0000000..f3996f0
--- /dev/null
+++ b/src/markup/engine/remarkup/blockstorage/PhutilRemarkupBlockStorage.php
@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+final class PhutilRemarkupBlockStorage {
+
+  private $map = array();
+  private $index;
+
+  public function store($token) {
+    $key = "~".(++$this->index)."%";
+    $this->map[$key] = $token;
+    return $key;
+  }
+
+  public function restore($corpus) {
+    if ($this->map) {
+      $corpus = str_replace(
+        array_reverse(array_keys($this->map)),
+        array_reverse($this->map),
+        $corpus);
+      $this->map = array();
+    }
+    return $corpus;
+  }
+
+}
diff --git a/src/markup/engine/remarkup/blockstorage/__init__.php b/src/markup/engine/remarkup/blockstorage/__init__.php
new file mode 100644
index 0000000..eb361b0
--- /dev/null
+++ b/src/markup/engine/remarkup/blockstorage/__init__.php
@@ -0,0 +1,10 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+
+phutil_require_source('PhutilRemarkupBlockStorage.php');
diff --git a/src/markup/engine/remarkup/markuprule/base/PhutilRemarkupRule.php b/src/markup/engine/remarkup/markuprule/base/PhutilRemarkupRule.php
new file mode 100644
index 0000000..38dcbe1
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/base/PhutilRemarkupRule.php
@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+abstract class PhutilRemarkupRule {
+
+  private $engine;
+
+  public function setEngine(PhutilRemarkupEngine $engine) {
+    $this->engine = $engine;
+    return $this;
+  }
+
+  public function getEngine() {
+    return $this->engine;
+  }
+
+  abstract public function apply($text);
+}
diff --git a/src/markup/engine/remarkup/markuprule/base/__init__.php b/src/markup/engine/remarkup/markuprule/base/__init__.php
new file mode 100644
index 0000000..02b4f10
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/base/__init__.php
@@ -0,0 +1,10 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+
+phutil_require_source('PhutilRemarkupRule.php');
diff --git a/src/markup/engine/remarkup/markuprule/bold/PhutilRemarkupRuleBold.php b/src/markup/engine/remarkup/markuprule/bold/PhutilRemarkupRuleBold.php
new file mode 100644
index 0000000..46373ca
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/bold/PhutilRemarkupRuleBold.php
@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupRuleBold
+  extends PhutilRemarkupRule {
+
+  public function apply($text) {
+    return preg_replace(
+      '@\\*\\*(.+?)\\*\\*@',
+      '<strong>\1</strong>',
+      $text);
+  }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/bold/__init__.php b/src/markup/engine/remarkup/markuprule/bold/__init__.php
new file mode 100644
index 0000000..cbc5425
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/bold/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/markuprule/base');
+
+
+phutil_require_source('PhutilRemarkupRuleBold.php');
diff --git a/src/markup/engine/remarkup/markuprule/escapehtml/PhutilRemarkupRuleEscapeHTML.php b/src/markup/engine/remarkup/markuprule/escapehtml/PhutilRemarkupRuleEscapeHTML.php
new file mode 100644
index 0000000..a642c94
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/escapehtml/PhutilRemarkupRuleEscapeHTML.php
@@ -0,0 +1,26 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupRuleEscapeHTML
+  extends PhutilRemarkupRule {
+
+  public function apply($text) {
+    return phutil_escape_html($text);
+  }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/escapehtml/__init__.php b/src/markup/engine/remarkup/markuprule/escapehtml/__init__.php
new file mode 100644
index 0000000..7abf5e5
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/escapehtml/__init__.php
@@ -0,0 +1,13 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup');
+phutil_require_module('phutil', 'markup/engine/remarkup/markuprule/base');
+
+
+phutil_require_source('PhutilRemarkupRuleEscapeHTML.php');
diff --git a/src/markup/engine/remarkup/markuprule/escaperemarkup/PhutilRemarkupRuleEscapeRemarkup.php b/src/markup/engine/remarkup/markuprule/escaperemarkup/PhutilRemarkupRuleEscapeRemarkup.php
new file mode 100644
index 0000000..cd634a2
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/escaperemarkup/PhutilRemarkupRuleEscapeRemarkup.php
@@ -0,0 +1,33 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupRuleEscapeRemarkup
+  extends PhutilRemarkupRule {
+
+  public function apply($text) {
+    return preg_replace_callback(
+      '/~/',
+      array($this, 'escapeRemarkup'),
+      $text);
+  }
+
+  public function escapeRemarkup($matches) {
+    return $this->getEngine()->storeText($matches[0]);
+  }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/escaperemarkup/__init__.php b/src/markup/engine/remarkup/markuprule/escaperemarkup/__init__.php
new file mode 100644
index 0000000..b63e662
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/escaperemarkup/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/markuprule/base');
+
+
+phutil_require_source('PhutilRemarkupRuleEscapeRemarkup.php');
diff --git a/src/markup/engine/remarkup/markuprule/hyperlink/PhutilRemarkupRuleHyperlink.php b/src/markup/engine/remarkup/markuprule/hyperlink/PhutilRemarkupRuleHyperlink.php
new file mode 100644
index 0000000..fc3690a
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/hyperlink/PhutilRemarkupRuleHyperlink.php
@@ -0,0 +1,59 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupRuleHyperlink
+  extends PhutilRemarkupRule {
+
+  public function apply($text) {
+
+    $text = preg_replace_callback(
+      '@[<](\w{3,}://.+?)[>]@',
+      array($this, 'markupHyperlink'),
+      $text);
+
+    $text = preg_replace_callback(
+      '@(?<=^|\s)(\w{3,}://\S+)(?=\s|$)@',
+      array($this, 'markupHyperlinkUngreedy'),
+      $text);
+
+    return $text;
+  }
+
+  public function markupHyperlink($matches) {
+    return $this->getEngine()->storeText(
+      phutil_render_tag(
+        'a',
+        array(
+          'href'    => $matches[1],
+          'target'  => '_blank',
+        ),
+        phutil_escape_html($matches[1])));
+  }
+
+  public function markupHyperlinkUngreedy($matches) {
+    $match = $matches[1];
+    $tail = null;
+    $trailing = null;
+    if (preg_match('/[;,.:!?]+$/', $match, $trailing)) {
+      $tail = $trailing[0];
+      $match = substr($match, 0, -strlen($tail));
+    }
+    return $this->markupHyperlink(array(null, $match)).$tail;
+  }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/hyperlink/__init__.php b/src/markup/engine/remarkup/markuprule/hyperlink/__init__.php
new file mode 100644
index 0000000..52e9a40
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/hyperlink/__init__.php
@@ -0,0 +1,13 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup');
+phutil_require_module('phutil', 'markup/engine/remarkup/markuprule/base');
+
+
+phutil_require_source('PhutilRemarkupRuleHyperlink.php');
diff --git a/src/markup/engine/remarkup/markuprule/italics/PhutilRemarkupRuleItalic.php b/src/markup/engine/remarkup/markuprule/italics/PhutilRemarkupRuleItalic.php
new file mode 100644
index 0000000..a8d3eb4
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/italics/PhutilRemarkupRuleItalic.php
@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupRuleItalic
+  extends PhutilRemarkupRule {
+
+  public function apply($text) {
+    return preg_replace(
+      '@(?<!:)//(.+?)//@',
+      '<em>\1</em>',
+      $text);
+  }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/italics/__init__.php b/src/markup/engine/remarkup/markuprule/italics/__init__.php
new file mode 100644
index 0000000..ae56d31
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/italics/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/markuprule/base');
+
+
+phutil_require_source('PhutilRemarkupRuleItalic.php');
diff --git a/src/markup/engine/remarkup/markuprule/linebreaks/PhutilRemarkupRuleLinebreaks.php b/src/markup/engine/remarkup/markuprule/linebreaks/PhutilRemarkupRuleLinebreaks.php
new file mode 100644
index 0000000..7021cd2
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/linebreaks/PhutilRemarkupRuleLinebreaks.php
@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupRuleLinebreaks
+  extends PhutilRemarkupRule {
+
+  public function apply($text) {
+    return str_replace(
+      "\n",
+      "<br />\n",
+      $text);
+  }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/linebreaks/__init__.php b/src/markup/engine/remarkup/markuprule/linebreaks/__init__.php
new file mode 100644
index 0000000..01b48ac
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/linebreaks/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/markuprule/base');
+
+
+phutil_require_source('PhutilRemarkupRuleLinebreaks.php');
diff --git a/src/markup/engine/remarkup/markuprule/monospace/PhutilRemarkupRuleMonospace.php b/src/markup/engine/remarkup/markuprule/monospace/PhutilRemarkupRuleMonospace.php
new file mode 100644
index 0000000..9d9b839
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/monospace/PhutilRemarkupRuleMonospace.php
@@ -0,0 +1,29 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class PhutilRemarkupRuleMonospace
+  extends PhutilRemarkupRule {
+
+  public function apply($text) {
+    return preg_replace(
+      '@##(.+?)##@',
+      '<tt>\1</tt>',
+      $text);
+  }
+
+}
diff --git a/src/markup/engine/remarkup/markuprule/monospace/__init__.php b/src/markup/engine/remarkup/markuprule/monospace/__init__.php
new file mode 100644
index 0000000..2411f43
--- /dev/null
+++ b/src/markup/engine/remarkup/markuprule/monospace/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'markup/engine/remarkup/markuprule/base');
+
+
+phutil_require_source('PhutilRemarkupRuleMonospace.php');
diff --git a/src/markup/render.php b/src/markup/render.php
new file mode 100644
index 0000000..dc62566
--- /dev/null
+++ b/src/markup/render.php
@@ -0,0 +1,36 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function phutil_render_tag($tag, array $attributes = array(), $content = null) {
+  foreach ($attributes as $k => $v) {
+    $v = phutil_escape_html($v);
+    $attributes[$k] = ' '.$k.'="'.$v.'"';
+  }
+
+  $attributes = implode('', $attributes);
+
+  if ($content === null) {
+    return '<'.$tag.$attributes.' />';
+  } else {
+    return '<'.$tag.$attributes.'>'.$content.'</'.$tag.'>';
+  }
+}
+
+function phutil_escape_html($string) {
+  return htmlspecialchars($string, ENT_QUOTES, 'UTF-8');
+}
diff --git a/src/moduleutils/__init__.php b/src/moduleutils/__init__.php
new file mode 100644
index 0000000..0d21216
--- /dev/null
+++ b/src/moduleutils/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'filesystem');
+
+
+phutil_require_source('moduleutils.php');
diff --git a/src/moduleutils/moduleutils.php b/src/moduleutils/moduleutils.php
new file mode 100644
index 0000000..68c6497
--- /dev/null
+++ b/src/moduleutils/moduleutils.php
@@ -0,0 +1,49 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function phutil_get_library_root($library) {
+  return __phutil_library_registry('find', $library);
+}
+
+
+function phutil_get_library_root_for_path($path) {
+  foreach (Filesystem::walkToRoot($path) as $dir) {
+    if (@file_exists($dir.'/__phutil_library_init__.php')) {
+      return $dir;
+    }
+  }
+  return null;
+}
+
+function phutil_get_library_name_for_root($path) {
+  $loaded = false;
+  while (true) {
+    $libs = __phutil_library_registry('list');
+    $path = rtrim(Filesystem::resolvePath($path), '/');
+    foreach ($libs as $lib => $root) {
+      if (rtrim(Filesystem::resolvePath($root), '/') == $path) {
+        return $lib;
+      }
+    }
+    if ($loaded) {
+      return null;
+    } else {
+      phutil_load_library($path);
+    }
+  } while (true);
+}
diff --git a/src/utils/__init__.php b/src/utils/__init__.php
new file mode 100644
index 0000000..d5139e8
--- /dev/null
+++ b/src/utils/__init__.php
@@ -0,0 +1,19 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_source('utils.php');
diff --git a/src/utils/utils.php b/src/utils/utils.php
new file mode 100644
index 0000000..a118080
--- /dev/null
+++ b/src/utils/utils.php
@@ -0,0 +1,205 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function id($x) {
+  return $x;
+}
+
+function idx(array $array, $key, $default = null) {
+  return array_key_exists($key, $array) ? $array[$key] : $default;
+}
+
+function mpull(array $list, $method, $key_method = null) {
+  $result = array();
+  foreach ($list as $key => $object) {
+    if ($key_method !== null) {
+      $key = $object->$key_method();
+    }
+    if ($method !== null) {
+      $value = $object->$method();
+    } else {
+      $value = $object;
+    }
+    $result[$key] = $value;
+  }
+  return $result;
+}
+
+function ipull(array $list, $index, $key_index = null) {
+  $result = array();
+  foreach ($list as $key => $array) {
+    if ($key_index !== null) {
+      $key = $array[$key_index];
+    }
+    if ($index !== null) {
+      $value = $array[$index];
+    } else {
+      $value = $array;
+    }
+    $result[$key] = $value;
+  }
+  return $result;
+}
+
+function mgroup(array $list, $by /*, ... */) {
+  $map = mpull($list, $by);
+
+  $groups = array();
+  foreach ($map as $group) {
+    // Can't array_fill_keys() here because 'false' gets encoded wrong.
+    $groups[$group] = array();
+  }
+
+  foreach ($map as $key => $group) {
+    $groups[$group][$key] = $list[$key];
+  }
+
+  $args = func_get_args();
+  $args = array_slice($args, 2);
+  if ($args) {
+    array_unshift($args, null);
+    foreach ($groups as $group_key => $grouped) {
+      $args[0] = $grouped;
+      $groups[$group_key] = call_user_func_array('mgroup', $args);
+    }
+  }
+
+  return $groups;
+}
+
+/**
+ * Sort a list of objects by the return value of some method.
+ */
+function msort(array $list, $method) {
+  $surrogate = mpull($list, $method);
+
+  asort($surrogate);
+
+  $result = array();
+  foreach ($surrogate as $key => $value) {
+    $result[$key] = $list[$key];
+  }
+
+  return $result;
+}
+
+/**
+ * Selects a list of keys from an array, returning a new array with only the
+ * key-value pairs identified by the selected keys, in the specified order.
+ *
+ * Note that since this function orders keys in the result according to the
+ * order they appear in the list of keys, there are effectively two common
+ * uses: either reducing a large dictionary to a smaller one, or changing the
+ * key order on an existing dictionary.
+ *
+ * @param  dict    Dictionary of key-value pairs to select from.
+ * @param  list    List of keys to select.
+ * @return dict    Dictionary of only those key-value pairs where the key was
+ *                 present in the list of keys to select. Ordering is
+ *                 determined by the list order.
+ */
+function array_select_keys(array $dict, array $keys) {
+  $result = array();
+  foreach ($keys as $key) {
+    if (array_key_exists($key, $dict)) {
+      $result[$key] = $dict[$key];
+    }
+  }
+  return $result;
+}
+
+/**
+ * Returns the first argument which is not strictly null, or `null' if there
+ * are no such arguments. Identical to the MySQL function of the same name.
+ *
+ * @param  ...         Zero or more arguments of any type.
+ * @return mixed       First non-null arg, or null if no such arg exists.
+ */
+function coalesce(/* ... */) {
+  $args = func_get_args();
+  foreach ($args as $arg) {
+    if ($arg !== null) {
+      return $arg;
+    }
+  }
+  return null;
+}
+
+
+/**
+ * Similar to coalesce(), but less strict: returns the first non-empty()
+ * argument, instead of the first argument that is strictly nonnull. If no
+ * argument is nonempty, it returns the last argument. This is useful
+ * idiomatically for setting defaults:
+ *
+ *   $value = nonempty($get_value, 0);
+ *
+ * @param  ...         Zero or more arguments of any type.
+ * @return mixed       First non-empty() arg, or last arg if no such arg
+ *                     exists, or null if you pased in zero args.
+ */
+function nonempty(/* ... */) {
+  $args = func_get_args();
+  foreach ($args as $arg) {
+    if ($arg) {
+      break;
+    }
+  }
+  return $arg;
+}
+
+/**
+ * Invokes the "new" operator with a vector of arguments. There is no way to
+ * call_user_func_array() on a class constructor, so you can instead use this
+ * function:
+ *
+ *   $obj = newv($class_name, $argv);
+ *
+ * That is, these two statements are equivalent:
+ *
+ *   $pancake = new Pancake('Blueberry', 'Maple Syrup', true);
+ *   $pancake = newv('Pancake', array('Blueberry', 'Maple Syrup', true));
+ *
+ * DO NOT solve this problem in other, more creative ways! Two popular
+ * alternatives are:
+ *
+ *   - Build a fake serialized object and unserialize it.
+ *   - Invoke the constructor twice.
+ *
+ * These are really bad solutions to the problem because they can have side
+ * effects (e.g., __wakeup()) and give you an object in an otherwise impossible
+ * state! Please endeavor to keep your objects in possible states.
+ *
+ * If you own the classes you're doing this for, you should consider whether
+ * or not restructuring your code (for instance, by creating static
+ * construction methods) might make it cleaner before using newv(). Static
+ * construtors can be invoked with call_user_func_array(), and may give your
+ * class a cleaner and more descriptive API.
+ *
+ * @param  string  The name of a class.
+ * @param  list    Array of arguments to pass to its constructor.
+ *
+ * @return obj     A new object of the specified class, constructed by passing
+ *                 the argument vector to its constructor.
+ */
+function newv($class_name, array $argv) {
+  $reflector = new ReflectionClass($class_name);
+  return $reflector->newInstanceArgs($argv);
+}
+
+
diff --git a/src/xsprintf/__init__.php b/src/xsprintf/__init__.php
new file mode 100644
index 0000000..baeaac9
--- /dev/null
+++ b/src/xsprintf/__init__.php
@@ -0,0 +1,19 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_source('xsprintf.php');
diff --git a/src/xsprintf/csprintf/__init__.php b/src/xsprintf/csprintf/__init__.php
new file mode 100644
index 0000000..e77169f
--- /dev/null
+++ b/src/xsprintf/csprintf/__init__.php
@@ -0,0 +1,21 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+phutil_require_module('phutil', 'xsprintf');
+
+phutil_require_source('csprintf.php');
diff --git a/src/xsprintf/csprintf/csprintf.php b/src/xsprintf/csprintf/csprintf.php
new file mode 100644
index 0000000..1200802
--- /dev/null
+++ b/src/xsprintf/csprintf/csprintf.php
@@ -0,0 +1,88 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Format a shell command string. This function behaves like sprintf(), except
+ * that all the normal conversions (like %s) will be properly escaped, and
+ * additional conversions are supported:
+ *
+ *   %C (Raw Command)
+ *     Passes the argument through without escaping. Dangerous!
+ *
+ * Generally, you should invoke shell commands via execx() rather than by
+ * calling csprintf() directly.
+ *
+ * @param  string  sprintf()-style format string.
+ * @param  ...     Zero or more arguments.
+ * @return string  Formatted string, escaped appropriately for shell contexts.
+ */
+function csprintf($pattern/*, ... */) {
+  $args = func_get_args();
+  return xsprintf('xsprintf_command', null, $args);
+}
+
+/**
+ * Version of csprintf() that takes a vector of arguments.
+ *
+ * @param  string  sprintf()-style format string.
+ * @param  list    List of zero or more arguments to csprintf().
+ * @return string  Formatted string, escaped appropriately for shell contexts.
+ */
+function vcsprintf($pattern, array $argv) {
+  array_unshift($argv, $pattern);
+  return call_user_func_array('csprintf', $argv);
+}
+
+
+/**
+ *  xsprintf() callback for csprintf().
+ */
+function xsprintf_command($userdata, &$pattern, &$pos, &$value, &$length) {
+  $type = $pattern[$pos];
+  $next = (strlen($pattern) > $pos + 1) ? $pattern[$pos + 1] : null;
+
+  switch ($type) {
+    case 'L':
+      // Only '%Ls' is supported.
+      if ($next !== 's') {
+        throw new Exception("Unknown conversion %L{$next}.");
+      }
+
+      // Remove the L, leaving %s
+      $pattern = substr_replace($pattern, '', $pos, 1);
+      $length  = strlen($pattern);
+      $type = 's';
+
+      // Check that the value is a non-empty array.
+      if (!is_array($value) || !$value) {
+        throw new Exception("Expected a non-empty array for %Ls conversion.");
+      }
+
+      // Convert the list of strings to a single string.
+      $value = implode(' ', array_map('escapeshellarg', $value));
+      break;
+    case 's':
+      $value = escapeshellarg($value);
+      $type = 's';
+      break;
+    case 'C':
+      $type = 's';
+      break;
+  }
+  $pattern[$pos] = $type;
+}
diff --git a/src/xsprintf/jsprintf/__init__.php b/src/xsprintf/jsprintf/__init__.php
new file mode 100644
index 0000000..2da434f
--- /dev/null
+++ b/src/xsprintf/jsprintf/__init__.php
@@ -0,0 +1,12 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'xsprintf');
+
+
+phutil_require_source('jsprintf.php');
diff --git a/src/xsprintf/jsprintf/jsprintf.php b/src/xsprintf/jsprintf/jsprintf.php
new file mode 100644
index 0000000..0b4a93a
--- /dev/null
+++ b/src/xsprintf/jsprintf/jsprintf.php
@@ -0,0 +1,104 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Format a Javascript string, using JSON to export complex values. This
+ * function behaves like sprintf(), except that all the normal conversions
+ * (like %s) will be properly escaped, and additional conversions are
+ * supported:
+ *
+ *   %O (Object)
+ *     Converts the argument to a JSON object.
+ *
+ *   %A (Array)
+ *     Converts the argument to a JSON array.
+ *
+ *   %b (Boolean)
+ *     Converts a value to either `true' or `false'.
+ *
+ *   %# (FBID)
+ *     JavaScript has issues with 64-bit numbers so we use this as our
+ *     transport mechanism from PHP to JavaScript
+ *
+ *   %J (Javascript)
+ *     Inserts raw, unescaped Javascript. This is DANGEROUS because it WILL
+ *     NOT BE ESCAPED.
+ */
+function jsprintf($pattern /*, ... */) {
+  $args = func_get_args();
+  return xsprintf('xsprintf_javascript', null, $args);
+}
+
+function vjsprintf($pattern, array $argv) {
+  array_unshift($argv, $pattern);
+  return xsprintf('xsprintf_javascript', null, $argv);
+}
+
+/**
+ *  xsprintf() callback for javascript encoding.
+ */
+function xsprintf_javascript($userdata, &$pattern, &$pos, &$value, &$length) {
+
+  $type = $pattern[$pos];
+
+  switch ($type) {
+    case '#':
+    case 's':
+      $value = json_encode((string)$value);
+      $type = 's';
+      break;
+
+    case 'A':
+      if (!is_array($value)) {
+        $value = array();
+      }
+
+      $value = json_encode(array_values($value));
+      $type = 's';
+      break;
+
+    case 'O':
+      if ($value !== null) {
+        $value = (object)$value;
+      }
+
+      $value = json_encode($value);
+      $type = 's';
+      break;
+
+    case 'J':
+      $type = 's';
+      break;
+
+    case 'b':
+      $value = $value ? 'true' : 'false';
+      $type = 's';
+      break;
+
+    case 'd':
+      if ($value > 0x1FFFFFFFFFFFFF) {
+        throw new Exception(
+          "You are passing an integer to jsprintf() which is so large it can ".
+          "not be represented without loss of precision by Javascript's ".
+          "native Number class. Use %# instead.");
+      }
+      break;
+  }
+
+  $pattern[$pos]  = $type;
+}
diff --git a/src/xsprintf/qsprintf/QsprintfQueryParameterException.php b/src/xsprintf/qsprintf/QsprintfQueryParameterException.php
new file mode 100644
index 0000000..d02f4ea
--- /dev/null
+++ b/src/xsprintf/qsprintf/QsprintfQueryParameterException.php
@@ -0,0 +1,32 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+class QsprintfQueryParameterException extends Exception {
+
+  private $query;
+
+  public function __construct($query, $message) {
+    parent::__construct($message." Query: ".$query);
+    $this->query = $query;
+  }
+
+  public function getQuery() {
+    return $this->query;
+  }
+
+}
diff --git a/src/xsprintf/qsprintf/__init__.php b/src/xsprintf/qsprintf/__init__.php
new file mode 100644
index 0000000..9fb0fff
--- /dev/null
+++ b/src/xsprintf/qsprintf/__init__.php
@@ -0,0 +1,13 @@
+<?php
+/**
+ * This file is automatically generated. Lint this module to rebuild it.
+ * @generated
+ */
+
+
+
+phutil_require_module('phutil', 'xsprintf');
+
+
+phutil_require_source('QsprintfQueryParameterException.php');
+phutil_require_source('qsprintf.php');
diff --git a/src/xsprintf/qsprintf/qsprintf.php b/src/xsprintf/qsprintf/qsprintf.php
new file mode 100644
index 0000000..35fe371
--- /dev/null
+++ b/src/xsprintf/qsprintf/qsprintf.php
@@ -0,0 +1,346 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Format a MySQL query. This function behaves like sprintf(), except that
+ * all the normal conversions (like %s) will be properly escaped, and
+ * additional conversions are supported:
+ *
+ *   %nd, %ns, %nf
+ *     "Nullable" versions of %d, %s and %f. Will produce 'NULL' if the
+ *     argument is a strict null.
+ *
+ *   %=d, %=s, %=f
+ *     "Nullable Test" versions of %d, %s and %f. If you pass a value, you
+ *     get "= 3"; if you pass null, you get "IS NULL". For instance, this
+ *     will work properly if `hatID' is a nullable column and $hat is null.
+ *
+ *       qsprintf($conn, 'WHERE hatID %=d', $hat);
+ *
+ *   %Ld, %Ls, %Lf
+ *     "List" versions of %d, %s and %f. These are appropriate for use in
+ *     an "IN" clause. For example:
+ *
+ *       qsprintf($conn, 'WHERE hatID IN(%Ld)', $list_of_hats);
+ *
+ *   %T ("Table")
+ *     Escapes a table name.
+ *
+ *   %C, %LC
+ *     Escapes a column name or a list of column names.
+ *
+ *   %K ("Comment")
+ *     Escapes a comment.
+ *
+ *   %Q ("Query Fragment")
+ *     Injects a raw query fragment. Extremely dangerous! Not escaped!
+ *
+ *   %~ ("Substring")
+ *     Escapes a substring query for a LIKE (or NOT LIKE) clause. For example:
+ *
+ *       //  Find all rows with $search as a substing of `name`.
+ *       qsprintf($conn, 'WHERE name LIKE %~', $search);
+ *
+ *     See also %> and %<.
+ *
+ *   %> ("Prefix")
+ *     Escapes a prefix query for a LIKE clause. For example:
+ *
+ *       //  Find all rows where `name` starts with $prefix.
+ *       qsprintf($conn, 'WHERE name LIKE %>', $prefix);
+ *
+ *   %< ("Suffix")
+ *     Escapes a suffix query for a LIKE clause. For example:
+ *
+ *       //  Find all rows where `name` ends with $suffix.
+ *       qsprintf($conn, 'WHERE name LIKE %<', $suffix);
+ */
+function qsprintf($conn, $pattern/*, ... */) {
+  $args = func_get_args();
+  array_shift($args);
+  return xsprintf('xsprintf_query', $conn, $args);
+}
+
+function vqsprintf($conn, $pattern, array $argv) {
+  array_unshift($argv, $pattern);
+  return xsprintf('xsprintf_query', $conn, $argv);
+}
+
+
+/**
+ *  xsprintf() callback for encoding SQL queries. See qsprintf().
+ */
+function xsprintf_query($userdata, &$pattern, &$pos, &$value, &$length) {
+  $type   = $pattern[$pos];
+  $conn   = $userdata;
+  $next   = (strlen($pattern) > $pos + 1) ? $pattern[$pos + 1] : null;
+
+  $nullable = false;
+  $done     = false;
+
+  $prefix   = '';
+
+  switch ($type) {
+    case '=': // Nullable test
+      switch ($next) {
+        case 'd':
+        case 'f':
+        case 's':
+          $pattern = substr_replace($pattern, '', $pos, 1);
+          $length  = strlen($pattern);
+          $type  = 's';
+          if ($value === null) {
+            $value = 'IS NULL';
+            $done = true;
+          } else {
+            $prefix = '= ';
+            $type = $next;
+          }
+          break;
+        default:
+          throw new Exception('Unknown conversion, try %=d, %=s, or %=f.');
+      }
+      break;
+
+    case 'n': // Nullable...
+      switch ($next) {
+        case 'd': //  ...integer.
+        case 'f': //  ...float.
+        case 's': //  ...string.
+          $pattern = substr_replace($pattern, '', $pos, 1);
+          $length = strlen($pattern);
+          $type = $next;
+          $nullable = true;
+          break;
+        default:
+          throw new Exception('Unknown conversion, try %nd or %ns.');
+      }
+      break;
+
+    case 'L': // List of..
+      _qsprintf_check_type($value, "L{$next}", $pattern);
+      $pattern = substr_replace($pattern, '', $pos, 1);
+      $length  = strlen($pattern);
+      $type = 's';
+      $done = true;
+
+      switch ($next) {
+        case 'd': //  ...integers.
+          $value = implode(', ', array_map('intval', $value));
+          break;
+        case 's': // ...strings.
+          $value = mysql_escape_array_of_strings_for_in_clause($value, $conn);
+          break;
+        case 'C': // ...columns.
+          $value = implode(', ', array_map('mysql_escape_column_name', $value));
+          break;
+        default:
+          throw new Exception("Unknown conversion %L{$next}.");
+      }
+      break;
+  }
+
+  if (!$done) {
+    _qsprintf_check_type($value, $type, $pattern);
+    switch ($type) {
+      case 's': // String
+        if ($nullable && $value === null) {
+          $value = 'NULL';
+        } else {
+          $value = "'".mysql_real_escape_string($value, $conn)."'";
+        }
+        $type = 's';
+        break;
+
+      case 'Q': // Query Fragment
+        $type = 's';
+        break;
+
+      case '~': // Like Substring
+      case '>': // Like Prefix
+      case '<': // Like Suffix
+        $value = mysql_real_escape_string($value, $conn);
+        // Ideally the query shouldn't be modified after safely escaping it,
+        // but we need to escape _ and % within LIKE terms.
+        $value = str_replace(
+          //  Even though we've already escaped, we need to replace \ with \\
+          //  because MYSQL unescapes twice inside a LIKE clause. See note
+          //  at mysql.com. However, if the \ is being used to escape a single
+          //  quote ('), then the \ should not be escaped. Thus, after all \
+          //  are replaced with \\, we need to revert instances of \\' back to
+          //  \'.
+          array('\\',   '\\\\\'', '_',  '%'),
+          array('\\\\', '\\\'',   '\_', '\%'),
+          $value);
+        switch ($type) {
+          case '~': $value = "'%".$value."%'"; break;
+          case '>': $value = "'" .$value."%'"; break;
+          case '<': $value = "'%".$value. "'"; break;
+        }
+        $type  = 's';
+        break;
+
+      case 'f': // Float
+        if ($nullable && $value === null) {
+          $value = 'NULL';
+        } else {
+          $value = (float)$value;
+        }
+        $type = 's';
+        break;
+
+      case 'd': // Integer
+        if ($nullable && $value === null) {
+          $value = 'NULL';
+        } else {
+          $value = (int)$value;
+        }
+        $type = 's';
+        break;
+
+      case 'T': // Table
+      case 'C': // Column
+        $value = mysql_escape_column_name($value);
+        $type = 's';
+        break;
+
+      case 'K': // Komment
+        $value = mysql_escape_multiline_comment($value);
+        $type = 's';
+        break;
+
+      default:
+        throw new Exception("Unknown conversion '%{$type}'.");
+
+    }
+  }
+
+  if ($prefix) {
+    $value = $prefix.$value;
+  }
+  $pattern[$pos] = $type;
+}
+
+function _qsprintf_check_type($value, $type, $query) {
+  switch ($type) {
+    case 'Ld': case 'Ls': case 'LC': case 'LA': case 'LO':
+      if (!is_array($value)) {
+        throw new QsprintfQueryParameterException(
+          $query,
+          "Expected array argument for %{$type} conversion.");
+      }
+      if (empty($value)) {
+        throw new QsprintfQueryParameterException(
+          $query,
+          "Array for %{$type} conversion is empty.");
+      }
+
+      foreach ($value as $scalar) {
+        _qsprintf_check_scalar_type($scalar, $type, $query);
+      }
+      break;
+    default:
+      _qsprintf_check_scalar_type($value, $type, $query);
+  }
+}
+
+
+function _qsprintf_check_scalar_type($value, $type, $query) {
+  switch ($type) {
+    case 'Q': case 'LC': case 'T': case 'C':
+      if (!is_string($value)) {
+        throw new QsprintfQueryParameterException(
+          $query,
+          "Expected a string for %{$type} conversion.");
+      }
+      break;
+
+    case 'Ld': case 'd': case 'f':
+      if (!is_null($value) && !is_scalar($value)) {
+        throw new QsprintfQueryParameterException(
+          $query,
+          "Expected a scalar or null for %{$type} conversion.");
+      }
+      break;
+
+    case 'Ls': case 's':
+    case '~': case '>': case '<': case 'K':
+      if (!is_null($value) && !is_scalar($value)) {
+        throw new QsprintfQueryParameterException(
+          $query,
+          "Expected a scalar or null for %{$type} conversion.");
+      }
+      break;
+
+    case 'LA': case 'LO':
+      if (!is_null($value) && !is_scalar($value) &&
+          !(is_array($value) && !empty($value))) {
+        throw new QsprintfQueryParameterException(
+          $query,
+          "Expected a scalar or null or non-empty array for ".
+          "%{$type} conversion.");
+      }
+      break;
+    default:
+      throw new Exception("Unknown conversion '{$type}'.");
+  }
+}
+
+
+function mysql_escape_column_name($value) {
+  return '`'.str_replace('`', '\\`', $value).'`';
+}
+
+function mysql_escape_multiline_comment($comment) {
+
+  //  These can either terminate a comment, confuse the hell out of the parser,
+  //  make MySQL execute the comment as a query, or, in the case of semicolon,
+  //  are quasi-dangerous because the semicolon could turn a broken query into
+  //  a working query plus an ignored query.
+
+  static $bad  = array(
+    '--', '*/', '//', '#', '!', ';');
+  static $safe = array(
+    '(DOUBLEDASH)', '(STARSLASH)', '(SLASHSLASH)', '(HASH)', '(BANG)',
+    '(SEMICOLON)');
+
+  $comment = str_replace($bad, $safe, $comment);
+
+  //  For good measure, kill anything else that isn't a nice printable
+  //  character.
+
+  $comment = preg_replace('/[^\x20-\x7F]+/', ' ', $comment);
+
+  return '/* '.$comment.' */';
+}
+
+function mysql_escape_array_of_strings_for_in_clause($strings, $conn) {
+  if (!count($strings)) {
+    return 'NULL';
+  }
+
+  foreach ($strings as &$string) {
+    if ($string === null) {
+      $string = 'NULL';
+    } else {
+      $string = "'".mysql_real_escape_string($string, $conn)."'";
+    }
+  }
+
+  return implode(', ', $strings);
+}
diff --git a/src/xsprintf/xsprintf.php b/src/xsprintf/xsprintf.php
new file mode 100644
index 0000000..654429e
--- /dev/null
+++ b/src/xsprintf/xsprintf.php
@@ -0,0 +1,72 @@
+<?php
+
+/*
+ * Copyright 2011 Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Parse a printf()-style format string in an extensible way.
+ *
+ * This method allows you to build a function with printf() semantics but
+ * custom conversions for different datatypes. Two examples are jsprintf()
+ * (which builds Javascript strings) and qsprintf() (which builds MySQL
+ * strings).
+ */
+function xsprintf($callback, $userdata, $argv) {
+  $argc = count($argv);
+  $arg  = 0;
+  $pos  = 0;
+  $pattern = $argv[0];
+  $len  = strlen($pattern);
+
+  $conv = false;  //  Are we inside a conversion?
+  for ($pos = 0; $pos < $len; $pos++) {
+    $c = $pattern[$pos];
+
+    if ($conv) {
+      //  We could make a greater effort to support formatting modifiers,
+      //  but they really have no place in semantic string formatting.
+      if (strpos("'-0123456789.\$+", $c) !== false) {
+        throw new Exception(
+          "xsprintf() does not support the `%{$c}' modifier.");
+      }
+
+      if ($c != '%') {
+        $conv = false;
+
+        $arg++;
+        if ($arg >= $argc) {
+          throw new Exception("Too few arguments to xsprintf().");
+        }
+
+        $callback($userdata, $pattern, $pos, $argv[$arg], $len);
+      }
+    }
+
+    if ($c == '%') {
+      //  If we have "%%", this encodes a literal percentage symbol, so we are
+      //  no longer inside a conversion.
+      $conv = !$conv;
+    }
+  }
+
+  if ($arg != ($argc - 1)) {
+    throw new Exception("Too many arguments to xsprintf().");
+  }
+
+  $argv[0] = $pattern;
+
+  return call_user_func_array('sprintf', $argv);
+}