Move Add-on SDK source to toolkit/jetpack

271 files changed, 39415 insertions, 2 deletions

diff --git a/toolkit/jetpack/app-extension/application.ini b/toolkit/jetpack/app-extension/application.ini
new file mode 100644
index 000000000..6cec69a16
--- /dev/null
+++ b/toolkit/jetpack/app-extension/application.ini
@@ -0,0 +1,11 @@
+[App]
+Vendor=Varma
+Name=Test App
+Version=1.0
+BuildID=20060101
+Copyright=Copyright (c) 2009 Atul Varma
+ID=xulapp@toolness.com
+
+[Gecko]
+MinVersion=1.9.2.0
+MaxVersion=2.0.*
diff --git a/toolkit/jetpack/app-extension/bootstrap.js b/toolkit/jetpack/app-extension/bootstrap.js
new file mode 100644
index 000000000..c2207c75f
--- /dev/null
+++ b/toolkit/jetpack/app-extension/bootstrap.js
@@ -0,0 +1,362 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// @see http://dxr.mozilla.org/mozilla-central/source/js/src/xpconnect/loader/mozJSComponentLoader.cpp
+
+'use strict';
+
+// IMPORTANT: Avoid adding any initialization tasks here, if you need to do
+// something before add-on is loaded consider addon/runner module instead!
+
+const { classes: Cc, Constructor: CC, interfaces: Ci, utils: Cu,
+        results: Cr, manager: Cm } = Components;
+const ioService = Cc['@mozilla.org/network/io-service;1'].
+                  getService(Ci.nsIIOService);
+const resourceHandler = ioService.getProtocolHandler('resource').
+                        QueryInterface(Ci.nsIResProtocolHandler);
+const systemPrincipal = CC('@mozilla.org/systemprincipal;1', 'nsIPrincipal')();
+const scriptLoader = Cc['@mozilla.org/moz/jssubscript-loader;1'].
+                     getService(Ci.mozIJSSubScriptLoader);
+const prefService = Cc['@mozilla.org/preferences-service;1'].
+                    getService(Ci.nsIPrefService).
+                    QueryInterface(Ci.nsIPrefBranch);
+const appInfo = Cc["@mozilla.org/xre/app-info;1"].
+                getService(Ci.nsIXULAppInfo);
+const vc = Cc["@mozilla.org/xpcom/version-comparator;1"].
+           getService(Ci.nsIVersionComparator);
+
+const { NetUtil } = Cu.import("resource://gre/modules/NetUtil.jsm", {});
+
+const Startup = Cu.import("resource://gre/modules/sdk/system/Startup.js", {}).exports;
+
+
+const REASON = [ 'unknown', 'startup', 'shutdown', 'enable', 'disable',
+                 'install', 'uninstall', 'upgrade', 'downgrade' ];
+
+const bind = Function.call.bind(Function.bind);
+
+var loader = null;
+var unload = null;
+var cuddlefishSandbox = null;
+var nukeTimer = null;
+
+var resourceDomains = [];
+function setResourceSubstitution(domain, uri) {
+  resourceDomains.push(domain);
+  resourceHandler.setSubstitution(domain, uri);
+}
+
+// Utility function that synchronously reads local resource from the given
+// `uri` and returns content string.
+function readURI(uri) {
+  let channel = NetUtil.newChannel({
+    uri: NetUtil.newURI(uri, 'UTF-8'),
+    loadUsingSystemPrincipal: true
+  });
+
+  let stream = channel.open2();
+
+  let cstream = Cc['@mozilla.org/intl/converter-input-stream;1'].
+    createInstance(Ci.nsIConverterInputStream);
+  cstream.init(stream, 'UTF-8', 0, 0);
+
+  let str = {};
+  let data = '';
+  let read = 0;
+  do {
+    read = cstream.readString(0xffffffff, str);
+    data += str.value;
+  } while (read != 0);
+
+  cstream.close();
+
+  return data;
+}
+
+// We don't do anything on install & uninstall yet, but in a future
+// we should allow add-ons to cleanup after uninstall.
+function install(data, reason) {}
+function uninstall(data, reason) {}
+
+function startup(data, reasonCode) {
+  try {
+    let reason = REASON[reasonCode];
+    // URI for the root of the XPI file.
+    // 'jar:' URI if the addon is packed, 'file:' URI otherwise.
+    // (Used by l10n module in order to fetch `locale` folder)
+    let rootURI = data.resourceURI.spec;
+
+    // TODO: Maybe we should perform read harness-options.json asynchronously,
+    // since we can't do anything until 'sessionstore-windows-restored' anyway.
+    let options = JSON.parse(readURI(rootURI + './harness-options.json'));
+
+    let id = options.jetpackID;
+    let name = options.name;
+
+    // Clean the metadata
+    options.metadata[name]['permissions'] = options.metadata[name]['permissions'] || {};
+
+    // freeze the permissionss
+    Object.freeze(options.metadata[name]['permissions']);
+    // freeze the metadata
+    Object.freeze(options.metadata[name]);
+
+    // Register a new resource 'domain' for this addon which is mapping to
+    // XPI's `resources` folder.
+    // Generate the domain name by using jetpack ID, which is the extension ID
+    // by stripping common characters that doesn't work as a domain name:
+    let uuidRe =
+      /^\{([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\}$/;
+
+    let domain = id.
+      toLowerCase().
+      replace(/@/g, '-at-').
+      replace(/\./g, '-dot-').
+      replace(uuidRe, '$1');
+
+    let prefixURI = 'resource://' + domain + '/';
+    let resourcesURI = ioService.newURI(rootURI + '/resources/', null, null);
+    setResourceSubstitution(domain, resourcesURI);
+
+    // Create path to URLs mapping supported by loader.
+    let paths = {
+      // Relative modules resolve to add-on package lib
+      './': prefixURI + name + '/lib/',
+      './tests/': prefixURI + name + '/tests/',
+      '': 'resource://gre/modules/commonjs/'
+    };
+
+    // Maps addon lib and tests ressource folders for each package
+    paths = Object.keys(options.metadata).reduce(function(result, name) {
+      result[name + '/'] = prefixURI + name + '/lib/'
+      result[name + '/tests/'] = prefixURI + name + '/tests/'
+      return result;
+    }, paths);
+
+    // We need to map tests folder when we run sdk tests whose package name
+    // is stripped
+    if (name == 'addon-sdk')
+      paths['tests/'] = prefixURI + name + '/tests/';
+
+    let useBundledSDK = options['force-use-bundled-sdk'];
+    if (!useBundledSDK) {
+      try {
+        useBundledSDK = prefService.getBoolPref("extensions.addon-sdk.useBundledSDK");
+      }
+      catch (e) {
+        // Pref doesn't exist, allow using Firefox shipped SDK
+      }
+    }
+
+    // Starting with Firefox 21.0a1, we start using modules shipped into firefox
+    // Still allow using modules from the xpi if the manifest tell us to do so.
+    // And only try to look for sdk modules in xpi if the xpi actually ship them
+    if (options['is-sdk-bundled'] &&
+        (vc.compare(appInfo.version, '21.0a1') < 0 || useBundledSDK)) {
+      // Maps sdk module folders to their resource folder
+      paths[''] = prefixURI + 'addon-sdk/lib/';
+      // test.js is usually found in root commonjs or SDK_ROOT/lib/ folder,
+      // so that it isn't shipped in the xpi. Keep a copy of it in sdk/ folder
+      // until we no longer support SDK modules in XPI:
+      paths['test'] = prefixURI + 'addon-sdk/lib/sdk/test.js';
+    }
+
+    // Retrieve list of module folder overloads based on preferences in order to
+    // eventually used a local modules instead of files shipped into Firefox.
+    let branch = prefService.getBranch('extensions.modules.' + id + '.path');
+    paths = branch.getChildList('', {}).reduce(function (result, name) {
+      // Allows overloading of any sub folder by replacing . by / in pref name
+      let path = name.substr(1).split('.').join('/');
+      // Only accept overloading folder by ensuring always ending with `/`
+      if (path) path += '/';
+      let fileURI = branch.getCharPref(name);
+
+      // On mobile, file URI has to end with a `/` otherwise, setSubstitution
+      // takes the parent folder instead.
+      if (fileURI[fileURI.length-1] !== '/')
+        fileURI += '/';
+
+      // Maps the given file:// URI to a resource:// in order to avoid various
+      // failure that happens with file:// URI and be close to production env
+      let resourcesURI = ioService.newURI(fileURI, null, null);
+      let resName = 'extensions.modules.' + domain + '.commonjs.path' + name;
+      setResourceSubstitution(resName, resourcesURI);
+
+      result[path] = 'resource://' + resName + '/';
+      return result;
+    }, paths);
+
+    // Make version 2 of the manifest
+    let manifest = options.manifest;
+
+    // Import `cuddlefish.js` module using a Sandbox and bootstrap loader.
+    let cuddlefishPath = 'loader/cuddlefish.js';
+    let cuddlefishURI = 'resource://gre/modules/commonjs/sdk/' + cuddlefishPath;
+    if (paths['sdk/']) { // sdk folder has been overloaded
+                         // (from pref, or cuddlefish is still in the xpi)
+      cuddlefishURI = paths['sdk/'] + cuddlefishPath;
+    }
+    else if (paths['']) { // root modules folder has been overloaded
+      cuddlefishURI = paths[''] + 'sdk/' + cuddlefishPath;
+    }
+
+    cuddlefishSandbox = loadSandbox(cuddlefishURI);
+    let cuddlefish = cuddlefishSandbox.exports;
+
+    // Normalize `options.mainPath` so that it looks like one that will come
+    // in a new version of linker.
+    let main = options.mainPath;
+
+    unload = cuddlefish.unload;
+    loader = cuddlefish.Loader({
+      paths: paths,
+      // modules manifest.
+      manifest: manifest,
+
+      // Add-on ID used by different APIs as a unique identifier.
+      id: id,
+      // Add-on name.
+      name: name,
+      // Add-on version.
+      version: options.metadata[name].version,
+      // Add-on package descriptor.
+      metadata: options.metadata[name],
+      // Add-on load reason.
+      loadReason: reason,
+
+      prefixURI: prefixURI,
+      // Add-on URI.
+      rootURI: rootURI,
+      // options used by system module.
+      // File to write 'OK' or 'FAIL' (exit code emulation).
+      resultFile: options.resultFile,
+      // Arguments passed as --static-args
+      staticArgs: options.staticArgs,
+
+      // Option to prevent automatic kill of firefox during tests
+      noQuit: options.no_quit,
+
+      // Add-on preferences branch name
+      preferencesBranch: options.preferencesBranch,
+
+      // Arguments related to test runner.
+      modules: {
+        '@test/options': {
+          iterations: options.iterations,
+          filter: options.filter,
+          profileMemory: options.profileMemory,
+          stopOnError: options.stopOnError,
+          verbose: options.verbose,
+          parseable: options.parseable,
+          checkMemory: options.check_memory,
+        }
+      }
+    });
+
+    let module = cuddlefish.Module('sdk/loader/cuddlefish', cuddlefishURI);
+    let require = cuddlefish.Require(loader, module);
+
+    // Init the 'sdk/webextension' module from the bootstrap addon parameter.
+    require("sdk/webextension").initFromBootstrapAddonParam(data);
+
+    require('sdk/addon/runner').startup(reason, {
+      loader: loader,
+      main: main,
+      prefsURI: rootURI + 'defaults/preferences/prefs.js'
+    });
+  } catch (error) {
+    dump('Bootstrap error: ' +
+         (error.message ? error.message : String(error)) + '\n' +
+         (error.stack || error.fileName + ': ' + error.lineNumber) + '\n');
+    throw error;
+  }
+};
+
+function loadSandbox(uri) {
+  let proto = {
+    sandboxPrototype: {
+      loadSandbox: loadSandbox,
+      ChromeWorker: ChromeWorker
+    }
+  };
+  let sandbox = Cu.Sandbox(systemPrincipal, proto);
+  // Create a fake commonjs environnement just to enable loading loader.js
+  // correctly
+  sandbox.exports = {};
+  sandbox.module = { uri: uri, exports: sandbox.exports };
+  sandbox.require = function (id) {
+    if (id !== "chrome")
+      throw new Error("Bootstrap sandbox `require` method isn't implemented.");
+
+    return Object.freeze({ Cc: Cc, Ci: Ci, Cu: Cu, Cr: Cr, Cm: Cm,
+      CC: bind(CC, Components), components: Components,
+      ChromeWorker: ChromeWorker });
+  };
+  scriptLoader.loadSubScript(uri, sandbox, 'UTF-8');
+  return sandbox;
+}
+
+function unloadSandbox(sandbox) {
+  if (Cu.getClassName(sandbox, true) == "Sandbox")
+    Cu.nukeSandbox(sandbox);
+}
+
+function setTimeout(callback, delay) {
+  let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+  timer.initWithCallback({ notify: callback }, delay,
+                         Ci.nsITimer.TYPE_ONE_SHOT);
+  return timer;
+}
+
+function shutdown(data, reasonCode) {
+  let reason = REASON[reasonCode];
+  if (loader) {
+    unload(loader, reason);
+    unload = null;
+
+    // Don't waste time cleaning up if the application is shutting down
+    if (reason != "shutdown") {
+      // Avoid leaking all modules when something goes wrong with one particular
+      // module. Do not clean it up immediatly in order to allow executing some
+      // actions on addon disabling.
+      // We need to keep a reference to the timer, otherwise it is collected
+      // and won't ever fire.
+      nukeTimer = setTimeout(nukeModules, 1000);
+
+      // Bug 944951 - bootstrap.js must remove the added resource: URIs on unload
+      resourceDomains.forEach(domain => {
+        resourceHandler.setSubstitution(domain, null);
+      })
+    }
+  }
+};
+
+function nukeModules() {
+  nukeTimer = null;
+  // module objects store `exports` which comes from sandboxes
+  // We should avoid keeping link to these object to avoid leaking sandboxes
+  for (let key in loader.modules) {
+    delete loader.modules[key];
+  }
+  // Direct links to sandboxes should be removed too
+  for (let key in loader.sandboxes) {
+    let sandbox = loader.sandboxes[key];
+    delete loader.sandboxes[key];
+    // Bug 775067: From FF17 we can kill all CCW from a given sandbox
+    unloadSandbox(sandbox);
+  }
+  unloadSandbox(loader.sharedGlobalSandbox);
+  loader = null;
+
+  // both `toolkit/loader` and `system/xul-app` are loaded as JSM's via
+  // `cuddlefish.js`, and needs to be unloaded to avoid memory leaks, when
+  // the addon is unload.
+
+  unloadSandbox(cuddlefishSandbox.loaderSandbox);
+
+  // Bug 764840: We need to unload cuddlefish otherwise it will stay alive
+  // and keep a reference to this compartment.
+  unloadSandbox(cuddlefishSandbox);
+  cuddlefishSandbox = null;
+}
diff --git a/toolkit/jetpack/app-extension/install.rdf b/toolkit/jetpack/app-extension/install.rdf
new file mode 100644
index 000000000..641d1cc21
--- /dev/null
+++ b/toolkit/jetpack/app-extension/install.rdf
@@ -0,0 +1,33 @@
+<?xml version="1.0"?>
+<!-- This Source Code Form is subject to the terms of the Mozilla Public
+   - License, v. 2.0. If a copy of the MPL was not distributed with this
+   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
+
+<RDF xmlns="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+     xmlns:em="http://www.mozilla.org/2004/em-rdf#">
+  <Description about="urn:mozilla:install-manifest">
+    <em:id>xulapp@toolness.com</em:id>
+    <em:version>1.0</em:version>
+    <em:type>2</em:type>
+    <em:bootstrap>true</em:bootstrap>
+    <em:unpack>false</em:unpack>
+
+    <!-- Firefox -->
+    <em:targetApplication>
+      <Description>
+        <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
+        <em:minVersion>26.0</em:minVersion>
+        <em:maxVersion>30.0</em:maxVersion>
+      </Description>
+    </em:targetApplication>
+
+    <!-- Front End MetaData -->
+    <em:name>Test App</em:name>
+    <em:description>Harness for tests.</em:description>
+    <em:creator>Mozilla Corporation</em:creator>
+    <em:homepageURL></em:homepageURL>
+    <em:optionsType></em:optionsType>
+    <em:optionsURL></em:optionsURL>
+    <em:updateURL></em:updateURL>
+  </Description>
+</RDF>
diff --git a/toolkit/jetpack/dev/debuggee.js b/toolkit/jetpack/dev/debuggee.js
new file mode 100644
index 000000000..0ca0bd37a
--- /dev/null
+++ b/toolkit/jetpack/dev/debuggee.js
@@ -0,0 +1,95 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cu } = require("chrome");
+const { Class } = require("../sdk/core/heritage");
+const { MessagePort, MessageChannel } = require("../sdk/messaging");
+const { require: devtoolsRequire } = Cu.import("resource://devtools/shared/Loader.jsm", {});
+const { DebuggerServer } = devtoolsRequire("devtools/server/main");
+
+const outputs = new WeakMap();
+const inputs = new WeakMap();
+const targets = new WeakMap();
+const transports = new WeakMap();
+
+const inputFor = port => inputs.get(port);
+const outputFor = port => outputs.get(port);
+const transportFor = port => transports.get(port);
+
+const fromTarget = target => {
+  const debuggee = new Debuggee();
+  const { port1, port2 } = new MessageChannel();
+  inputs.set(debuggee, port1);
+  outputs.set(debuggee, port2);
+  targets.set(debuggee, target);
+
+  return debuggee;
+};
+exports.fromTarget = fromTarget;
+
+const Debuggee = Class({
+  extends: MessagePort.prototype,
+  close: function() {
+    const server = transportFor(this);
+    if (server) {
+      transports.delete(this);
+      server.close();
+    }
+    outputFor(this).close();
+  },
+  start: function() {
+    const target = targets.get(this);
+    if (target.isLocalTab) {
+      // Since a remote protocol connection will be made, let's start the
+      // DebuggerServer here, once and for all tools.
+      if (!DebuggerServer.initialized) {
+        DebuggerServer.init();
+        DebuggerServer.addBrowserActors();
+      }
+
+      transports.set(this, DebuggerServer.connectPipe());
+    }
+    // TODO: Implement support for remote connections (See Bug 980421)
+    else {
+      throw Error("Remote targets are not yet supported");
+    }
+
+    // pipe messages send to the debuggee to an actual
+    // server via remote debugging protocol transport.
+    inputFor(this).addEventListener("message", ({data}) =>
+      transportFor(this).send(data));
+
+    // pipe messages received from the remote debugging
+    // server transport onto the this debuggee.
+    transportFor(this).hooks = {
+      onPacket: packet => inputFor(this).postMessage(packet),
+      onClosed: () => inputFor(this).close()
+    };
+
+    inputFor(this).start();
+    outputFor(this).start();
+  },
+  postMessage: function(data) {
+    return outputFor(this).postMessage(data);
+  },
+  get onmessage() {
+    return outputFor(this).onmessage;
+  },
+  set onmessage(onmessage) {
+    outputFor(this).onmessage = onmessage;
+  },
+  addEventListener: function(...args) {
+    return outputFor(this).addEventListener(...args);
+  },
+  removeEventListener: function(...args) {
+    return outputFor(this).removeEventListener(...args);
+  }
+});
+exports.Debuggee = Debuggee;
diff --git a/toolkit/jetpack/dev/frame-script.js b/toolkit/jetpack/dev/frame-script.js
new file mode 100644
index 000000000..33a197419
--- /dev/null
+++ b/toolkit/jetpack/dev/frame-script.js
@@ -0,0 +1,120 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+(function({content, sendSyncMessage, addMessageListener, sendAsyncMessage}) {
+
+const Cc = Components.classes;
+const Ci = Components.interfaces;
+const observerService = Cc["@mozilla.org/observer-service;1"]
+                        .getService(Ci.nsIObserverService);
+
+const channels = new Map();
+const handles = new WeakMap();
+
+// Takes remote port handle and creates a local one.
+// also set's up a messaging channel between them.
+// This is temporary workaround until Bug 914974 is fixed
+// and port can be transfered through message manager.
+const demarshal = (handle) => {
+  if (handle.type === "MessagePort") {
+    if (!channels.has(handle.id)) {
+      const channel = new content.MessageChannel();
+      channels.set(handle.id, channel);
+      handles.set(channel.port1, handle);
+      channel.port1.onmessage = onOutPort;
+    }
+    return channels.get(handle.id).port2;
+  }
+  return null;
+};
+
+const onOutPort = event => {
+  const handle = handles.get(event.target);
+  sendAsyncMessage("sdk/port/message", {
+    port: handle,
+    message: event.data
+  });
+};
+
+const onInPort = ({data}) => {
+  const channel = channels.get(data.port.id);
+  if (channel)
+    channel.port1.postMessage(data.message);
+};
+
+const onOutEvent = event =>
+  sendSyncMessage("sdk/event/" + event.type,
+                  { type: event.type,
+                    data: event.data });
+
+const onInMessage = (message) => {
+  const {type, data, origin, bubbles, cancelable, ports} = message.data;
+
+  const event = new content.MessageEvent(type, {
+    bubbles: bubbles,
+    cancelable: cancelable,
+    data: data,
+    origin: origin,
+    target: content,
+    source: content,
+    ports: ports.map(demarshal)
+  });
+  content.dispatchEvent(event);
+};
+
+const onReady = event => {
+  channels.clear();
+};
+
+addMessageListener("sdk/event/message", onInMessage);
+addMessageListener("sdk/port/message", onInPort);
+
+const observer = {
+  handleEvent: ({target, type}) => {
+    observer.observe(target, type);
+  },
+  observe: (document, topic, data) => {
+    // When frame associated with message manager is removed from document `docShell`
+    // is set to `null` but observer is still kept alive. At this point accesing
+    // `content.document` throws "can't access dead object" exceptions. In order to
+    // avoid leaking observer and logged errors observer is going to be removed when
+    // `docShell` is set to `null`.
+    if (!docShell) {
+      observerService.removeObserver(observer, topic);
+    }
+    else if (document === content.document) {
+      if (topic.endsWith("-document-interactive")) {
+        sendAsyncMessage("sdk/event/ready", {
+          type: "ready",
+          readyState: document.readyState,
+          uri: document.documentURI
+        });
+      }
+      if (topic.endsWith("-document-loaded")) {
+        sendAsyncMessage("sdk/event/load", {
+          type: "load",
+          readyState: document.readyState,
+          uri: document.documentURI
+        });
+      }
+      if (topic === "unload") {
+        channels.clear();
+        sendAsyncMessage("sdk/event/unload", {
+          type: "unload",
+          readyState: "uninitialized",
+          uri: document.documentURI
+        });
+      }
+    }
+  }
+};
+
+observerService.addObserver(observer, "content-document-interactive", false);
+observerService.addObserver(observer, "content-document-loaded", false);
+observerService.addObserver(observer, "chrome-document-interactive", false);
+observerService.addObserver(observer, "chrome-document-loaded", false);
+addEventListener("unload", observer, false);
+
+})(this);
diff --git a/toolkit/jetpack/dev/panel.js b/toolkit/jetpack/dev/panel.js
new file mode 100644
index 000000000..1ef6a303a
--- /dev/null
+++ b/toolkit/jetpack/dev/panel.js
@@ -0,0 +1,259 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cu } = require("chrome");
+const { Class } = require("../sdk/core/heritage");
+const { curry } = require("../sdk/lang/functional");
+const { EventTarget } = require("../sdk/event/target");
+const { Disposable, setup, dispose } = require("../sdk/core/disposable");
+const { emit, off, setListeners } = require("../sdk/event/core");
+const { when } = require("../sdk/event/utils");
+const { getFrameElement } = require("../sdk/window/utils");
+const { contract, validate } = require("../sdk/util/contract");
+const { data: { url: resolve }} = require("../sdk/self");
+const { identify } = require("../sdk/ui/id");
+const { isLocalURL, URL } = require("../sdk/url");
+const { encode } = require("../sdk/base64");
+const { marshal, demarshal } = require("./ports");
+const { fromTarget } = require("./debuggee");
+const { removed } = require("../sdk/dom/events");
+const { id: addonID } = require("../sdk/self");
+const { viewFor } = require("../sdk/view/core");
+const { createView } = require("./panel/view");
+
+const OUTER_FRAME_URI = module.uri.replace(/\.js$/, ".html");
+const FRAME_SCRIPT = module.uri.replace("/panel.js", "/frame-script.js");
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+
+const makeID = name =>
+  ("dev-panel-" + addonID + "-" + name).
+  split("/").join("-").
+  split(".").join("-").
+  split(" ").join("-").
+  replace(/[^A-Za-z0-9_\-]/g, "");
+
+
+// Weak mapping between `Panel` instances and their frame's
+// `nsIMessageManager`.
+const managers = new WeakMap();
+// Return `nsIMessageManager` for the given `Panel` instance.
+const managerFor = x => managers.get(x);
+
+// Weak mappinging between iframe's and their owner
+// `Panel` instances.
+const panels = new WeakMap();
+const panelFor = frame => panels.get(frame);
+
+// Weak mapping between panels and debugees they're targeting.
+const debuggees = new WeakMap();
+const debuggeeFor = panel => debuggees.get(panel);
+
+const frames = new WeakMap();
+const frameFor = panel => frames.get(panel);
+
+const setAttributes = (node, attributes) => {
+  for (var key in attributes)
+    node.setAttribute(key, attributes[key]);
+};
+
+const onStateChange = ({target, data}) => {
+  const panel = panelFor(target);
+  panel.readyState = data.readyState;
+  emit(panel, data.type, { target: panel, type: data.type });
+};
+
+// port event listener on the message manager that demarshalls
+// and forwards to the actual receiver. This is a workaround
+// until Bug 914974 is fixed.
+const onPortMessage = ({data, target}) => {
+  const port = demarshal(target, data.port);
+  if (port)
+    port.postMessage(data.message);
+};
+
+// When frame is removed from the toolbox destroy panel
+// associated with it to release all the resources.
+const onFrameRemove = frame => {
+  panelFor(frame).destroy();
+};
+
+const onFrameInited = frame => {
+  frame.style.visibility = "visible";
+}
+
+const inited = frame => new Promise(resolve => {
+  const { messageManager } = frame.frameLoader;
+  const listener = message => {
+    messageManager.removeMessageListener("sdk/event/ready", listener);
+    resolve(frame);
+  };
+  messageManager.addMessageListener("sdk/event/ready", listener);
+});
+
+const getTarget = ({target}) => target;
+
+const Panel = Class({
+  extends: Disposable,
+  implements: [EventTarget],
+  get id() {
+    return makeID(this.name || this.label);
+  },
+  readyState: "uninitialized",
+  ready: function() {
+    const { readyState } = this;
+    const isReady = readyState === "complete" ||
+                    readyState === "interactive";
+    return isReady ? Promise.resolve(this) :
+           when(this, "ready").then(getTarget);
+  },
+  loaded: function() {
+    const { readyState } = this;
+    const isLoaded = readyState === "complete";
+    return isLoaded ? Promise.resolve(this) :
+           when(this, "load").then(getTarget);
+  },
+  unloaded: function() {
+    const { readyState } = this;
+    const isUninitialized = readyState === "uninitialized";
+    return isUninitialized ? Promise.resolve(this) :
+           when(this, "unload").then(getTarget);
+  },
+  postMessage: function(data, ports=[]) {
+    const manager = managerFor(this);
+    manager.sendAsyncMessage("sdk/event/message", {
+      type: "message",
+      bubbles: false,
+      cancelable: false,
+      data: data,
+      origin: this.url,
+      ports: ports.map(marshal(manager))
+    });
+  }
+});
+exports.Panel = Panel;
+
+validate.define(Panel, contract({
+  label: {
+    is: ["string"],
+    msg: "The `option.label` must be a provided"
+  },
+  tooltip: {
+    is: ["string", "undefined"],
+    msg: "The `option.tooltip` must be a string"
+  },
+  icon: {
+    is: ["string"],
+    map: x => x && resolve(x),
+    ok: x => isLocalURL(x),
+    msg: "The `options.icon` must be a valid local URI."
+  },
+  url: {
+    map: x => resolve(x.toString()),
+    is: ["string"],
+    ok: x => isLocalURL(x),
+    msg: "The `options.url` must be a valid local URI."
+  },
+  invertIconForLightTheme: {
+    is: ["boolean", "undefined"],
+    msg: "The `options.invertIconForLightTheme` must be a boolean."
+  },
+  invertIconForDarkTheme: {
+    is: ["boolean", "undefined"],
+    msg: "The `options.invertIconForDarkTheme` must be a boolean."
+  }
+}));
+
+setup.define(Panel, (panel, {window, toolbox, url}) => {
+  // Hack: Given that iframe created by devtools API is no good for us,
+  // we obtain original iframe and replace it with the one that has
+  // desired configuration.
+  const original = getFrameElement(window);
+  const container = original.parentNode;
+  original.remove();
+  const frame = createView(panel, container.ownerDocument);
+
+  // Following modifications are a temporary workaround until Bug 1049188
+  // is fixed.
+  // Enforce certain iframe customizations regardless of users request.
+  setAttributes(frame, {
+    "id": original.id,
+    "src": url,
+    "flex": 1,
+    "forceOwnRefreshDriver": "",
+    "tooltip": "aHTMLTooltip"
+  });
+  frame.style.visibility = "hidden";
+  frame.classList.add("toolbox-panel-iframe");
+  // Inject iframe into designated node until add-on author decides
+  // to inject it elsewhere instead.
+  if (!frame.parentNode)
+    container.appendChild(frame);
+
+  // associate view with a panel
+  frames.set(panel, frame);
+
+  // associate panel model with a frame view.
+  panels.set(frame, panel);
+
+  const debuggee = fromTarget(toolbox.target);
+  // associate debuggee with a panel.
+  debuggees.set(panel, debuggee);
+
+
+  // Setup listeners for the frame message manager.
+  const { messageManager } = frame.frameLoader;
+  messageManager.addMessageListener("sdk/event/ready", onStateChange);
+  messageManager.addMessageListener("sdk/event/load", onStateChange);
+  messageManager.addMessageListener("sdk/event/unload", onStateChange);
+  messageManager.addMessageListener("sdk/port/message", onPortMessage);
+  messageManager.loadFrameScript(FRAME_SCRIPT, false);
+
+  managers.set(panel, messageManager);
+
+  // destroy panel if frame is removed.
+  removed(frame).then(onFrameRemove);
+  // show frame when it is initialized.
+  inited(frame).then(onFrameInited);
+
+
+  // set listeners if there are ones defined on the prototype.
+  setListeners(panel, Object.getPrototypeOf(panel));
+
+
+  panel.setup({ debuggee: debuggee });
+});
+
+createView.define(Panel, (panel, document) => {
+  const frame = document.createElement("iframe");
+  setAttributes(frame, {
+    "sandbox": "allow-scripts",
+    // We end up using chrome iframe with forced message manager
+    // as fixing a swapFrameLoader seemed like a giant task (see
+    // Bug 1075490).
+    "type": "chrome",
+    "forcemessagemanager": true,
+    "transparent": true,
+    "seamless": "seamless",
+  });
+  return frame;
+});
+
+dispose.define(Panel, function(panel) {
+  debuggeeFor(panel).close();
+
+  debuggees.delete(panel);
+  managers.delete(panel);
+  frames.delete(panel);
+  panel.readyState = "destroyed";
+  panel.dispose();
+});
+
+viewFor.define(Panel, frameFor);
diff --git a/toolkit/jetpack/dev/panel/view.js b/toolkit/jetpack/dev/panel/view.js
new file mode 100644
index 000000000..41cf9c221
--- /dev/null
+++ b/toolkit/jetpack/dev/panel/view.js
@@ -0,0 +1,14 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { method } = require("method/core");
+
+const createView = method("dev/panel/view#createView");
+exports.createView = createView;
diff --git a/toolkit/jetpack/dev/ports.js b/toolkit/jetpack/dev/ports.js
new file mode 100644
index 000000000..a41f59eb7
--- /dev/null
+++ b/toolkit/jetpack/dev/ports.js
@@ -0,0 +1,64 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+// This module provides `marshal` and `demarshal` functions
+// that can be used to send  MessagePort's over `nsIFrameMessageManager`
+// until Bug 914974 is fixed.
+
+const { add, iterator } = require("../sdk/lang/weak-set");
+const { curry } = require("../sdk/lang/functional");
+
+var id = 0;
+const ports = new WeakMap();
+
+// Takes `nsIFrameMessageManager` and `MessagePort` instances
+// and returns a handle representing given `port`. Messages
+// received on given `port` will be forwarded to a message
+// manager under `sdk/port/message` and messages like:
+// { port: { type: "MessagePort", id: 2}, data: data }
+// Where id is an identifier associated with a given `port`
+// and `data` is an `event.data` received on port.
+const marshal = curry((manager, port) => {
+  if (!ports.has(port)) {
+    id = id + 1;
+    const handle = {type: "MessagePort", id: id};
+    // Bind id to the given port
+    ports.set(port, handle);
+
+    // Obtain a weak reference to a port.
+    add(exports, port);
+
+    port.onmessage = event => {
+      manager.sendAsyncMessage("sdk/port/message", {
+        port: handle,
+        message: event.data
+      });
+    };
+
+    return handle;
+  }
+  return ports.get(port);
+});
+exports.marshal = marshal;
+
+// Takes `nsIFrameMessageManager` instance and a handle returned
+// `marshal(manager, port)` returning a `port` that was passed
+// to it. Note that `port` may be GC-ed in which case returned
+// value will be `null`.
+const demarshal = curry((manager, {type, id}) => {
+  if (type === "MessagePort") {
+    for (let port of iterator(exports)) {
+      if (id === ports.get(port).id)
+        return port;
+    }
+  }
+  return null;
+});
+exports.demarshal = demarshal;
diff --git a/toolkit/jetpack/dev/theme.js b/toolkit/jetpack/dev/theme.js
new file mode 100644
index 000000000..05930a502
--- /dev/null
+++ b/toolkit/jetpack/dev/theme.js
@@ -0,0 +1,135 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Class } = require("../sdk/core/heritage");
+const { EventTarget } = require("../sdk/event/target");
+const { Disposable, setup, dispose } = require("../sdk/core/disposable");
+const { contract, validate } = require("../sdk/util/contract");
+const { id: addonID } = require("../sdk/self");
+const { onEnable, onDisable } = require("dev/theme/hooks");
+const { isString, instanceOf, isFunction } = require("sdk/lang/type");
+const { add } = require("sdk/util/array");
+const { data } = require("../sdk/self");
+const { isLocalURL } = require("../sdk/url");
+
+const makeID = name =>
+  ("dev-theme-" + addonID + (name ? "-" + name : "")).
+  split(/[ . /]/).join("-").
+  replace(/[^A-Za-z0-9_\-]/g, "");
+
+const Theme = Class({
+  extends: Disposable,
+  implements: [EventTarget],
+
+  initialize: function(options) {
+    this.name = options.name;
+    this.label = options.label;
+    this.styles = options.styles;
+
+    // Event handlers
+    this.onEnable = options.onEnable;
+    this.onDisable = options.onDisable;
+  },
+  get id() {
+    return makeID(this.name || this.label);
+  },
+  setup: function() {
+    // Any initialization steps done at the registration time.
+  },
+  getStyles: function() {
+    if (!this.styles) {
+      return [];
+    }
+
+    if (isString(this.styles)) {
+      if (isLocalURL(this.styles)) {
+        return [data.url(this.styles)];
+      }
+    }
+
+    let result = [];
+    for (let style of this.styles) {
+      if (isString(style)) {
+        if (isLocalURL(style)) {
+          style = data.url(style);
+        }
+        add(result, style);
+      } else if (instanceOf(style, Theme)) {
+        result = result.concat(style.getStyles());
+      }
+    }
+    return result;
+  },
+  getClassList: function() {
+    let result = [];
+    for (let style of this.styles) {
+      if (instanceOf(style, Theme)) {
+        result = result.concat(style.getClassList());
+      }
+    }
+
+    if (this.name) {
+      add(result, this.name);
+    }
+
+    return result;
+  }
+});
+
+exports.Theme = Theme;
+
+// Initialization & dispose
+
+setup.define(Theme, (theme) => {
+  theme.classList = [];
+  theme.setup();
+});
+
+dispose.define(Theme, function(theme) {
+  theme.dispose();
+});
+
+// Validation
+
+validate.define(Theme, contract({
+  label: {
+    is: ["string"],
+    msg: "The `option.label` must be a provided"
+  },
+}));
+
+// Support theme events: apply and unapply the theme.
+
+onEnable.define(Theme, (theme, {window, oldTheme}) => {
+  if (isFunction(theme.onEnable)) {
+    theme.onEnable(window, oldTheme);
+  }
+});
+
+onDisable.define(Theme, (theme, {window, newTheme}) => {
+  if (isFunction(theme.onDisable)) {
+    theme.onDisable(window, newTheme);
+  }
+});
+
+// Support for built-in themes
+
+const LightTheme = Theme({
+  name: "theme-light",
+  styles: "chrome://devtools/skin/light-theme.css",
+});
+
+const DarkTheme = Theme({
+  name: "theme-dark",
+  styles: "chrome://devtools/skin/dark-theme.css",
+});
+
+exports.LightTheme = LightTheme;
+exports.DarkTheme = DarkTheme;
diff --git a/toolkit/jetpack/dev/theme/hooks.js b/toolkit/jetpack/dev/theme/hooks.js
new file mode 100644
index 000000000..9987f853b
--- /dev/null
+++ b/toolkit/jetpack/dev/theme/hooks.js
@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { method } = require("method/core");
+
+const onEnable = method("dev/theme/hooks#onEnable");
+const onDisable = method("dev/theme/hooks#onDisable");
+
+exports.onEnable = onEnable;
+exports.onDisable = onDisable;
diff --git a/toolkit/jetpack/dev/toolbox.js b/toolkit/jetpack/dev/toolbox.js
new file mode 100644
index 000000000..43f37759f
--- /dev/null
+++ b/toolkit/jetpack/dev/toolbox.js
@@ -0,0 +1,107 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cu, Cc, Ci } = require("chrome");
+const { Class } = require("../sdk/core/heritage");
+const { Disposable, setup } = require("../sdk/core/disposable");
+const { contract, validate } = require("../sdk/util/contract");
+const { each, pairs, values } = require("../sdk/util/sequence");
+const { onEnable, onDisable } = require("../dev/theme/hooks");
+
+const { gDevTools } = Cu.import("resource://devtools/client/framework/gDevTools.jsm", {});
+
+// This is temporary workaround to allow loading of the developer tools client - volcan
+// into a toolbox panel, this hack won't be necessary as soon as devtools patch will be
+// shipped in nightly, after which it can be removed. Bug 1038517
+const registerSDKURI = () => {
+  const ioService = Cc['@mozilla.org/network/io-service;1']
+                      .getService(Ci.nsIIOService);
+  const resourceHandler = ioService.getProtocolHandler("resource")
+                                   .QueryInterface(Ci.nsIResProtocolHandler);
+
+  const uri = module.uri.replace("dev/toolbox.js", "");
+  resourceHandler.setSubstitution("sdk", ioService.newURI(uri, null, null));
+};
+
+registerSDKURI();
+
+const Tool = Class({
+  extends: Disposable,
+  setup: function(params={}) {
+    const { panels } = validate(this, params);
+    const { themes } = validate(this, params);
+
+    this.panels = panels;
+    this.themes = themes;
+
+    each(([key, Panel]) => {
+      const { url, label, tooltip, icon, invertIconForLightTheme,
+              invertIconForDarkTheme } = validate(Panel.prototype);
+      const { id } = Panel.prototype;
+
+      gDevTools.registerTool({
+        id: id,
+        url: "about:blank",
+        label: label,
+        tooltip: tooltip,
+        icon: icon,
+        invertIconForLightTheme: invertIconForLightTheme,
+        invertIconForDarkTheme: invertIconForDarkTheme,
+        isTargetSupported: target => target.isLocalTab,
+        build: (window, toolbox) => {
+          const panel = new Panel();
+          setup(panel, { window: window,
+                         toolbox: toolbox,
+                         url: url });
+
+          return panel.ready();
+        }
+      });
+    }, pairs(panels));
+
+    each(([key, theme]) => {
+      validate(theme);
+      setup(theme);
+
+      gDevTools.registerTheme({
+        id: theme.id,
+        label: theme.label,
+        stylesheets: theme.getStyles(),
+        classList: theme.getClassList(),
+        onApply: (window, oldTheme) => {
+          onEnable(theme, { window: window,
+                            oldTheme: oldTheme });
+        },
+        onUnapply: (window, newTheme) => {
+          onDisable(theme, { window: window,
+                            newTheme: newTheme });
+        }
+      });
+    }, pairs(themes));
+  },
+  dispose: function() {
+    each(Panel => gDevTools.unregisterTool(Panel.prototype.id),
+         values(this.panels));
+
+    each(Theme => gDevTools.unregisterTheme(Theme.prototype.id),
+         values(this.themes));
+  }
+});
+
+validate.define(Tool, contract({
+  panels: {
+    is: ["object", "undefined"]
+  },
+  themes: {
+    is: ["object", "undefined"]
+  }
+}));
+
+exports.Tool = Tool;
diff --git a/toolkit/jetpack/dev/utils.js b/toolkit/jetpack/dev/utils.js
new file mode 100644
index 000000000..48db39e04
--- /dev/null
+++ b/toolkit/jetpack/dev/utils.js
@@ -0,0 +1,40 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+const { Cu } = require("chrome");
+const { gDevTools } = Cu.import("resource://devtools/client/framework/gDevTools.jsm", {});
+const { devtools } = Cu.import("resource://devtools/shared/Loader.jsm", {});
+
+const { getActiveTab } = require("../sdk/tabs/utils");
+const { getMostRecentBrowserWindow } = require("../sdk/window/utils");
+
+const targetFor = target => {
+  target = target || getActiveTab(getMostRecentBrowserWindow());
+  return devtools.TargetFactory.forTab(target);
+};
+
+const getId = id => ((id.prototype && id.prototype.id) || id.id || id);
+
+const getCurrentPanel = toolbox => toolbox.getCurrentPanel();
+exports.getCurrentPanel = getCurrentPanel;
+
+const openToolbox = (id, tab) => {
+  id = getId(id);
+  return gDevTools.showToolbox(targetFor(tab), id);
+};
+exports.openToolbox = openToolbox;
+
+const closeToolbox = tab => gDevTools.closeToolbox(targetFor(tab));
+exports.closeToolbox = closeToolbox;
+
+const getToolbox = tab => gDevTools.getToolbox(targetFor(tab));
+exports.getToolbox = getToolbox;
+
+const openToolboxPanel = (id, tab) => {
+  id = getId(id);
+  return gDevTools.showToolbox(targetFor(tab), id).then(getCurrentPanel);
+};
+exports.openToolboxPanel = openToolboxPanel;
diff --git a/toolkit/jetpack/dev/volcan.js b/toolkit/jetpack/dev/volcan.js
new file mode 100644
index 000000000..6a68ed12d
--- /dev/null
+++ b/toolkit/jetpack/dev/volcan.js
@@ -0,0 +1,3848 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+!function(e){if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.volcan=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
+"use strict";
+
+var Client = _dereq_("../client").Client;
+
+function connect(port) {
+  var client = new Client();
+  return client.connect(port);
+}
+exports.connect = connect;
+
+},{"../client":4}],2:[function(_dereq_,module,exports){
+"use strict";
+
+exports.Promise = Promise;
+
+},{}],3:[function(_dereq_,module,exports){
+"use strict";
+
+var describe = Object.getOwnPropertyDescriptor;
+var Class = function(fields) {
+  var names = Object.keys(fields);
+  var constructor = names.indexOf("constructor") >= 0 ? fields.constructor :
+                    function() {};
+  var ancestor = fields.extends || Object;
+
+  var descriptor = names.reduce(function(descriptor, key) {
+    descriptor[key] = describe(fields, key);
+    return descriptor;
+  }, {});
+
+  var prototype = Object.create(ancestor.prototype, descriptor);
+
+  constructor.prototype = prototype;
+  prototype.constructor = constructor;
+
+  return constructor;
+};
+exports.Class = Class;
+
+},{}],4:[function(_dereq_,module,exports){
+"use strict";
+
+var Class = _dereq_("./class").Class;
+var TypeSystem = _dereq_("./type-system").TypeSystem;
+var values = _dereq_("./util").values;
+var Promise = _dereq_("es6-promise").Promise;
+var MessageEvent = _dereq_("./event").MessageEvent;
+
+var specification = _dereq_("./specification/core.json");
+
+function recoverActorDescriptions(error) {
+  console.warn("Failed to fetch protocol specification (see reason below). " +
+               "Using a fallback protocal specification!",
+               error);
+  return _dereq_("./specification/protocol.json");
+}
+
+// Type to represent superviser actor relations to actors they supervise
+// in terms of lifetime management.
+var Supervisor = Class({
+  constructor: function(id) {
+    this.id = id;
+    this.workers = [];
+  }
+});
+
+var Telemetry = Class({
+  add: function(id, ms) {
+    console.log("telemetry::", id, ms)
+  }
+});
+
+// Consider making client a root actor.
+
+var Client = Class({
+  constructor: function() {
+    this.root = null;
+    this.telemetry = new Telemetry();
+
+    this.setupConnection();
+    this.setupLifeManagement();
+    this.setupTypeSystem();
+  },
+
+  setupConnection: function() {
+    this.requests = [];
+  },
+  setupLifeManagement: function() {
+    this.cache = Object.create(null);
+    this.graph = Object.create(null);
+    this.get = this.get.bind(this);
+    this.release = this.release.bind(this);
+  },
+  setupTypeSystem: function() {
+    this.typeSystem = new TypeSystem(this);
+    this.typeSystem.registerTypes(specification);
+  },
+
+  connect: function(port) {
+    var client = this;
+    return new Promise(function(resolve, reject) {
+      client.port = port;
+      port.onmessage = client.receive.bind(client);
+      client.onReady = resolve;
+      client.onFail = reject;
+
+      port.start();
+    });
+  },
+  send: function(packet) {
+    this.port.postMessage(packet);
+  },
+  request: function(packet) {
+    var client = this;
+    return new Promise(function(resolve, reject) {
+      client.requests.push(packet.to, { resolve: resolve, reject: reject });
+      client.send(packet);
+    });
+  },
+
+  receive: function(event) {
+    var packet = event.data;
+    if (!this.root) {
+      if (packet.from !== "root")
+        throw Error("Initial packet must be from root");
+      if (!("applicationType" in packet))
+        throw Error("Initial packet must contain applicationType field");
+
+      this.root = this.typeSystem.read("root", null, "root");
+      this.root
+          .protocolDescription()
+          .catch(recoverActorDescriptions)
+          .then(this.typeSystem.registerTypes.bind(this.typeSystem))
+          .then(this.onReady.bind(this, this.root), this.onFail);
+    } else {
+      var actor = this.get(packet.from) || this.root;
+      var event = actor.events[packet.type];
+      if (event) {
+        var message = new MessageEvent(packet.type, {
+          data: event.read(packet)
+        });
+        actor.dispatchEvent(message);
+      } else {
+        var index = this.requests.indexOf(actor.id);
+        if (index >= 0) {
+          var request = this.requests.splice(index, 2).pop();
+          if (packet.error)
+            request.reject(packet);
+          else
+            request.resolve(packet);
+        } else {
+          console.error(Error("Unexpected packet " + JSON.stringify(packet, 2, 2)),
+                        packet,
+                        this.requests.slice(0));
+        }
+      }
+    }
+  },
+
+  get: function(id) {
+    return this.cache[id];
+  },
+  supervisorOf: function(actor) {
+    for (var id in this.graph) {
+      if (this.graph[id].indexOf(actor.id) >= 0) {
+        return id;
+      }
+    }
+  },
+  workersOf: function(actor) {
+    return this.graph[actor.id];
+  },
+  supervise: function(actor, worker) {
+    var workers = this.workersOf(actor)
+    if (workers.indexOf(worker.id) < 0) {
+      workers.push(worker.id);
+    }
+  },
+  unsupervise: function(actor, worker) {
+    var workers = this.workersOf(actor);
+    var index = workers.indexOf(worker.id)
+    if (index >= 0) {
+      workers.splice(index, 1)
+    }
+  },
+
+  register: function(actor) {
+    var registered = this.get(actor.id);
+    if (!registered) {
+      this.cache[actor.id] = actor;
+      this.graph[actor.id] = [];
+    } else if (registered !== actor) {
+      throw new Error("Different actor with same id is already registered");
+    }
+  },
+  unregister: function(actor) {
+    if (this.get(actor.id)) {
+      delete this.cache[actor.id];
+      delete this.graph[actor.id];
+    }
+  },
+
+  release: function(actor) {
+    var supervisor = this.supervisorOf(actor);
+    if (supervisor)
+      this.unsupervise(supervisor, actor);
+
+    var workers = this.workersOf(actor)
+
+    if (workers) {
+      workers.map(this.get).forEach(this.release)
+    }
+    this.unregister(actor);
+  }
+});
+exports.Client = Client;
+
+},{"./class":3,"./event":5,"./specification/core.json":23,"./specification/protocol.json":24,"./type-system":25,"./util":26,"es6-promise":2}],5:[function(_dereq_,module,exports){
+"use strict";
+
+var Symbol = _dereq_("es6-symbol")
+var EventEmitter = _dereq_("events").EventEmitter;
+var Class = _dereq_("./class").Class;
+
+var $bound = Symbol("EventTarget/handleEvent");
+var $emitter = Symbol("EventTarget/emitter");
+
+function makeHandler(handler) {
+  return function(event) {
+    handler.handleEvent(event);
+  }
+}
+
+var EventTarget = Class({
+  constructor: function() {
+    Object.defineProperty(this, $emitter, {
+      enumerable: false,
+      configurable: true,
+      writable: true,
+      value: new EventEmitter()
+    });
+  },
+  addEventListener: function(type, handler) {
+    if (typeof(handler) === "function") {
+      this[$emitter].on(type, handler);
+    }
+    else if (handler && typeof(handler) === "object") {
+      if (!handler[$bound]) handler[$bound] = makeHandler(handler);
+      this[$emitter].on(type, handler[$bound]);
+    }
+  },
+  removeEventListener: function(type, handler) {
+    if (typeof(handler) === "function")
+      this[$emitter].removeListener(type, handler);
+    else if (handler && handler[$bound])
+      this[$emitter].removeListener(type, handler[$bound]);
+  },
+  dispatchEvent: function(event) {
+    event.target = this;
+    this[$emitter].emit(event.type, event);
+  }
+});
+exports.EventTarget = EventTarget;
+
+var MessageEvent = Class({
+  constructor: function(type, options) {
+    options = options || {};
+    this.type = type;
+    this.data = options.data === void(0) ? null : options.data;
+
+    this.lastEventId = options.lastEventId || "";
+    this.origin = options.origin || "";
+    this.bubbles = options.bubbles || false;
+    this.cancelable = options.cancelable || false;
+  },
+  source: null,
+  ports: null,
+  preventDefault: function() {
+  },
+  stopPropagation: function() {
+  },
+  stopImmediatePropagation: function() {
+  }
+});
+exports.MessageEvent = MessageEvent;
+
+},{"./class":3,"es6-symbol":7,"events":6}],6:[function(_dereq_,module,exports){
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+function EventEmitter() {
+  this._events = this._events || {};
+  this._maxListeners = this._maxListeners || undefined;
+}
+module.exports = EventEmitter;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+  if (!isNumber(n) || n < 0 || isNaN(n))
+    throw TypeError('n must be a positive number');
+  this._maxListeners = n;
+  return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+  var er, handler, len, args, i, listeners;
+
+  if (!this._events)
+    this._events = {};
+
+  // If there is no 'error' event listener then throw.
+  if (type === 'error') {
+    if (!this._events.error ||
+        (isObject(this._events.error) && !this._events.error.length)) {
+      er = arguments[1];
+      if (er instanceof Error) {
+        throw er; // Unhandled 'error' event
+      } else {
+        throw TypeError('Uncaught, unspecified "error" event.');
+      }
+      return false;
+    }
+  }
+
+  handler = this._events[type];
+
+  if (isUndefined(handler))
+    return false;
+
+  if (isFunction(handler)) {
+    switch (arguments.length) {
+      // fast cases
+      case 1:
+        handler.call(this);
+        break;
+      case 2:
+        handler.call(this, arguments[1]);
+        break;
+      case 3:
+        handler.call(this, arguments[1], arguments[2]);
+        break;
+      // slower
+      default:
+        len = arguments.length;
+        args = new Array(len - 1);
+        for (i = 1; i < len; i++)
+          args[i - 1] = arguments[i];
+        handler.apply(this, args);
+    }
+  } else if (isObject(handler)) {
+    len = arguments.length;
+    args = new Array(len - 1);
+    for (i = 1; i < len; i++)
+      args[i - 1] = arguments[i];
+
+    listeners = handler.slice();
+    len = listeners.length;
+    for (i = 0; i < len; i++)
+      listeners[i].apply(this, args);
+  }
+
+  return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+  var m;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events)
+    this._events = {};
+
+  // To avoid recursion in the case that type === "newListener"! Before
+  // adding it to the listeners, first emit "newListener".
+  if (this._events.newListener)
+    this.emit('newListener', type,
+              isFunction(listener.listener) ?
+              listener.listener : listener);
+
+  if (!this._events[type])
+    // Optimize the case of one listener. Don't need the extra array object.
+    this._events[type] = listener;
+  else if (isObject(this._events[type]))
+    // If we've already got an array, just append.
+    this._events[type].push(listener);
+  else
+    // Adding the second element, need to change to array.
+    this._events[type] = [this._events[type], listener];
+
+  // Check for listener leak
+  if (isObject(this._events[type]) && !this._events[type].warned) {
+    var m;
+    if (!isUndefined(this._maxListeners)) {
+      m = this._maxListeners;
+    } else {
+      m = EventEmitter.defaultMaxListeners;
+    }
+
+    if (m && m > 0 && this._events[type].length > m) {
+      this._events[type].warned = true;
+      console.error('(node) warning: possible EventEmitter memory ' +
+                    'leak detected. %d listeners added. ' +
+                    'Use emitter.setMaxListeners() to increase limit.',
+                    this._events[type].length);
+      if (typeof console.trace === 'function') {
+        // not supported in IE 10
+        console.trace();
+      }
+    }
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  var fired = false;
+
+  function g() {
+    this.removeListener(type, g);
+
+    if (!fired) {
+      fired = true;
+      listener.apply(this, arguments);
+    }
+  }
+
+  g.listener = listener;
+  this.on(type, g);
+
+  return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+  var list, position, length, i;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events || !this._events[type])
+    return this;
+
+  list = this._events[type];
+  length = list.length;
+  position = -1;
+
+  if (list === listener ||
+      (isFunction(list.listener) && list.listener === listener)) {
+    delete this._events[type];
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+
+  } else if (isObject(list)) {
+    for (i = length; i-- > 0;) {
+      if (list[i] === listener ||
+          (list[i].listener && list[i].listener === listener)) {
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0)
+      return this;
+
+    if (list.length === 1) {
+      list.length = 0;
+      delete this._events[type];
+    } else {
+      list.splice(position, 1);
+    }
+
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+  var key, listeners;
+
+  if (!this._events)
+    return this;
+
+  // not listening for removeListener, no need to emit
+  if (!this._events.removeListener) {
+    if (arguments.length === 0)
+      this._events = {};
+    else if (this._events[type])
+      delete this._events[type];
+    return this;
+  }
+
+  // emit removeListener for all listeners on all events
+  if (arguments.length === 0) {
+    for (key in this._events) {
+      if (key === 'removeListener') continue;
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners('removeListener');
+    this._events = {};
+    return this;
+  }
+
+  listeners = this._events[type];
+
+  if (isFunction(listeners)) {
+    this.removeListener(type, listeners);
+  } else {
+    // LIFO order
+    while (listeners.length)
+      this.removeListener(type, listeners[listeners.length - 1]);
+  }
+  delete this._events[type];
+
+  return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+  var ret;
+  if (!this._events || !this._events[type])
+    ret = [];
+  else if (isFunction(this._events[type]))
+    ret = [this._events[type]];
+  else
+    ret = this._events[type].slice();
+  return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  var ret;
+  if (!emitter._events || !emitter._events[type])
+    ret = 0;
+  else if (isFunction(emitter._events[type]))
+    ret = 1;
+  else
+    ret = emitter._events[type].length;
+  return ret;
+};
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+
+},{}],7:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = _dereq_('./is-implemented')() ? Symbol : _dereq_('./polyfill');
+
+},{"./is-implemented":8,"./polyfill":22}],8:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function () {
+	var symbol;
+	if (typeof Symbol !== 'function') return false;
+	symbol = Symbol('test symbol');
+	try {
+		if (String(symbol) !== 'Symbol (test symbol)') return false;
+	} catch (e) { return false; }
+	if (typeof Symbol.iterator === 'symbol') return true;
+
+	// Return 'true' for polyfills
+	if (typeof Symbol.isConcatSpreadable !== 'object') return false;
+	if (typeof Symbol.isRegExp !== 'object') return false;
+	if (typeof Symbol.iterator !== 'object') return false;
+	if (typeof Symbol.toPrimitive !== 'object') return false;
+	if (typeof Symbol.toStringTag !== 'object') return false;
+	if (typeof Symbol.unscopables !== 'object') return false;
+
+	return true;
+};
+
+},{}],9:[function(_dereq_,module,exports){
+'use strict';
+
+var assign        = _dereq_('es5-ext/object/assign')
+  , normalizeOpts = _dereq_('es5-ext/object/normalize-options')
+  , isCallable    = _dereq_('es5-ext/object/is-callable')
+  , contains      = _dereq_('es5-ext/string/#/contains')
+
+  , d;
+
+d = module.exports = function (dscr, value/*, options*/) {
+	var c, e, w, options, desc;
+	if ((arguments.length < 2) || (typeof dscr !== 'string')) {
+		options = value;
+		value = dscr;
+		dscr = null;
+	} else {
+		options = arguments[2];
+	}
+	if (dscr == null) {
+		c = w = true;
+		e = false;
+	} else {
+		c = contains.call(dscr, 'c');
+		e = contains.call(dscr, 'e');
+		w = contains.call(dscr, 'w');
+	}
+
+	desc = { value: value, configurable: c, enumerable: e, writable: w };
+	return !options ? desc : assign(normalizeOpts(options), desc);
+};
+
+d.gs = function (dscr, get, set/*, options*/) {
+	var c, e, options, desc;
+	if (typeof dscr !== 'string') {
+		options = set;
+		set = get;
+		get = dscr;
+		dscr = null;
+	} else {
+		options = arguments[3];
+	}
+	if (get == null) {
+		get = undefined;
+	} else if (!isCallable(get)) {
+		options = get;
+		get = set = undefined;
+	} else if (set == null) {
+		set = undefined;
+	} else if (!isCallable(set)) {
+		options = set;
+		set = undefined;
+	}
+	if (dscr == null) {
+		c = true;
+		e = false;
+	} else {
+		c = contains.call(dscr, 'c');
+		e = contains.call(dscr, 'e');
+	}
+
+	desc = { get: get, set: set, configurable: c, enumerable: e };
+	return !options ? desc : assign(normalizeOpts(options), desc);
+};
+
+},{"es5-ext/object/assign":10,"es5-ext/object/is-callable":13,"es5-ext/object/normalize-options":17,"es5-ext/string/#/contains":19}],10:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = _dereq_('./is-implemented')()
+	? Object.assign
+	: _dereq_('./shim');
+
+},{"./is-implemented":11,"./shim":12}],11:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function () {
+	var assign = Object.assign, obj;
+	if (typeof assign !== 'function') return false;
+	obj = { foo: 'raz' };
+	assign(obj, { bar: 'dwa' }, { trzy: 'trzy' });
+	return (obj.foo + obj.bar + obj.trzy) === 'razdwatrzy';
+};
+
+},{}],12:[function(_dereq_,module,exports){
+'use strict';
+
+var keys  = _dereq_('../keys')
+  , value = _dereq_('../valid-value')
+
+  , max = Math.max;
+
+module.exports = function (dest, src/*, …srcn*/) {
+	var error, i, l = max(arguments.length, 2), assign;
+	dest = Object(value(dest));
+	assign = function (key) {
+		try { dest[key] = src[key]; } catch (e) {
+			if (!error) error = e;
+		}
+	};
+	for (i = 1; i < l; ++i) {
+		src = arguments[i];
+		keys(src).forEach(assign);
+	}
+	if (error !== undefined) throw error;
+	return dest;
+};
+
+},{"../keys":14,"../valid-value":18}],13:[function(_dereq_,module,exports){
+// Deprecated
+
+'use strict';
+
+module.exports = function (obj) { return typeof obj === 'function'; };
+
+},{}],14:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = _dereq_('./is-implemented')()
+	? Object.keys
+	: _dereq_('./shim');
+
+},{"./is-implemented":15,"./shim":16}],15:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function () {
+	try {
+		Object.keys('primitive');
+		return true;
+	} catch (e) { return false; }
+};
+
+},{}],16:[function(_dereq_,module,exports){
+'use strict';
+
+var keys = Object.keys;
+
+module.exports = function (object) {
+	return keys(object == null ? object : Object(object));
+};
+
+},{}],17:[function(_dereq_,module,exports){
+'use strict';
+
+var assign = _dereq_('./assign')
+
+  , forEach = Array.prototype.forEach
+  , create = Object.create, getPrototypeOf = Object.getPrototypeOf
+
+  , process;
+
+process = function (src, obj) {
+	var proto = getPrototypeOf(src);
+	return assign(proto ? process(proto, obj) : obj, src);
+};
+
+module.exports = function (options/*, …options*/) {
+	var result = create(null);
+	forEach.call(arguments, function (options) {
+		if (options == null) return;
+		process(Object(options), result);
+	});
+	return result;
+};
+
+},{"./assign":10}],18:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = function (value) {
+	if (value == null) throw new TypeError("Cannot use null or undefined");
+	return value;
+};
+
+},{}],19:[function(_dereq_,module,exports){
+'use strict';
+
+module.exports = _dereq_('./is-implemented')()
+	? String.prototype.contains
+	: _dereq_('./shim');
+
+},{"./is-implemented":20,"./shim":21}],20:[function(_dereq_,module,exports){
+'use strict';
+
+var str = 'razdwatrzy';
+
+module.exports = function () {
+	if (typeof str.contains !== 'function') return false;
+	return ((str.contains('dwa') === true) && (str.contains('foo') === false));
+};
+
+},{}],21:[function(_dereq_,module,exports){
+'use strict';
+
+var indexOf = String.prototype.indexOf;
+
+module.exports = function (searchString/*, position*/) {
+	return indexOf.call(this, searchString, arguments[1]) > -1;
+};
+
+},{}],22:[function(_dereq_,module,exports){
+'use strict';
+
+var d = _dereq_('d')
+
+  , create = Object.create, defineProperties = Object.defineProperties
+  , generateName, Symbol;
+
+generateName = (function () {
+	var created = create(null);
+	return function (desc) {
+		var postfix = 0;
+		while (created[desc + (postfix || '')]) ++postfix;
+		desc += (postfix || '');
+		created[desc] = true;
+		return '@@' + desc;
+	};
+}());
+
+module.exports = Symbol = function (description) {
+	var symbol;
+	if (this instanceof Symbol) {
+		throw new TypeError('TypeError: Symbol is not a constructor');
+	}
+	symbol = create(Symbol.prototype);
+	description = (description === undefined ? '' : String(description));
+	return defineProperties(symbol, {
+		__description__: d('', description),
+		__name__: d('', generateName(description))
+	});
+};
+
+Object.defineProperties(Symbol, {
+	create: d('', Symbol('create')),
+	hasInstance: d('', Symbol('hasInstance')),
+	isConcatSpreadable: d('', Symbol('isConcatSpreadable')),
+	isRegExp: d('', Symbol('isRegExp')),
+	iterator: d('', Symbol('iterator')),
+	toPrimitive: d('', Symbol('toPrimitive')),
+	toStringTag: d('', Symbol('toStringTag')),
+	unscopables: d('', Symbol('unscopables'))
+});
+
+defineProperties(Symbol.prototype, {
+	properToString: d(function () {
+		return 'Symbol (' + this.__description__ + ')';
+	}),
+	toString: d('', function () { return this.__name__; })
+});
+Object.defineProperty(Symbol.prototype, Symbol.toPrimitive, d('',
+	function (hint) {
+		throw new TypeError("Conversion of symbol objects is not allowed");
+	}));
+Object.defineProperty(Symbol.prototype, Symbol.toStringTag, d('c', 'Symbol'));
+
+},{"d":9}],23:[function(_dereq_,module,exports){
+module.exports={
+  "types": {
+    "root": {
+      "category": "actor",
+      "typeName": "root",
+      "methods": [
+        {
+          "name": "echo",
+          "request": {
+            "string": { "_arg": 0, "type": "string" }
+          },
+          "response": {
+            "string": { "_retval": "string" }
+          }
+        },
+        {
+          "name": "listTabs",
+          "request": {},
+          "response": { "_retval": "tablist" }
+        },
+        {
+          "name": "protocolDescription",
+          "request": {},
+          "response": { "_retval": "json" }
+        }
+      ],
+      "events": {
+        "tabListChanged": {}
+      }
+    },
+    "tablist": {
+      "category": "dict",
+      "typeName": "tablist",
+      "specializations": {
+        "selected": "number",
+        "tabs": "array:tab",
+        "url": "string",
+        "consoleActor": "console",
+        "inspectorActor": "inspector",
+        "styleSheetsActor": "stylesheets",
+        "styleEditorActor": "styleeditor",
+        "memoryActor": "memory",
+        "eventLoopLagActor": "eventLoopLag",
+        "preferenceActor": "preference",
+        "deviceActor": "device",
+
+        "profilerActor": "profiler",
+        "chromeDebugger": "chromeDebugger",
+        "webappsActor": "webapps"
+      }
+    },
+    "tab": {
+      "category": "actor",
+      "typeName": "tab",
+      "fields": {
+        "title": "string",
+        "url": "string",
+        "outerWindowID": "number",
+        "inspectorActor": "inspector",
+        "callWatcherActor": "call-watcher",
+        "canvasActor": "canvas",
+        "webglActor": "webgl",
+        "webaudioActor": "webaudio",
+        "storageActor": "storage",
+        "gcliActor": "gcli",
+        "memoryActor": "memory",
+        "eventLoopLag": "eventLoopLag",
+        "styleSheetsActor": "stylesheets",
+        "styleEditorActor": "styleeditor",
+
+        "consoleActor": "console",
+        "traceActor": "trace"
+      },
+      "methods": [
+         {
+          "name": "attach",
+          "request": {},
+          "response": { "_retval": "json" }
+         }
+      ],
+      "events": {
+        "tabNavigated": {
+           "typeName": "tabNavigated"
+        }
+      }
+    },
+    "console": {
+      "category": "actor",
+      "typeName": "console",
+      "methods": [
+        {
+          "name": "evaluateJS",
+          "request": {
+            "text": {
+              "_option": 0,
+              "type": "string"
+            },
+            "url": {
+              "_option": 1,
+              "type": "string"
+            },
+            "bindObjectActor": {
+              "_option": 2,
+              "type": "nullable:string"
+            },
+            "frameActor": {
+              "_option": 2,
+              "type": "nullable:string"
+            },
+            "selectedNodeActor": {
+              "_option": 2,
+              "type": "nullable:string"
+            }
+          },
+          "response": {
+            "_retval": "evaluatejsresponse"
+          }
+        }
+      ],
+      "events": {}
+    },
+    "evaluatejsresponse": {
+      "category": "dict",
+      "typeName": "evaluatejsresponse",
+      "specializations": {
+        "result": "object",
+        "exception": "object",
+        "exceptionMessage": "string",
+        "input": "string"
+      }
+    },
+    "object": {
+      "category": "actor",
+      "typeName": "object",
+      "methods": [
+         {
+           "name": "property",
+           "request": {
+              "name": {
+                "_arg": 0,
+                "type": "string"
+              }
+           },
+           "response": {
+              "descriptor": {
+                "_retval": "json"
+              }
+           }
+         }
+      ]
+    }
+  }
+}
+
+},{}],24:[function(_dereq_,module,exports){
+module.exports={
+  "types": {
+    "longstractor": {
+      "category": "actor",
+      "typeName": "longstractor",
+      "methods": [
+        {
+          "name": "substring",
+          "request": {
+            "type": "substring",
+            "start": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "end": {
+              "_arg": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "substring": {
+              "_retval": "primitive"
+            }
+          }
+        },
+        {
+          "name": "release",
+          "release": true,
+          "request": {
+            "type": "release"
+          },
+          "response": {}
+        }
+      ],
+      "events": {}
+    },
+    "stylesheet": {
+      "category": "actor",
+      "typeName": "stylesheet",
+      "methods": [
+        {
+          "name": "toggleDisabled",
+          "request": {
+            "type": "toggleDisabled"
+          },
+          "response": {
+            "disabled": {
+              "_retval": "boolean"
+            }
+          }
+        },
+        {
+          "name": "getText",
+          "request": {
+            "type": "getText"
+          },
+          "response": {
+            "text": {
+              "_retval": "longstring"
+            }
+          }
+        },
+        {
+          "name": "getOriginalSources",
+          "request": {
+            "type": "getOriginalSources"
+          },
+          "response": {
+            "originalSources": {
+              "_retval": "nullable:array:originalsource"
+            }
+          }
+        },
+        {
+          "name": "getOriginalLocation",
+          "request": {
+            "type": "getOriginalLocation",
+            "line": {
+              "_arg": 0,
+              "type": "number"
+            },
+            "column": {
+              "_arg": 1,
+              "type": "number"
+            }
+          },
+          "response": {
+            "_retval": "originallocationresponse"
+          }
+        },
+        {
+          "name": "update",
+          "request": {
+            "type": "update",
+            "text": {
+              "_arg": 0,
+              "type": "string"
+            },
+            "transition": {
+              "_arg": 1,
+              "type": "boolean"
+            }
+          },
+          "response": {}
+        }
+      ],
+      "events": {
+        "property-change": {
+          "type": "propertyChange",
+          "property": {
+            "_arg": 0,
+            "type": "string"
+          },
+          "value": {
+            "_arg": 1,
+            "type": "json"
+          }
+        },
+        "style-applied": {
+          "type": "styleApplied"
+        }
+      }
+    },
+    "originalsource": {
+      "category": "actor",
+      "typeName": "originalsource",
+      "methods": [
+        {
+          "name": "getText",
+          "request": {
+            "type": "getText"
+          },
+          "response": {
+            "text": {
+              "_retval": "longstring"
+            }
+          }
+        }
+      ],
+      "events": {}
+    },
+    "stylesheets": {
+      "category": "actor",
+      "typeName": "stylesheets",
+      "methods": [
+        {
+          "name": "getStyleSheets",
+          "request": {
+            "type": "getStyleSheets"
+          },
+          "response": {
+            "styleSheets": {
+              "_retval": "array:stylesheet"
+            }
+          }
+        },
+        {
+          "name": "addStyleSheet",
+          "request": {
+            "type": "addStyleSheet",
+            "text": {
+              "_arg": 0,
+              "type": "string"
+            }
+          },
+          "response": {
+            "styleSheet": {
+              "_retval": "stylesheet"
+            }
+          }
+        }
+      ],
+      "events": {}
+    },
+    "originallocationresponse": {
+      "category": "dict",
+      "typeName": "originallocationresponse",
+      "specializations": {
+        "source": "string",
+        "line": "number",
+        "column": "number"
+      }
+    },
+    "domnode": {
+      "category": "actor",
+      "typeName": "domnode",
+      "methods": [
+        {
+          "name": "getNodeValue",
+          "request": {
+            "type": "getNodeValue"
+          },
+          "response": {
+            "value": {
+              "_retval": "longstring"
+            }
+          }
+        },
+        {
+          "name": "setNodeValue",
+          "request": {
+            "type": "setNodeValue",
+            "value": {
+              "_arg": 0,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "getImageData",
+          "request": {
+            "type": "getImageData",
+            "maxDim": {
+              "_arg": 0,
+              "type": "nullable:number"
+            }
+          },
+          "response": {
+            "_retval": "imageData"
+          }
+        },
+        {
+          "name": "modifyAttributes",
+          "request": {
+            "type": "modifyAttributes",
+            "modifications": {
+              "_arg": 0,
+              "type": "array:json"
+            }
+          },
+          "response": {}
+        }
+      ],
+      "events": {}
+    },
+    "appliedstyle": {
+      "category": "dict",
+      "typeName": "appliedstyle",
+      "specializations": {
+        "rule": "domstylerule#actorid",
+        "inherited": "nullable:domnode#actorid"
+      }
+    },
+    "matchedselector": {
+      "category": "dict",
+      "typeName": "matchedselector",
+      "specializations": {
+        "rule": "domstylerule#actorid",
+        "selector": "string",
+        "value": "string",
+        "status": "number"
+      }
+    },
+    "matchedselectorresponse": {
+      "category": "dict",
+      "typeName": "matchedselectorresponse",
+      "specializations": {
+        "rules": "array:domstylerule",
+        "sheets": "array:stylesheet",
+        "matched": "array:matchedselector"
+      }
+    },
+    "appliedStylesReturn": {
+      "category": "dict",
+      "typeName": "appliedStylesReturn",
+      "specializations": {
+        "entries": "array:appliedstyle",
+        "rules": "array:domstylerule",
+        "sheets": "array:stylesheet"
+      }
+    },
+    "pagestyle": {
+      "category": "actor",
+      "typeName": "pagestyle",
+      "methods": [
+        {
+          "name": "getComputed",
+          "request": {
+            "type": "getComputed",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "markMatched": {
+              "_option": 1,
+              "type": "boolean"
+            },
+            "onlyMatched": {
+              "_option": 1,
+              "type": "boolean"
+            },
+            "filter": {
+              "_option": 1,
+              "type": "string"
+            }
+          },
+          "response": {
+            "computed": {
+              "_retval": "json"
+            }
+          }
+        },
+        {
+          "name": "getMatchedSelectors",
+          "request": {
+            "type": "getMatchedSelectors",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "property": {
+              "_arg": 1,
+              "type": "string"
+            },
+            "filter": {
+              "_option": 2,
+              "type": "string"
+            }
+          },
+          "response": {
+            "_retval": "matchedselectorresponse"
+          }
+        },
+        {
+          "name": "getApplied",
+          "request": {
+            "type": "getApplied",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "inherited": {
+              "_option": 1,
+              "type": "boolean"
+            },
+            "matchedSelectors": {
+              "_option": 1,
+              "type": "boolean"
+            },
+            "filter": {
+              "_option": 1,
+              "type": "string"
+            }
+          },
+          "response": {
+            "_retval": "appliedStylesReturn"
+          }
+        },
+        {
+          "name": "getLayout",
+          "request": {
+            "type": "getLayout",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "autoMargins": {
+              "_option": 1,
+              "type": "boolean"
+            }
+          },
+          "response": {
+            "_retval": "json"
+          }
+        }
+      ],
+      "events": {}
+    },
+    "domstylerule": {
+      "category": "actor",
+      "typeName": "domstylerule",
+      "methods": [
+        {
+          "name": "modifyProperties",
+          "request": {
+            "type": "modifyProperties",
+            "modifications": {
+              "_arg": 0,
+              "type": "array:json"
+            }
+          },
+          "response": {
+            "rule": {
+              "_retval": "domstylerule"
+            }
+          }
+        }
+      ],
+      "events": {}
+    },
+    "highlighter": {
+      "category": "actor",
+      "typeName": "highlighter",
+      "methods": [
+        {
+          "name": "showBoxModel",
+          "request": {
+            "type": "showBoxModel",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "region": {
+              "_option": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "hideBoxModel",
+          "request": {
+            "type": "hideBoxModel"
+          },
+          "response": {}
+        },
+        {
+          "name": "pick",
+          "request": {
+            "type": "pick"
+          },
+          "response": {}
+        },
+        {
+          "name": "cancelPick",
+          "request": {
+            "type": "cancelPick"
+          },
+          "response": {}
+        }
+      ],
+      "events": {}
+    },
+    "imageData": {
+      "category": "dict",
+      "typeName": "imageData",
+      "specializations": {
+        "data": "nullable:longstring",
+        "size": "json"
+      }
+    },
+    "disconnectedNode": {
+      "category": "dict",
+      "typeName": "disconnectedNode",
+      "specializations": {
+        "node": "domnode",
+        "newParents": "array:domnode"
+      }
+    },
+    "disconnectedNodeArray": {
+      "category": "dict",
+      "typeName": "disconnectedNodeArray",
+      "specializations": {
+        "nodes": "array:domnode",
+        "newParents": "array:domnode"
+      }
+    },
+    "dommutation": {
+      "category": "dict",
+      "typeName": "dommutation",
+      "specializations": {}
+    },
+    "domnodelist": {
+      "category": "actor",
+      "typeName": "domnodelist",
+      "methods": [
+        {
+          "name": "item",
+          "request": {
+            "type": "item",
+            "item": {
+              "_arg": 0,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "_retval": "disconnectedNode"
+          }
+        },
+        {
+          "name": "items",
+          "request": {
+            "type": "items",
+            "start": {
+              "_arg": 0,
+              "type": "nullable:number"
+            },
+            "end": {
+              "_arg": 1,
+              "type": "nullable:number"
+            }
+          },
+          "response": {
+            "_retval": "disconnectedNodeArray"
+          }
+        },
+        {
+          "name": "release",
+          "release": true,
+          "request": {
+            "type": "release"
+          },
+          "response": {}
+        }
+      ],
+      "events": {}
+    },
+    "domtraversalarray": {
+      "category": "dict",
+      "typeName": "domtraversalarray",
+      "specializations": {
+        "nodes": "array:domnode"
+      }
+    },
+    "domwalker": {
+      "category": "actor",
+      "typeName": "domwalker",
+      "methods": [
+        {
+          "name": "release",
+          "release": true,
+          "request": {
+            "type": "release"
+          },
+          "response": {}
+        },
+        {
+          "name": "pick",
+          "request": {
+            "type": "pick"
+          },
+          "response": {
+            "_retval": "disconnectedNode"
+          }
+        },
+        {
+          "name": "cancelPick",
+          "request": {
+            "type": "cancelPick"
+          },
+          "response": {}
+        },
+        {
+          "name": "highlight",
+          "request": {
+            "type": "highlight",
+            "node": {
+              "_arg": 0,
+              "type": "nullable:domnode"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "document",
+          "request": {
+            "type": "document",
+            "node": {
+              "_arg": 0,
+              "type": "nullable:domnode"
+            }
+          },
+          "response": {
+            "node": {
+              "_retval": "domnode"
+            }
+          }
+        },
+        {
+          "name": "documentElement",
+          "request": {
+            "type": "documentElement",
+            "node": {
+              "_arg": 0,
+              "type": "nullable:domnode"
+            }
+          },
+          "response": {
+            "node": {
+              "_retval": "domnode"
+            }
+          }
+        },
+        {
+          "name": "parents",
+          "request": {
+            "type": "parents",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "sameDocument": {
+              "_option": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "nodes": {
+              "_retval": "array:domnode"
+            }
+          }
+        },
+        {
+          "name": "retainNode",
+          "request": {
+            "type": "retainNode",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "unretainNode",
+          "request": {
+            "type": "unretainNode",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "releaseNode",
+          "request": {
+            "type": "releaseNode",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "force": {
+              "_option": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "children",
+          "request": {
+            "type": "children",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "maxNodes": {
+              "_option": 1,
+              "type": "primitive"
+            },
+            "center": {
+              "_option": 1,
+              "type": "domnode"
+            },
+            "start": {
+              "_option": 1,
+              "type": "domnode"
+            },
+            "whatToShow": {
+              "_option": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "_retval": "domtraversalarray"
+          }
+        },
+        {
+          "name": "siblings",
+          "request": {
+            "type": "siblings",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "maxNodes": {
+              "_option": 1,
+              "type": "primitive"
+            },
+            "center": {
+              "_option": 1,
+              "type": "domnode"
+            },
+            "start": {
+              "_option": 1,
+              "type": "domnode"
+            },
+            "whatToShow": {
+              "_option": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "_retval": "domtraversalarray"
+          }
+        },
+        {
+          "name": "nextSibling",
+          "request": {
+            "type": "nextSibling",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "whatToShow": {
+              "_option": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "node": {
+              "_retval": "nullable:domnode"
+            }
+          }
+        },
+        {
+          "name": "previousSibling",
+          "request": {
+            "type": "previousSibling",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "whatToShow": {
+              "_option": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "node": {
+              "_retval": "nullable:domnode"
+            }
+          }
+        },
+        {
+          "name": "querySelector",
+          "request": {
+            "type": "querySelector",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "selector": {
+              "_arg": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "_retval": "disconnectedNode"
+          }
+        },
+        {
+          "name": "querySelectorAll",
+          "request": {
+            "type": "querySelectorAll",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "selector": {
+              "_arg": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "list": {
+              "_retval": "domnodelist"
+            }
+          }
+        },
+        {
+          "name": "getSuggestionsForQuery",
+          "request": {
+            "type": "getSuggestionsForQuery",
+            "query": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "completing": {
+              "_arg": 1,
+              "type": "primitive"
+            },
+            "selectorState": {
+              "_arg": 2,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "list": {
+              "_retval": "array:array:string"
+            }
+          }
+        },
+        {
+          "name": "addPseudoClassLock",
+          "request": {
+            "type": "addPseudoClassLock",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "pseudoClass": {
+              "_arg": 1,
+              "type": "primitive"
+            },
+            "parents": {
+              "_option": 2,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "hideNode",
+          "request": {
+            "type": "hideNode",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "unhideNode",
+          "request": {
+            "type": "unhideNode",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "removePseudoClassLock",
+          "request": {
+            "type": "removePseudoClassLock",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "pseudoClass": {
+              "_arg": 1,
+              "type": "primitive"
+            },
+            "parents": {
+              "_option": 2,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "clearPseudoClassLocks",
+          "request": {
+            "type": "clearPseudoClassLocks",
+            "node": {
+              "_arg": 0,
+              "type": "nullable:domnode"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "innerHTML",
+          "request": {
+            "type": "innerHTML",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            }
+          },
+          "response": {
+            "value": {
+              "_retval": "longstring"
+            }
+          }
+        },
+        {
+          "name": "outerHTML",
+          "request": {
+            "type": "outerHTML",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            }
+          },
+          "response": {
+            "value": {
+              "_retval": "longstring"
+            }
+          }
+        },
+        {
+          "name": "setOuterHTML",
+          "request": {
+            "type": "setOuterHTML",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "value": {
+              "_arg": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "removeNode",
+          "request": {
+            "type": "removeNode",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            }
+          },
+          "response": {
+            "nextSibling": {
+              "_retval": "nullable:domnode"
+            }
+          }
+        },
+        {
+          "name": "insertBefore",
+          "request": {
+            "type": "insertBefore",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            },
+            "parent": {
+              "_arg": 1,
+              "type": "domnode"
+            },
+            "sibling": {
+              "_arg": 2,
+              "type": "nullable:domnode"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "getMutations",
+          "request": {
+            "type": "getMutations",
+            "cleanup": {
+              "_option": 0,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "mutations": {
+              "_retval": "array:dommutation"
+            }
+          }
+        },
+        {
+          "name": "isInDOMTree",
+          "request": {
+            "type": "isInDOMTree",
+            "node": {
+              "_arg": 0,
+              "type": "domnode"
+            }
+          },
+          "response": {
+            "attached": {
+              "_retval": "boolean"
+            }
+          }
+        },
+        {
+          "name": "getNodeActorFromObjectActor",
+          "request": {
+            "type": "getNodeActorFromObjectActor",
+            "objectActorID": {
+              "_arg": 0,
+              "type": "string"
+            }
+          },
+          "response": {
+            "nodeFront": {
+              "_retval": "nullable:disconnectedNode"
+            }
+          }
+        }
+      ],
+      "events": {
+        "new-mutations": {
+          "type": "newMutations"
+        },
+        "picker-node-picked": {
+          "type": "pickerNodePicked",
+          "node": {
+            "_arg": 0,
+            "type": "disconnectedNode"
+          }
+        },
+        "picker-node-hovered": {
+          "type": "pickerNodeHovered",
+          "node": {
+            "_arg": 0,
+            "type": "disconnectedNode"
+          }
+        },
+        "highlighter-ready": {
+          "type": "highlighter-ready"
+        },
+        "highlighter-hide": {
+          "type": "highlighter-hide"
+        }
+      }
+    },
+    "inspector": {
+      "category": "actor",
+      "typeName": "inspector",
+      "methods": [
+        {
+          "name": "getWalker",
+          "request": {
+            "type": "getWalker"
+          },
+          "response": {
+            "walker": {
+              "_retval": "domwalker"
+            }
+          }
+        },
+        {
+          "name": "getPageStyle",
+          "request": {
+            "type": "getPageStyle"
+          },
+          "response": {
+            "pageStyle": {
+              "_retval": "pagestyle"
+            }
+          }
+        },
+        {
+          "name": "getHighlighter",
+          "request": {
+            "type": "getHighlighter",
+            "autohide": {
+              "_arg": 0,
+              "type": "boolean"
+            }
+          },
+          "response": {
+            "highligter": {
+              "_retval": "highlighter"
+            }
+          }
+        },
+        {
+          "name": "getImageDataFromURL",
+          "request": {
+            "type": "getImageDataFromURL",
+            "url": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "maxDim": {
+              "_arg": 1,
+              "type": "nullable:number"
+            }
+          },
+          "response": {
+            "_retval": "imageData"
+          }
+        }
+      ],
+      "events": {}
+    },
+    "call-stack-item": {
+      "category": "dict",
+      "typeName": "call-stack-item",
+      "specializations": {
+        "name": "string",
+        "file": "string",
+        "line": "number"
+      }
+    },
+    "call-details": {
+      "category": "dict",
+      "typeName": "call-details",
+      "specializations": {
+        "type": "number",
+        "name": "string",
+        "stack": "array:call-stack-item"
+      }
+    },
+    "function-call": {
+      "category": "actor",
+      "typeName": "function-call",
+      "methods": [
+        {
+          "name": "getDetails",
+          "request": {
+            "type": "getDetails"
+          },
+          "response": {
+            "info": {
+              "_retval": "call-details"
+            }
+          }
+        }
+      ],
+      "events": {}
+    },
+    "call-watcher": {
+      "category": "actor",
+      "typeName": "call-watcher",
+      "methods": [
+        {
+          "name": "setup",
+          "oneway": true,
+          "request": {
+            "type": "setup",
+            "tracedGlobals": {
+              "_option": 0,
+              "type": "nullable:array:string"
+            },
+            "tracedFunctions": {
+              "_option": 0,
+              "type": "nullable:array:string"
+            },
+            "startRecording": {
+              "_option": 0,
+              "type": "boolean"
+            },
+            "performReload": {
+              "_option": 0,
+              "type": "boolean"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "finalize",
+          "oneway": true,
+          "request": {
+            "type": "finalize"
+          },
+          "response": {}
+        },
+        {
+          "name": "isRecording",
+          "request": {
+            "type": "isRecording"
+          },
+          "response": {
+            "_retval": "boolean"
+          }
+        },
+        {
+          "name": "resumeRecording",
+          "request": {
+            "type": "resumeRecording"
+          },
+          "response": {}
+        },
+        {
+          "name": "pauseRecording",
+          "request": {
+            "type": "pauseRecording"
+          },
+          "response": {
+            "calls": {
+              "_retval": "array:function-call"
+            }
+          }
+        },
+        {
+          "name": "eraseRecording",
+          "request": {
+            "type": "eraseRecording"
+          },
+          "response": {}
+        }
+      ],
+      "events": {}
+    },
+    "snapshot-image": {
+      "category": "dict",
+      "typeName": "snapshot-image",
+      "specializations": {
+        "index": "number",
+        "width": "number",
+        "height": "number",
+        "flipped": "boolean",
+        "pixels": "uint32-array"
+      }
+    },
+    "snapshot-overview": {
+      "category": "dict",
+      "typeName": "snapshot-overview",
+      "specializations": {
+        "calls": "array:function-call",
+        "thumbnails": "array:snapshot-image",
+        "screenshot": "snapshot-image"
+      }
+    },
+    "frame-snapshot": {
+      "category": "actor",
+      "typeName": "frame-snapshot",
+      "methods": [
+        {
+          "name": "getOverview",
+          "request": {
+            "type": "getOverview"
+          },
+          "response": {
+            "overview": {
+              "_retval": "snapshot-overview"
+            }
+          }
+        },
+        {
+          "name": "generateScreenshotFor",
+          "request": {
+            "type": "generateScreenshotFor",
+            "call": {
+              "_arg": 0,
+              "type": "function-call"
+            }
+          },
+          "response": {
+            "screenshot": {
+              "_retval": "snapshot-image"
+            }
+          }
+        }
+      ],
+      "events": {}
+    },
+    "canvas": {
+      "category": "actor",
+      "typeName": "canvas",
+      "methods": [
+        {
+          "name": "setup",
+          "oneway": true,
+          "request": {
+            "type": "setup",
+            "reload": {
+              "_option": 0,
+              "type": "boolean"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "finalize",
+          "oneway": true,
+          "request": {
+            "type": "finalize"
+          },
+          "response": {}
+        },
+        {
+          "name": "isInitialized",
+          "request": {
+            "type": "isInitialized"
+          },
+          "response": {
+            "initialized": {
+              "_retval": "boolean"
+            }
+          }
+        },
+        {
+          "name": "recordAnimationFrame",
+          "request": {
+            "type": "recordAnimationFrame"
+          },
+          "response": {
+            "snapshot": {
+              "_retval": "frame-snapshot"
+            }
+          }
+        }
+      ],
+      "events": {}
+    },
+    "gl-shader": {
+      "category": "actor",
+      "typeName": "gl-shader",
+      "methods": [
+        {
+          "name": "getText",
+          "request": {
+            "type": "getText"
+          },
+          "response": {
+            "text": {
+              "_retval": "string"
+            }
+          }
+        },
+        {
+          "name": "compile",
+          "request": {
+            "type": "compile",
+            "text": {
+              "_arg": 0,
+              "type": "string"
+            }
+          },
+          "response": {
+            "error": {
+              "_retval": "nullable:json"
+            }
+          }
+        }
+      ],
+      "events": {}
+    },
+    "gl-program": {
+      "category": "actor",
+      "typeName": "gl-program",
+      "methods": [
+        {
+          "name": "getVertexShader",
+          "request": {
+            "type": "getVertexShader"
+          },
+          "response": {
+            "shader": {
+              "_retval": "gl-shader"
+            }
+          }
+        },
+        {
+          "name": "getFragmentShader",
+          "request": {
+            "type": "getFragmentShader"
+          },
+          "response": {
+            "shader": {
+              "_retval": "gl-shader"
+            }
+          }
+        },
+        {
+          "name": "highlight",
+          "oneway": true,
+          "request": {
+            "type": "highlight",
+            "tint": {
+              "_arg": 0,
+              "type": "array:number"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "unhighlight",
+          "oneway": true,
+          "request": {
+            "type": "unhighlight"
+          },
+          "response": {}
+        },
+        {
+          "name": "blackbox",
+          "oneway": true,
+          "request": {
+            "type": "blackbox"
+          },
+          "response": {}
+        },
+        {
+          "name": "unblackbox",
+          "oneway": true,
+          "request": {
+            "type": "unblackbox"
+          },
+          "response": {}
+        }
+      ],
+      "events": {}
+    },
+    "webgl": {
+      "category": "actor",
+      "typeName": "webgl",
+      "methods": [
+        {
+          "name": "setup",
+          "oneway": true,
+          "request": {
+            "type": "setup",
+            "reload": {
+              "_option": 0,
+              "type": "boolean"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "finalize",
+          "oneway": true,
+          "request": {
+            "type": "finalize"
+          },
+          "response": {}
+        },
+        {
+          "name": "getPrograms",
+          "request": {
+            "type": "getPrograms"
+          },
+          "response": {
+            "programs": {
+              "_retval": "array:gl-program"
+            }
+          }
+        }
+      ],
+      "events": {
+        "program-linked": {
+          "type": "programLinked",
+          "program": {
+            "_arg": 0,
+            "type": "gl-program"
+          }
+        }
+      }
+    },
+    "audionode": {
+      "category": "actor",
+      "typeName": "audionode",
+      "methods": [
+        {
+          "name": "getType",
+          "request": {
+            "type": "getType"
+          },
+          "response": {
+            "type": {
+              "_retval": "string"
+            }
+          }
+        },
+        {
+          "name": "isSource",
+          "request": {
+            "type": "isSource"
+          },
+          "response": {
+            "source": {
+              "_retval": "boolean"
+            }
+          }
+        },
+        {
+          "name": "setParam",
+          "request": {
+            "type": "setParam",
+            "param": {
+              "_arg": 0,
+              "type": "string"
+            },
+            "value": {
+              "_arg": 1,
+              "type": "nullable:primitive"
+            }
+          },
+          "response": {
+            "error": {
+              "_retval": "nullable:json"
+            }
+          }
+        },
+        {
+          "name": "getParam",
+          "request": {
+            "type": "getParam",
+            "param": {
+              "_arg": 0,
+              "type": "string"
+            }
+          },
+          "response": {
+            "text": {
+              "_retval": "nullable:primitive"
+            }
+          }
+        },
+        {
+          "name": "getParamFlags",
+          "request": {
+            "type": "getParamFlags",
+            "param": {
+              "_arg": 0,
+              "type": "string"
+            }
+          },
+          "response": {
+            "flags": {
+              "_retval": "nullable:primitive"
+            }
+          }
+        },
+        {
+          "name": "getParams",
+          "request": {
+            "type": "getParams"
+          },
+          "response": {
+            "params": {
+              "_retval": "json"
+            }
+          }
+        }
+      ],
+      "events": {}
+    },
+    "webaudio": {
+      "category": "actor",
+      "typeName": "webaudio",
+      "methods": [
+        {
+          "name": "setup",
+          "oneway": true,
+          "request": {
+            "type": "setup",
+            "reload": {
+              "_option": 0,
+              "type": "boolean"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "finalize",
+          "oneway": true,
+          "request": {
+            "type": "finalize"
+          },
+          "response": {}
+        }
+      ],
+      "events": {
+        "start-context": {
+          "type": "startContext"
+        },
+        "connect-node": {
+          "type": "connectNode",
+          "source": {
+            "_option": 0,
+            "type": "audionode"
+          },
+          "dest": {
+            "_option": 0,
+            "type": "audionode"
+          }
+        },
+        "disconnect-node": {
+          "type": "disconnectNode",
+          "source": {
+            "_arg": 0,
+            "type": "audionode"
+          }
+        },
+        "connect-param": {
+          "type": "connectParam",
+          "source": {
+            "_arg": 0,
+            "type": "audionode"
+          },
+          "param": {
+            "_arg": 1,
+            "type": "string"
+          }
+        },
+        "change-param": {
+          "type": "changeParam",
+          "source": {
+            "_option": 0,
+            "type": "audionode"
+          },
+          "param": {
+            "_option": 0,
+            "type": "string"
+          },
+          "value": {
+            "_option": 0,
+            "type": "string"
+          }
+        },
+        "create-node": {
+          "type": "createNode",
+          "source": {
+            "_arg": 0,
+            "type": "audionode"
+          }
+        }
+      }
+    },
+    "old-stylesheet": {
+      "category": "actor",
+      "typeName": "old-stylesheet",
+      "methods": [
+        {
+          "name": "toggleDisabled",
+          "request": {
+            "type": "toggleDisabled"
+          },
+          "response": {
+            "disabled": {
+              "_retval": "boolean"
+            }
+          }
+        },
+        {
+          "name": "fetchSource",
+          "request": {
+            "type": "fetchSource"
+          },
+          "response": {}
+        },
+        {
+          "name": "update",
+          "request": {
+            "type": "update",
+            "text": {
+              "_arg": 0,
+              "type": "string"
+            },
+            "transition": {
+              "_arg": 1,
+              "type": "boolean"
+            }
+          },
+          "response": {}
+        }
+      ],
+      "events": {
+        "property-change": {
+          "type": "propertyChange",
+          "property": {
+            "_arg": 0,
+            "type": "string"
+          },
+          "value": {
+            "_arg": 1,
+            "type": "json"
+          }
+        },
+        "source-load": {
+          "type": "sourceLoad",
+          "source": {
+            "_arg": 0,
+            "type": "string"
+          }
+        },
+        "style-applied": {
+          "type": "styleApplied"
+        }
+      }
+    },
+    "styleeditor": {
+      "category": "actor",
+      "typeName": "styleeditor",
+      "methods": [
+        {
+          "name": "newDocument",
+          "request": {
+            "type": "newDocument"
+          },
+          "response": {}
+        },
+        {
+          "name": "newStyleSheet",
+          "request": {
+            "type": "newStyleSheet",
+            "text": {
+              "_arg": 0,
+              "type": "string"
+            }
+          },
+          "response": {
+            "styleSheet": {
+              "_retval": "old-stylesheet"
+            }
+          }
+        }
+      ],
+      "events": {
+        "document-load": {
+          "type": "documentLoad",
+          "styleSheets": {
+            "_arg": 0,
+            "type": "array:old-stylesheet"
+          }
+        }
+      }
+    },
+    "cookieobject": {
+      "category": "dict",
+      "typeName": "cookieobject",
+      "specializations": {
+        "name": "string",
+        "value": "longstring",
+        "path": "nullable:string",
+        "host": "string",
+        "isDomain": "boolean",
+        "isSecure": "boolean",
+        "isHttpOnly": "boolean",
+        "creationTime": "number",
+        "lastAccessed": "number",
+        "expires": "number"
+      }
+    },
+    "cookiestoreobject": {
+      "category": "dict",
+      "typeName": "cookiestoreobject",
+      "specializations": {
+        "total": "number",
+        "offset": "number",
+        "data": "array:nullable:cookieobject"
+      }
+    },
+    "storageobject": {
+      "category": "dict",
+      "typeName": "storageobject",
+      "specializations": {
+        "name": "string",
+        "value": "longstring"
+      }
+    },
+    "storagestoreobject": {
+      "category": "dict",
+      "typeName": "storagestoreobject",
+      "specializations": {
+        "total": "number",
+        "offset": "number",
+        "data": "array:nullable:storageobject"
+      }
+    },
+    "idbobject": {
+      "category": "dict",
+      "typeName": "idbobject",
+      "specializations": {
+        "name": "nullable:string",
+        "db": "nullable:string",
+        "objectStore": "nullable:string",
+        "origin": "nullable:string",
+        "version": "nullable:number",
+        "objectStores": "nullable:number",
+        "keyPath": "nullable:string",
+        "autoIncrement": "nullable:boolean",
+        "indexes": "nullable:string",
+        "value": "nullable:longstring"
+      }
+    },
+    "idbstoreobject": {
+      "category": "dict",
+      "typeName": "idbstoreobject",
+      "specializations": {
+        "total": "number",
+        "offset": "number",
+        "data": "array:nullable:idbobject"
+      }
+    },
+    "storeUpdateObject": {
+      "category": "dict",
+      "typeName": "storeUpdateObject",
+      "specializations": {
+        "changed": "nullable:json",
+        "deleted": "nullable:json",
+        "added": "nullable:json"
+      }
+    },
+    "cookies": {
+      "category": "actor",
+      "typeName": "cookies",
+      "methods": [
+        {
+          "name": "getStoreObjects",
+          "request": {
+            "type": "getStoreObjects",
+            "host": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "names": {
+              "_arg": 1,
+              "type": "nullable:array:string"
+            },
+            "options": {
+              "_arg": 2,
+              "type": "nullable:json"
+            }
+          },
+          "response": {
+            "_retval": "cookiestoreobject"
+          }
+        }
+      ],
+      "events": {}
+    },
+    "localStorage": {
+      "category": "actor",
+      "typeName": "localStorage",
+      "methods": [
+        {
+          "name": "getStoreObjects",
+          "request": {
+            "type": "getStoreObjects",
+            "host": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "names": {
+              "_arg": 1,
+              "type": "nullable:array:string"
+            },
+            "options": {
+              "_arg": 2,
+              "type": "nullable:json"
+            }
+          },
+          "response": {
+            "_retval": "storagestoreobject"
+          }
+        }
+      ],
+      "events": {}
+    },
+    "sessionStorage": {
+      "category": "actor",
+      "typeName": "sessionStorage",
+      "methods": [
+        {
+          "name": "getStoreObjects",
+          "request": {
+            "type": "getStoreObjects",
+            "host": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "names": {
+              "_arg": 1,
+              "type": "nullable:array:string"
+            },
+            "options": {
+              "_arg": 2,
+              "type": "nullable:json"
+            }
+          },
+          "response": {
+            "_retval": "storagestoreobject"
+          }
+        }
+      ],
+      "events": {}
+    },
+    "indexedDB": {
+      "category": "actor",
+      "typeName": "indexedDB",
+      "methods": [
+        {
+          "name": "getStoreObjects",
+          "request": {
+            "type": "getStoreObjects",
+            "host": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "names": {
+              "_arg": 1,
+              "type": "nullable:array:string"
+            },
+            "options": {
+              "_arg": 2,
+              "type": "nullable:json"
+            }
+          },
+          "response": {
+            "_retval": "idbstoreobject"
+          }
+        }
+      ],
+      "events": {}
+    },
+    "storelist": {
+      "category": "dict",
+      "typeName": "storelist",
+      "specializations": {
+        "cookies": "cookies",
+        "localStorage": "localStorage",
+        "sessionStorage": "sessionStorage",
+        "indexedDB": "indexedDB"
+      }
+    },
+    "storage": {
+      "category": "actor",
+      "typeName": "storage",
+      "methods": [
+        {
+          "name": "listStores",
+          "request": {
+            "type": "listStores"
+          },
+          "response": {
+            "_retval": "storelist"
+          }
+        }
+      ],
+      "events": {
+        "stores-update": {
+          "type": "storesUpdate",
+          "data": {
+            "_arg": 0,
+            "type": "storeUpdateObject"
+          }
+        },
+        "stores-cleared": {
+          "type": "storesCleared",
+          "data": {
+            "_arg": 0,
+            "type": "json"
+          }
+        },
+        "stores-reloaded": {
+          "type": "storesRelaoded",
+          "data": {
+            "_arg": 0,
+            "type": "json"
+          }
+        }
+      }
+    },
+    "gcli": {
+      "category": "actor",
+      "typeName": "gcli",
+      "methods": [
+        {
+          "name": "specs",
+          "request": {
+            "type": "specs"
+          },
+          "response": {
+            "_retval": "json"
+          }
+        },
+        {
+          "name": "execute",
+          "request": {
+            "type": "execute",
+            "typed": {
+              "_arg": 0,
+              "type": "string"
+            }
+          },
+          "response": {
+            "_retval": "json"
+          }
+        },
+        {
+          "name": "state",
+          "request": {
+            "type": "state",
+            "typed": {
+              "_arg": 0,
+              "type": "string"
+            },
+            "start": {
+              "_arg": 1,
+              "type": "number"
+            },
+            "rank": {
+              "_arg": 2,
+              "type": "number"
+            }
+          },
+          "response": {
+            "_retval": "json"
+          }
+        },
+        {
+          "name": "typeparse",
+          "request": {
+            "type": "typeparse",
+            "typed": {
+              "_arg": 0,
+              "type": "string"
+            },
+            "param": {
+              "_arg": 1,
+              "type": "string"
+            }
+          },
+          "response": {
+            "_retval": "json"
+          }
+        },
+        {
+          "name": "typeincrement",
+          "request": {
+            "type": "typeincrement",
+            "typed": {
+              "_arg": 0,
+              "type": "string"
+            },
+            "param": {
+              "_arg": 1,
+              "type": "string"
+            }
+          },
+          "response": {
+            "_retval": "string"
+          }
+        },
+        {
+          "name": "typedecrement",
+          "request": {
+            "type": "typedecrement",
+            "typed": {
+              "_arg": 0,
+              "type": "string"
+            },
+            "param": {
+              "_arg": 1,
+              "type": "string"
+            }
+          },
+          "response": {
+            "_retval": "string"
+          }
+        },
+        {
+          "name": "selectioninfo",
+          "request": {
+            "type": "selectioninfo",
+            "typed": {
+              "_arg": 0,
+              "type": "string"
+            },
+            "param": {
+              "_arg": 1,
+              "type": "string"
+            },
+            "action": {
+              "_arg": 1,
+              "type": "string"
+            }
+          },
+          "response": {
+            "_retval": "json"
+          }
+        }
+      ],
+      "events": {}
+    },
+    "memory": {
+      "category": "actor",
+      "typeName": "memory",
+      "methods": [
+        {
+          "name": "measure",
+          "request": {
+            "type": "measure"
+          },
+          "response": {
+            "_retval": "json"
+          }
+        }
+      ],
+      "events": {}
+    },
+    "eventLoopLag": {
+      "category": "actor",
+      "typeName": "eventLoopLag",
+      "methods": [
+        {
+          "name": "start",
+          "request": {
+            "type": "start"
+          },
+          "response": {
+            "success": {
+              "_retval": "number"
+            }
+          }
+        },
+        {
+          "name": "stop",
+          "request": {
+            "type": "stop"
+          },
+          "response": {}
+        }
+      ],
+      "events": {
+        "event-loop-lag": {
+          "type": "event-loop-lag",
+          "time": {
+            "_arg": 0,
+            "type": "number"
+          }
+        }
+      }
+    },
+    "preference": {
+      "category": "actor",
+      "typeName": "preference",
+      "methods": [
+        {
+          "name": "getBoolPref",
+          "request": {
+            "type": "getBoolPref",
+            "value": {
+              "_arg": 0,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "value": {
+              "_retval": "boolean"
+            }
+          }
+        },
+        {
+          "name": "getCharPref",
+          "request": {
+            "type": "getCharPref",
+            "value": {
+              "_arg": 0,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "value": {
+              "_retval": "string"
+            }
+          }
+        },
+        {
+          "name": "getIntPref",
+          "request": {
+            "type": "getIntPref",
+            "value": {
+              "_arg": 0,
+              "type": "primitive"
+            }
+          },
+          "response": {
+            "value": {
+              "_retval": "number"
+            }
+          }
+        },
+        {
+          "name": "getAllPrefs",
+          "request": {
+            "type": "getAllPrefs"
+          },
+          "response": {
+            "value": {
+              "_retval": "json"
+            }
+          }
+        },
+        {
+          "name": "setBoolPref",
+          "request": {
+            "type": "setBoolPref",
+            "name": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "value": {
+              "_arg": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "setCharPref",
+          "request": {
+            "type": "setCharPref",
+            "name": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "value": {
+              "_arg": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "setIntPref",
+          "request": {
+            "type": "setIntPref",
+            "name": {
+              "_arg": 0,
+              "type": "primitive"
+            },
+            "value": {
+              "_arg": 1,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        },
+        {
+          "name": "clearUserPref",
+          "request": {
+            "type": "clearUserPref",
+            "name": {
+              "_arg": 0,
+              "type": "primitive"
+            }
+          },
+          "response": {}
+        }
+      ],
+      "events": {}
+    },
+    "device": {
+      "category": "actor",
+      "typeName": "device",
+      "methods": [
+        {
+          "name": "getDescription",
+          "request": {
+            "type": "getDescription"
+          },
+          "response": {
+            "value": {
+              "_retval": "json"
+            }
+          }
+        },
+        {
+          "name": "getWallpaper",
+          "request": {
+            "type": "getWallpaper"
+          },
+          "response": {
+            "value": {
+              "_retval": "longstring"
+            }
+          }
+        },
+        {
+          "name": "screenshotToDataURL",
+          "request": {
+            "type": "screenshotToDataURL"
+          },
+          "response": {
+            "value": {
+              "_retval": "longstring"
+            }
+          }
+        },
+        {
+          "name": "getRawPermissionsTable",
+          "request": {
+            "type": "getRawPermissionsTable"
+          },
+          "response": {
+            "value": {
+              "_retval": "json"
+            }
+          }
+        }
+      ],
+      "events": {}
+    }
+  },
+  "from": "root"
+}
+
+},{}],25:[function(_dereq_,module,exports){
+"use strict";
+
+var Class = _dereq_("./class").Class;
+var util = _dereq_("./util");
+var keys = util.keys;
+var values = util.values;
+var pairs = util.pairs;
+var query = util.query;
+var findPath = util.findPath;
+var EventTarget = _dereq_("./event").EventTarget;
+
+var TypeSystem = Class({
+  constructor: function(client) {
+    var types = Object.create(null);
+    var specification = Object.create(null);
+
+    this.specification = specification;
+    this.types = types;
+
+    var typeFor = function typeFor(typeName) {
+      typeName = typeName || "primitive";
+      if (!types[typeName]) {
+        defineType(typeName);
+      }
+
+      return types[typeName];
+    };
+    this.typeFor = typeFor;
+
+    var defineType = function(descriptor) {
+      var type = void(0);
+      if (typeof(descriptor) === "string") {
+        if (descriptor.indexOf(":") > 0)
+          type = makeCompoundType(descriptor);
+        else if (descriptor.indexOf("#") > 0)
+          type = new ActorDetail(descriptor);
+          else if (specification[descriptor])
+            type = makeCategoryType(specification[descriptor]);
+      } else {
+        type = makeCategoryType(descriptor);
+      }
+
+      if (type)
+        types[type.name] = type;
+      else
+        throw TypeError("Invalid type: " + descriptor);
+    };
+    this.defineType = defineType;
+
+
+    var makeCompoundType = function(name) {
+      var index = name.indexOf(":");
+      var baseType = name.slice(0, index);
+      var subType = name.slice(index + 1);
+
+      return baseType === "array" ? new ArrayOf(subType) :
+      baseType === "nullable" ? new Maybe(subType) :
+      null;
+    };
+
+    var makeCategoryType = function(descriptor) {
+      var category = descriptor.category;
+      return category === "dict" ? new Dictionary(descriptor) :
+      category === "actor" ? new Actor(descriptor) :
+      null;
+    };
+
+    var read = function(input, context, typeName) {
+      return typeFor(typeName).read(input, context);
+    }
+    this.read = read;
+
+    var write = function(input, context, typeName) {
+      return typeFor(typeName).write(input);
+    };
+    this.write = write;
+
+
+    var Type = Class({
+      constructor: function() {
+      },
+      get name() {
+        return this.category ? this.category + ":" + this.type :
+        this.type;
+      },
+      read: function(input, context) {
+        throw new TypeError("`Type` subclass must implement `read`");
+      },
+      write: function(input, context) {
+        throw new TypeError("`Type` subclass must implement `write`");
+      }
+    });
+
+    var Primitve = Class({
+      extends: Type,
+      constuctor: function(type) {
+        this.type = type;
+      },
+      read: function(input, context) {
+        return input;
+      },
+      write: function(input, context) {
+        return input;
+      }
+    });
+
+    var Maybe = Class({
+      extends: Type,
+      category: "nullable",
+      constructor: function(type) {
+        this.type = type;
+      },
+      read: function(input, context) {
+        return input === null ? null :
+        input === void(0) ? void(0) :
+        read(input, context, this.type);
+      },
+      write: function(input, context) {
+        return input === null ? null :
+        input === void(0) ? void(0) :
+        write(input, context, this.type);
+      }
+    });
+
+    var ArrayOf = Class({
+      extends: Type,
+      category: "array",
+      constructor: function(type) {
+        this.type = type;
+      },
+      read: function(input, context) {
+        var type = this.type;
+        return input.map(function($) { return read($, context, type) });
+      },
+      write: function(input, context) {
+        var type = this.type;
+        return input.map(function($) { return write($, context, type) });
+      }
+    });
+
+    var makeField = function makeField(name, type) {
+      return {
+        enumerable: true,
+        configurable: true,
+        get: function() {
+          Object.defineProperty(this, name, {
+            configurable: false,
+            value: read(this.state[name], this.context, type)
+          });
+          return this[name];
+        }
+      }
+    };
+
+    var makeFields = function(descriptor) {
+      return pairs(descriptor).reduce(function(fields, pair) {
+        var name = pair[0], type = pair[1];
+        fields[name] = makeField(name, type);
+        return fields;
+      }, {});
+    }
+
+    var DictionaryType = Class({});
+
+    var Dictionary = Class({
+      extends: Type,
+      category: "dict",
+      get name() { return this.type; },
+      constructor: function(descriptor) {
+        this.type = descriptor.typeName;
+        this.types = descriptor.specializations;
+
+        var proto = Object.defineProperties({
+          extends: DictionaryType,
+          constructor: function(state, context) {
+            Object.defineProperties(this, {
+              state: {
+                enumerable: false,
+                writable: true,
+                configurable: true,
+                value: state
+              },
+              context: {
+                enumerable: false,
+                writable: false,
+                configurable: true,
+                value: context
+              }
+            });
+          }
+        }, makeFields(this.types));
+
+        this.class = new Class(proto);
+      },
+      read: function(input, context) {
+        return new this.class(input, context);
+      },
+      write: function(input, context) {
+        var output = {};
+        for (var key in input) {
+          output[key] = write(value, context, types[key]);
+        }
+        return output;
+      }
+    });
+
+    var makeMethods = function(descriptors) {
+      return descriptors.reduce(function(methods, descriptor) {
+        methods[descriptor.name] = {
+          enumerable: true,
+          configurable: true,
+          writable: false,
+          value: makeMethod(descriptor)
+        };
+        return methods;
+      }, {});
+    };
+
+    var makeEvents = function(descriptors) {
+      return pairs(descriptors).reduce(function(events, pair) {
+        var name = pair[0], descriptor = pair[1];
+        var event = new Event(name, descriptor);
+        events[event.eventType] = event;
+        return events;
+      }, Object.create(null));
+    };
+
+    var Actor = Class({
+      extends: Type,
+      category: "actor",
+      get name() { return this.type; },
+      constructor: function(descriptor) {
+        this.type = descriptor.typeName;
+
+        var events = makeEvents(descriptor.events || {});
+        var fields = makeFields(descriptor.fields || {});
+        var methods = makeMethods(descriptor.methods || []);
+
+
+        var proto = {
+          extends: Front,
+          constructor: function() {
+            Front.apply(this, arguments);
+          },
+          events: events
+        };
+        Object.defineProperties(proto, fields);
+        Object.defineProperties(proto, methods);
+
+        this.class = Class(proto);
+      },
+      read: function(input, context, detail) {
+        var state = typeof(input) === "string" ? { actor: input } : input;
+
+        var actor = client.get(state.actor) || new this.class(state, context);
+        actor.form(state, detail, context);
+
+        return actor;
+      },
+      write: function(input, context, detail) {
+        return input.id;
+      }
+    });
+    exports.Actor = Actor;
+
+
+    var ActorDetail = Class({
+      extends: Actor,
+      constructor: function(name) {
+        var parts = name.split("#")
+        this.actorType = parts[0]
+        this.detail = parts[1];
+      },
+      read: function(input, context) {
+        return typeFor(this.actorType).read(input, context, this.detail);
+      },
+      write: function(input, context) {
+        return typeFor(this.actorType).write(input, context, this.detail);
+      }
+    });
+    exports.ActorDetail = ActorDetail;
+
+    var Method = Class({
+      extends: Type,
+      constructor: function(descriptor) {
+        this.type = descriptor.name;
+        this.path = findPath(descriptor.response, "_retval");
+        this.responseType = this.path && query(descriptor.response, this.path)._retval;
+        this.requestType = descriptor.request.type;
+
+        var params = [];
+        for (var key in descriptor.request) {
+          if (key !== "type") {
+            var param = descriptor.request[key];
+            var index = "_arg" in param ? param._arg : param._option;
+            var isParam = param._option === index;
+            var isArgument = param._arg === index;
+            params[index] = {
+              type: param.type,
+              key: key,
+              index: index,
+              isParam: isParam,
+              isArgument: isArgument
+            };
+          }
+        }
+        this.params = params;
+      },
+      read: function(input, context) {
+        return read(query(input, this.path), context, this.responseType);
+      },
+      write: function(input, context) {
+        return this.params.reduce(function(result, param) {
+          result[param.key] = write(input[param.index], context, param.type);
+          return result;
+        }, {type: this.type});
+      }
+    });
+    exports.Method = Method;
+
+    var profiler = function(method, id) {
+      return function() {
+        var start = new Date();
+        return method.apply(this, arguments).then(function(result) {
+          var end = new Date();
+          client.telemetry.add(id, +end - start);
+          return result;
+        });
+      };
+    };
+
+    var destructor = function(method) {
+      return function() {
+        return method.apply(this, arguments).then(function(result) {
+          client.release(this);
+          return result;
+        });
+      };
+    };
+
+    function makeMethod(descriptor) {
+      var type = new Method(descriptor);
+      var method = descriptor.oneway ? makeUnidirecationalMethod(descriptor, type) :
+                   makeBidirectionalMethod(descriptor, type);
+
+      if (descriptor.telemetry)
+        method = profiler(method);
+      if (descriptor.release)
+        method = destructor(method);
+
+      return method;
+    }
+
+    var makeUnidirecationalMethod = function(descriptor, type) {
+      return function() {
+        var packet = type.write(arguments, this);
+        packet.to = this.id;
+        client.send(packet);
+        return Promise.resolve(void(0));
+      };
+    };
+
+    var makeBidirectionalMethod = function(descriptor, type) {
+      return function() {
+        var context = this.context;
+        var packet = type.write(arguments, context);
+        var context = this.context;
+        packet.to = this.id;
+        return client.request(packet).then(function(packet) {
+          return type.read(packet, context);
+        });
+      };
+    };
+
+    var Event = Class({
+      constructor: function(name, descriptor) {
+        this.name = descriptor.type || name;
+        this.eventType = descriptor.type || name;
+        this.types = Object.create(null);
+
+        var types = this.types;
+        for (var key in descriptor) {
+          if (key === "type") {
+            types[key] = "string";
+          } else {
+            types[key] = descriptor[key].type;
+          }
+        }
+      },
+      read: function(input, context) {
+        var output = {};
+        var types = this.types;
+        for (var key in input) {
+          output[key] = read(input[key], context, types[key]);
+        }
+        return output;
+      },
+      write: function(input, context) {
+        var output = {};
+        var types = this.types;
+        for (var key in this.types) {
+          output[key] = write(input[key], context, types[key]);
+        }
+        return output;
+      }
+    });
+
+    var Front = Class({
+      extends: EventTarget,
+      EventTarget: EventTarget,
+      constructor: function(state) {
+        this.EventTarget();
+        Object.defineProperties(this,  {
+          state: {
+            enumerable: false,
+            writable: true,
+            configurable: true,
+            value: state
+          }
+        });
+
+        client.register(this);
+      },
+      get id() {
+        return this.state.actor;
+      },
+      get context() {
+        return this;
+      },
+      form: function(state, detail, context) {
+        if (this.state !== state) {
+          if (detail) {
+            this.state[detail] = state[detail];
+          } else {
+            pairs(state).forEach(function(pair) {
+              var key = pair[0], value = pair[1];
+              this.state[key] = value;
+            }, this);
+          }
+        }
+
+        if (context) {
+          client.supervise(context, this);
+        }
+      },
+      requestTypes: function() {
+        return client.request({
+          to: this.id,
+          type: "requestTypes"
+        }).then(function(packet) {
+          return packet.requestTypes;
+        });
+      }
+    });
+    types.primitive = new Primitve("primitive");
+    types.string = new Primitve("string");
+    types.number = new Primitve("number");
+    types.boolean = new Primitve("boolean");
+    types.json = new Primitve("json");
+    types.array = new Primitve("array");
+  },
+  registerTypes: function(descriptor) {
+    var specification = this.specification;
+    values(descriptor.types).forEach(function(descriptor) {
+      specification[descriptor.typeName] = descriptor;
+    });
+  }
+});
+exports.TypeSystem = TypeSystem;
+
+},{"./class":3,"./event":5,"./util":26}],26:[function(_dereq_,module,exports){
+"use strict";
+
+var keys = Object.keys;
+exports.keys = keys;
+
+// Returns array of values for the given object.
+var values = function(object) {
+  return keys(object).map(function(key) {
+    return object[key]
+  });
+};
+exports.values = values;
+
+// Returns [key, value] pairs for the given object.
+var pairs = function(object) {
+  return keys(object).map(function(key) {
+    return [key, object[key]]
+  });
+};
+exports.pairs = pairs;
+
+
+// Queries an object for the field nested with in it.
+var query = function(object, path) {
+  return path.reduce(function(object, entry) {
+    return object && object[entry]
+  }, object);
+};
+exports.query = query;
+
+var isObject = function(x) {
+  return x && typeof(x) === "object"
+}
+
+var findPath = function(object, key) {
+  var path = void(0);
+  if (object && typeof(object) === "object") {
+    var names = keys(object);
+    if (names.indexOf(key) >= 0) {
+      path = [];
+    } else {
+      var index = 0;
+      var count = names.length;
+      while (index < count && !path){
+        var head = names[index];
+        var tail = findPath(object[head], key);
+        path = tail ? [head].concat(tail) : tail;
+        index = index + 1
+      }
+    }
+  }
+  return path;
+};
+exports.findPath = findPath;
+
+},{}]},{},[1])
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generated.js","sources":["/Users/gozala/Projects/volcan/node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/gozala/Projects/volcan/browser/index.js","/Users/gozala/Projects/volcan/browser/promise.js","/Users/gozala/Projects/volcan/class.js","/Users/gozala/Projects/volcan/client.js","/Users/gozala/Projects/volcan/event.js","/Users/gozala/Projects/volcan/node_modules/browserify/node_modules/events/events.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/is-implemented.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/d/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/assign/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/assign/is-implemented.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/assign/shim.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/is-callable.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/keys/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/keys/is-implemented.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/keys/shim.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/normalize-options.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/object/valid-value.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/string/#/contains/index.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/string/#/contains/is-implemented.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/node_modules/es5-ext/string/#/contains/shim.js","/Users/gozala/Projects/volcan/node_modules/es6-symbol/polyfill.js","/Users/gozala/Projects/volcan/specification/core.json","/Users/gozala/Projects/volcan/specification/protocol.json","/Users/gozala/Projects/volcan/type-system.js","/Users/gozala/Projects/volcan/util.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/SA;AACA;AACA;AACA;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtBA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACRA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzJA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3uEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\"use strict\";\n\nvar Client = require(\"../client\").Client;\n\nfunction connect(port) {\n  var client = new Client();\n  return client.connect(port);\n}\nexports.connect = connect;\n","\"use strict\";\n\nexports.Promise = Promise;\n","\"use strict\";\n\nvar describe = Object.getOwnPropertyDescriptor;\nvar Class = function(fields) {\n  var names = Object.keys(fields);\n  var constructor = names.indexOf(\"constructor\") >= 0 ? fields.constructor :\n                    function() {};\n  var ancestor = fields.extends || Object;\n\n  var descriptor = names.reduce(function(descriptor, key) {\n    descriptor[key] = describe(fields, key);\n    return descriptor;\n  }, {});\n\n  var prototype = Object.create(ancestor.prototype, descriptor);\n\n  constructor.prototype = prototype;\n  prototype.constructor = constructor;\n\n  return constructor;\n};\nexports.Class = Class;\n","\"use strict\";\n\nvar Class = require(\"./class\").Class;\nvar TypeSystem = require(\"./type-system\").TypeSystem;\nvar values = require(\"./util\").values;\nvar Promise = require(\"es6-promise\").Promise;\nvar MessageEvent = require(\"./event\").MessageEvent;\n\nvar specification = require(\"./specification/core.json\");\n\nfunction recoverActorDescriptions(error) {\n  console.warn(\"Failed to fetch protocol specification (see reason below). \" +\n               \"Using a fallback protocal specification!\",\n               error);\n  return require(\"./specification/protocol.json\");\n}\n\n// Type to represent superviser actor relations to actors they supervise\n// in terms of lifetime management.\nvar Supervisor = Class({\n  constructor: function(id) {\n    this.id = id;\n    this.workers = [];\n  }\n});\n\nvar Telemetry = Class({\n  add: function(id, ms) {\n    console.log(\"telemetry::\", id, ms)\n  }\n});\n\n// Consider making client a root actor.\n\nvar Client = Class({\n  constructor: function() {\n    this.root = null;\n    this.telemetry = new Telemetry();\n\n    this.setupConnection();\n    this.setupLifeManagement();\n    this.setupTypeSystem();\n  },\n\n  setupConnection: function() {\n    this.requests = [];\n  },\n  setupLifeManagement: function() {\n    this.cache = Object.create(null);\n    this.graph = Object.create(null);\n    this.get = this.get.bind(this);\n    this.release = this.release.bind(this);\n  },\n  setupTypeSystem: function() {\n    this.typeSystem = new TypeSystem(this);\n    this.typeSystem.registerTypes(specification);\n  },\n\n  connect: function(port) {\n    var client = this;\n    return new Promise(function(resolve, reject) {\n      client.port = port;\n      port.onmessage = client.receive.bind(client);\n      client.onReady = resolve;\n      client.onFail = reject;\n\n      port.start();\n    });\n  },\n  send: function(packet) {\n    this.port.postMessage(packet);\n  },\n  request: function(packet) {\n    var client = this;\n    return new Promise(function(resolve, reject) {\n      client.requests.push(packet.to, { resolve: resolve, reject: reject });\n      client.send(packet);\n    });\n  },\n\n  receive: function(event) {\n    var packet = event.data;\n    if (!this.root) {\n      if (packet.from !== \"root\")\n        throw Error(\"Initial packet must be from root\");\n      if (!(\"applicationType\" in packet))\n        throw Error(\"Initial packet must contain applicationType field\");\n\n      this.root = this.typeSystem.read(\"root\", null, \"root\");\n      this.root\n          .protocolDescription()\n          .catch(recoverActorDescriptions)\n          .then(this.typeSystem.registerTypes.bind(this.typeSystem))\n          .then(this.onReady.bind(this, this.root), this.onFail);\n    } else {\n      var actor = this.get(packet.from) || this.root;\n      var event = actor.events[packet.type];\n      if (event) {\n        var message = new MessageEvent(packet.type, {\n          data: event.read(packet)\n        });\n        actor.dispatchEvent(message);\n      } else {\n        var index = this.requests.indexOf(actor.id);\n        if (index >= 0) {\n          var request = this.requests.splice(index, 2).pop();\n          if (packet.error)\n            request.reject(packet);\n          else\n            request.resolve(packet);\n        } else {\n          console.error(Error(\"Unexpected packet \" + JSON.stringify(packet, 2, 2)),\n                        packet,\n                        this.requests.slice(0));\n        }\n      }\n    }\n  },\n\n  get: function(id) {\n    return this.cache[id];\n  },\n  supervisorOf: function(actor) {\n    for (var id in this.graph) {\n      if (this.graph[id].indexOf(actor.id) >= 0) {\n        return id;\n      }\n    }\n  },\n  workersOf: function(actor) {\n    return this.graph[actor.id];\n  },\n  supervise: function(actor, worker) {\n    var workers = this.workersOf(actor)\n    if (workers.indexOf(worker.id) < 0) {\n      workers.push(worker.id);\n    }\n  },\n  unsupervise: function(actor, worker) {\n    var workers = this.workersOf(actor);\n    var index = workers.indexOf(worker.id)\n    if (index >= 0) {\n      workers.splice(index, 1)\n    }\n  },\n\n  register: function(actor) {\n    var registered = this.get(actor.id);\n    if (!registered) {\n      this.cache[actor.id] = actor;\n      this.graph[actor.id] = [];\n    } else if (registered !== actor) {\n      throw new Error(\"Different actor with same id is already registered\");\n    }\n  },\n  unregister: function(actor) {\n    if (this.get(actor.id)) {\n      delete this.cache[actor.id];\n      delete this.graph[actor.id];\n    }\n  },\n\n  release: function(actor) {\n    var supervisor = this.supervisorOf(actor);\n    if (supervisor)\n      this.unsupervise(supervisor, actor);\n\n    var workers = this.workersOf(actor)\n\n    if (workers) {\n      workers.map(this.get).forEach(this.release)\n    }\n    this.unregister(actor);\n  }\n});\nexports.Client = Client;\n","\"use strict\";\n\nvar Symbol = require(\"es6-symbol\")\nvar EventEmitter = require(\"events\").EventEmitter;\nvar Class = require(\"./class\").Class;\n\nvar $bound = Symbol(\"EventTarget/handleEvent\");\nvar $emitter = Symbol(\"EventTarget/emitter\");\n\nfunction makeHandler(handler) {\n  return function(event) {\n    handler.handleEvent(event);\n  }\n}\n\nvar EventTarget = Class({\n  constructor: function() {\n    Object.defineProperty(this, $emitter, {\n      enumerable: false,\n      configurable: true,\n      writable: true,\n      value: new EventEmitter()\n    });\n  },\n  addEventListener: function(type, handler) {\n    if (typeof(handler) === \"function\") {\n      this[$emitter].on(type, handler);\n    }\n    else if (handler && typeof(handler) === \"object\") {\n      if (!handler[$bound]) handler[$bound] = makeHandler(handler);\n      this[$emitter].on(type, handler[$bound]);\n    }\n  },\n  removeEventListener: function(type, handler) {\n    if (typeof(handler) === \"function\")\n      this[$emitter].removeListener(type, handler);\n    else if (handler && handler[$bound])\n      this[$emitter].removeListener(type, handler[$bound]);\n  },\n  dispatchEvent: function(event) {\n    event.target = this;\n    this[$emitter].emit(event.type, event);\n  }\n});\nexports.EventTarget = EventTarget;\n\nvar MessageEvent = Class({\n  constructor: function(type, options) {\n    options = options || {};\n    this.type = type;\n    this.data = options.data === void(0) ? null : options.data;\n\n    this.lastEventId = options.lastEventId || \"\";\n    this.origin = options.origin || \"\";\n    this.bubbles = options.bubbles || false;\n    this.cancelable = options.cancelable || false;\n  },\n  source: null,\n  ports: null,\n  preventDefault: function() {\n  },\n  stopPropagation: function() {\n  },\n  stopImmediatePropagation: function() {\n  }\n});\nexports.MessageEvent = MessageEvent;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nfunction EventEmitter() {\n  this._events = this._events || {};\n  this._maxListeners = this._maxListeners || undefined;\n}\nmodule.exports = EventEmitter;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nEventEmitter.defaultMaxListeners = 10;\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function(n) {\n  if (!isNumber(n) || n < 0 || isNaN(n))\n    throw TypeError('n must be a positive number');\n  this._maxListeners = n;\n  return this;\n};\n\nEventEmitter.prototype.emit = function(type) {\n  var er, handler, len, args, i, listeners;\n\n  if (!this._events)\n    this._events = {};\n\n  // If there is no 'error' event listener then throw.\n  if (type === 'error') {\n    if (!this._events.error ||\n        (isObject(this._events.error) && !this._events.error.length)) {\n      er = arguments[1];\n      if (er instanceof Error) {\n        throw er; // Unhandled 'error' event\n      } else {\n        throw TypeError('Uncaught, unspecified \"error\" event.');\n      }\n      return false;\n    }\n  }\n\n  handler = this._events[type];\n\n  if (isUndefined(handler))\n    return false;\n\n  if (isFunction(handler)) {\n    switch (arguments.length) {\n      // fast cases\n      case 1:\n        handler.call(this);\n        break;\n      case 2:\n        handler.call(this, arguments[1]);\n        break;\n      case 3:\n        handler.call(this, arguments[1], arguments[2]);\n        break;\n      // slower\n      default:\n        len = arguments.length;\n        args = new Array(len - 1);\n        for (i = 1; i < len; i++)\n          args[i - 1] = arguments[i];\n        handler.apply(this, args);\n    }\n  } else if (isObject(handler)) {\n    len = arguments.length;\n    args = new Array(len - 1);\n    for (i = 1; i < len; i++)\n      args[i - 1] = arguments[i];\n\n    listeners = handler.slice();\n    len = listeners.length;\n    for (i = 0; i < len; i++)\n      listeners[i].apply(this, args);\n  }\n\n  return true;\n};\n\nEventEmitter.prototype.addListener = function(type, listener) {\n  var m;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events)\n    this._events = {};\n\n  // To avoid recursion in the case that type === \"newListener\"! Before\n  // adding it to the listeners, first emit \"newListener\".\n  if (this._events.newListener)\n    this.emit('newListener', type,\n              isFunction(listener.listener) ?\n              listener.listener : listener);\n\n  if (!this._events[type])\n    // Optimize the case of one listener. Don't need the extra array object.\n    this._events[type] = listener;\n  else if (isObject(this._events[type]))\n    // If we've already got an array, just append.\n    this._events[type].push(listener);\n  else\n    // Adding the second element, need to change to array.\n    this._events[type] = [this._events[type], listener];\n\n  // Check for listener leak\n  if (isObject(this._events[type]) && !this._events[type].warned) {\n    var m;\n    if (!isUndefined(this._maxListeners)) {\n      m = this._maxListeners;\n    } else {\n      m = EventEmitter.defaultMaxListeners;\n    }\n\n    if (m && m > 0 && this._events[type].length > m) {\n      this._events[type].warned = true;\n      console.error('(node) warning: possible EventEmitter memory ' +\n                    'leak detected. %d listeners added. ' +\n                    'Use emitter.setMaxListeners() to increase limit.',\n                    this._events[type].length);\n      if (typeof console.trace === 'function') {\n        // not supported in IE 10\n        console.trace();\n      }\n    }\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.once = function(type, listener) {\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  var fired = false;\n\n  function g() {\n    this.removeListener(type, g);\n\n    if (!fired) {\n      fired = true;\n      listener.apply(this, arguments);\n    }\n  }\n\n  g.listener = listener;\n  this.on(type, g);\n\n  return this;\n};\n\n// emits a 'removeListener' event iff the listener was removed\nEventEmitter.prototype.removeListener = function(type, listener) {\n  var list, position, length, i;\n\n  if (!isFunction(listener))\n    throw TypeError('listener must be a function');\n\n  if (!this._events || !this._events[type])\n    return this;\n\n  list = this._events[type];\n  length = list.length;\n  position = -1;\n\n  if (list === listener ||\n      (isFunction(list.listener) && list.listener === listener)) {\n    delete this._events[type];\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n\n  } else if (isObject(list)) {\n    for (i = length; i-- > 0;) {\n      if (list[i] === listener ||\n          (list[i].listener && list[i].listener === listener)) {\n        position = i;\n        break;\n      }\n    }\n\n    if (position < 0)\n      return this;\n\n    if (list.length === 1) {\n      list.length = 0;\n      delete this._events[type];\n    } else {\n      list.splice(position, 1);\n    }\n\n    if (this._events.removeListener)\n      this.emit('removeListener', type, listener);\n  }\n\n  return this;\n};\n\nEventEmitter.prototype.removeAllListeners = function(type) {\n  var key, listeners;\n\n  if (!this._events)\n    return this;\n\n  // not listening for removeListener, no need to emit\n  if (!this._events.removeListener) {\n    if (arguments.length === 0)\n      this._events = {};\n    else if (this._events[type])\n      delete this._events[type];\n    return this;\n  }\n\n  // emit removeListener for all listeners on all events\n  if (arguments.length === 0) {\n    for (key in this._events) {\n      if (key === 'removeListener') continue;\n      this.removeAllListeners(key);\n    }\n    this.removeAllListeners('removeListener');\n    this._events = {};\n    return this;\n  }\n\n  listeners = this._events[type];\n\n  if (isFunction(listeners)) {\n    this.removeListener(type, listeners);\n  } else {\n    // LIFO order\n    while (listeners.length)\n      this.removeListener(type, listeners[listeners.length - 1]);\n  }\n  delete this._events[type];\n\n  return this;\n};\n\nEventEmitter.prototype.listeners = function(type) {\n  var ret;\n  if (!this._events || !this._events[type])\n    ret = [];\n  else if (isFunction(this._events[type]))\n    ret = [this._events[type]];\n  else\n    ret = this._events[type].slice();\n  return ret;\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  var ret;\n  if (!emitter._events || !emitter._events[type])\n    ret = 0;\n  else if (isFunction(emitter._events[type]))\n    ret = 1;\n  else\n    ret = emitter._events[type].length;\n  return ret;\n};\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\n","'use strict';\n\nmodule.exports = require('./is-implemented')() ? Symbol : require('./polyfill');\n","'use strict';\n\nmodule.exports = function () {\n\tvar symbol;\n\tif (typeof Symbol !== 'function') return false;\n\tsymbol = Symbol('test symbol');\n\ttry {\n\t\tif (String(symbol) !== 'Symbol (test symbol)') return false;\n\t} catch (e) { return false; }\n\tif (typeof Symbol.iterator === 'symbol') return true;\n\n\t// Return 'true' for polyfills\n\tif (typeof Symbol.isConcatSpreadable !== 'object') return false;\n\tif (typeof Symbol.isRegExp !== 'object') return false;\n\tif (typeof Symbol.iterator !== 'object') return false;\n\tif (typeof Symbol.toPrimitive !== 'object') return false;\n\tif (typeof Symbol.toStringTag !== 'object') return false;\n\tif (typeof Symbol.unscopables !== 'object') return false;\n\n\treturn true;\n};\n","'use strict';\n\nvar assign        = require('es5-ext/object/assign')\n  , normalizeOpts = require('es5-ext/object/normalize-options')\n  , isCallable    = require('es5-ext/object/is-callable')\n  , contains      = require('es5-ext/string/#/contains')\n\n  , d;\n\nd = module.exports = function (dscr, value/*, options*/) {\n\tvar c, e, w, options, desc;\n\tif ((arguments.length < 2) || (typeof dscr !== 'string')) {\n\t\toptions = value;\n\t\tvalue = dscr;\n\t\tdscr = null;\n\t} else {\n\t\toptions = arguments[2];\n\t}\n\tif (dscr == null) {\n\t\tc = w = true;\n\t\te = false;\n\t} else {\n\t\tc = contains.call(dscr, 'c');\n\t\te = contains.call(dscr, 'e');\n\t\tw = contains.call(dscr, 'w');\n\t}\n\n\tdesc = { value: value, configurable: c, enumerable: e, writable: w };\n\treturn !options ? desc : assign(normalizeOpts(options), desc);\n};\n\nd.gs = function (dscr, get, set/*, options*/) {\n\tvar c, e, options, desc;\n\tif (typeof dscr !== 'string') {\n\t\toptions = set;\n\t\tset = get;\n\t\tget = dscr;\n\t\tdscr = null;\n\t} else {\n\t\toptions = arguments[3];\n\t}\n\tif (get == null) {\n\t\tget = undefined;\n\t} else if (!isCallable(get)) {\n\t\toptions = get;\n\t\tget = set = undefined;\n\t} else if (set == null) {\n\t\tset = undefined;\n\t} else if (!isCallable(set)) {\n\t\toptions = set;\n\t\tset = undefined;\n\t}\n\tif (dscr == null) {\n\t\tc = true;\n\t\te = false;\n\t} else {\n\t\tc = contains.call(dscr, 'c');\n\t\te = contains.call(dscr, 'e');\n\t}\n\n\tdesc = { get: get, set: set, configurable: c, enumerable: e };\n\treturn !options ? desc : assign(normalizeOpts(options), desc);\n};\n","'use strict';\n\nmodule.exports = require('./is-implemented')()\n\t? Object.assign\n\t: require('./shim');\n","'use strict';\n\nmodule.exports = function () {\n\tvar assign = Object.assign, obj;\n\tif (typeof assign !== 'function') return false;\n\tobj = { foo: 'raz' };\n\tassign(obj, { bar: 'dwa' }, { trzy: 'trzy' });\n\treturn (obj.foo + obj.bar + obj.trzy) === 'razdwatrzy';\n};\n","'use strict';\n\nvar keys  = require('../keys')\n  , value = require('../valid-value')\n\n  , max = Math.max;\n\nmodule.exports = function (dest, src/*, …srcn*/) {\n\tvar error, i, l = max(arguments.length, 2), assign;\n\tdest = Object(value(dest));\n\tassign = function (key) {\n\t\ttry { dest[key] = src[key]; } catch (e) {\n\t\t\tif (!error) error = e;\n\t\t}\n\t};\n\tfor (i = 1; i < l; ++i) {\n\t\tsrc = arguments[i];\n\t\tkeys(src).forEach(assign);\n\t}\n\tif (error !== undefined) throw error;\n\treturn dest;\n};\n","// Deprecated\n\n'use strict';\n\nmodule.exports = function (obj) { return typeof obj === 'function'; };\n","'use strict';\n\nmodule.exports = require('./is-implemented')()\n\t? Object.keys\n\t: require('./shim');\n","'use strict';\n\nmodule.exports = function () {\n\ttry {\n\t\tObject.keys('primitive');\n\t\treturn true;\n\t} catch (e) { return false; }\n};\n","'use strict';\n\nvar keys = Object.keys;\n\nmodule.exports = function (object) {\n\treturn keys(object == null ? object : Object(object));\n};\n","'use strict';\n\nvar assign = require('./assign')\n\n  , forEach = Array.prototype.forEach\n  , create = Object.create, getPrototypeOf = Object.getPrototypeOf\n\n  , process;\n\nprocess = function (src, obj) {\n\tvar proto = getPrototypeOf(src);\n\treturn assign(proto ? process(proto, obj) : obj, src);\n};\n\nmodule.exports = function (options/*, …options*/) {\n\tvar result = create(null);\n\tforEach.call(arguments, function (options) {\n\t\tif (options == null) return;\n\t\tprocess(Object(options), result);\n\t});\n\treturn result;\n};\n","'use strict';\n\nmodule.exports = function (value) {\n\tif (value == null) throw new TypeError(\"Cannot use null or undefined\");\n\treturn value;\n};\n","'use strict';\n\nmodule.exports = require('./is-implemented')()\n\t? String.prototype.contains\n\t: require('./shim');\n","'use strict';\n\nvar str = 'razdwatrzy';\n\nmodule.exports = function () {\n\tif (typeof str.contains !== 'function') return false;\n\treturn ((str.contains('dwa') === true) && (str.contains('foo') === false));\n};\n","'use strict';\n\nvar indexOf = String.prototype.indexOf;\n\nmodule.exports = function (searchString/*, position*/) {\n\treturn indexOf.call(this, searchString, arguments[1]) > -1;\n};\n","'use strict';\n\nvar d = require('d')\n\n  , create = Object.create, defineProperties = Object.defineProperties\n  , generateName, Symbol;\n\ngenerateName = (function () {\n\tvar created = create(null);\n\treturn function (desc) {\n\t\tvar postfix = 0;\n\t\twhile (created[desc + (postfix || '')]) ++postfix;\n\t\tdesc += (postfix || '');\n\t\tcreated[desc] = true;\n\t\treturn '@@' + desc;\n\t};\n}());\n\nmodule.exports = Symbol = function (description) {\n\tvar symbol;\n\tif (this instanceof Symbol) {\n\t\tthrow new TypeError('TypeError: Symbol is not a constructor');\n\t}\n\tsymbol = create(Symbol.prototype);\n\tdescription = (description === undefined ? '' : String(description));\n\treturn defineProperties(symbol, {\n\t\t__description__: d('', description),\n\t\t__name__: d('', generateName(description))\n\t});\n};\n\nObject.defineProperties(Symbol, {\n\tcreate: d('', Symbol('create')),\n\thasInstance: d('', Symbol('hasInstance')),\n\tisConcatSpreadable: d('', Symbol('isConcatSpreadable')),\n\tisRegExp: d('', Symbol('isRegExp')),\n\titerator: d('', Symbol('iterator')),\n\ttoPrimitive: d('', Symbol('toPrimitive')),\n\ttoStringTag: d('', Symbol('toStringTag')),\n\tunscopables: d('', Symbol('unscopables'))\n});\n\ndefineProperties(Symbol.prototype, {\n\tproperToString: d(function () {\n\t\treturn 'Symbol (' + this.__description__ + ')';\n\t}),\n\ttoString: d('', function () { return this.__name__; })\n});\nObject.defineProperty(Symbol.prototype, Symbol.toPrimitive, d('',\n\tfunction (hint) {\n\t\tthrow new TypeError(\"Conversion of symbol objects is not allowed\");\n\t}));\nObject.defineProperty(Symbol.prototype, Symbol.toStringTag, d('c', 'Symbol'));\n","module.exports={\n  \"types\": {\n    \"root\": {\n      \"category\": \"actor\",\n      \"typeName\": \"root\",\n      \"methods\": [\n        {\n          \"name\": \"echo\",\n          \"request\": {\n            \"string\": { \"_arg\": 0, \"type\": \"string\" }\n          },\n          \"response\": {\n            \"string\": { \"_retval\": \"string\" }\n          }\n        },\n        {\n          \"name\": \"listTabs\",\n          \"request\": {},\n          \"response\": { \"_retval\": \"tablist\" }\n        },\n        {\n          \"name\": \"protocolDescription\",\n          \"request\": {},\n          \"response\": { \"_retval\": \"json\" }\n        }\n      ],\n      \"events\": {\n        \"tabListChanged\": {}\n      }\n    },\n    \"tablist\": {\n      \"category\": \"dict\",\n      \"typeName\": \"tablist\",\n      \"specializations\": {\n        \"selected\": \"number\",\n        \"tabs\": \"array:tab\",\n        \"url\": \"string\",\n        \"consoleActor\": \"console\",\n        \"inspectorActor\": \"inspector\",\n        \"styleSheetsActor\": \"stylesheets\",\n        \"styleEditorActor\": \"styleeditor\",\n        \"memoryActor\": \"memory\",\n        \"eventLoopLagActor\": \"eventLoopLag\",\n        \"preferenceActor\": \"preference\",\n        \"deviceActor\": \"device\",\n\n        \"profilerActor\": \"profiler\",\n        \"chromeDebugger\": \"chromeDebugger\",\n        \"webappsActor\": \"webapps\"\n      }\n    },\n    \"tab\": {\n      \"category\": \"actor\",\n      \"typeName\": \"tab\",\n      \"fields\": {\n        \"title\": \"string\",\n        \"url\": \"string\",\n        \"outerWindowID\": \"number\",\n        \"inspectorActor\": \"inspector\",\n        \"callWatcherActor\": \"call-watcher\",\n        \"canvasActor\": \"canvas\",\n        \"webglActor\": \"webgl\",\n        \"webaudioActor\": \"webaudio\",\n        \"storageActor\": \"storage\",\n        \"gcliActor\": \"gcli\",\n        \"memoryActor\": \"memory\",\n        \"eventLoopLag\": \"eventLoopLag\",\n        \"styleSheetsActor\": \"stylesheets\",\n        \"styleEditorActor\": \"styleeditor\",\n\n        \"consoleActor\": \"console\",\n        \"traceActor\": \"trace\"\n      },\n      \"methods\": [\n         {\n          \"name\": \"attach\",\n          \"request\": {},\n          \"response\": { \"_retval\": \"json\" }\n         }\n      ],\n      \"events\": {\n        \"tabNavigated\": {\n           \"typeName\": \"tabNavigated\"\n        }\n      }\n    },\n    \"console\": {\n      \"category\": \"actor\",\n      \"typeName\": \"console\",\n      \"methods\": [\n        {\n          \"name\": \"evaluateJS\",\n          \"request\": {\n            \"text\": {\n              \"_option\": 0,\n              \"type\": \"string\"\n            },\n            \"url\": {\n              \"_option\": 1,\n              \"type\": \"string\"\n            },\n            \"bindObjectActor\": {\n              \"_option\": 2,\n              \"type\": \"nullable:string\"\n            },\n            \"frameActor\": {\n              \"_option\": 2,\n              \"type\": \"nullable:string\"\n            },\n            \"selectedNodeActor\": {\n              \"_option\": 2,\n              \"type\": \"nullable:string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"evaluatejsresponse\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"evaluatejsresponse\": {\n      \"category\": \"dict\",\n      \"typeName\": \"evaluatejsresponse\",\n      \"specializations\": {\n        \"result\": \"object\",\n        \"exception\": \"object\",\n        \"exceptionMessage\": \"string\",\n        \"input\": \"string\"\n      }\n    },\n    \"object\": {\n      \"category\": \"actor\",\n      \"typeName\": \"object\",\n      \"methods\": [\n         {\n           \"name\": \"property\",\n           \"request\": {\n              \"name\": {\n                \"_arg\": 0,\n                \"type\": \"string\"\n              }\n           },\n           \"response\": {\n              \"descriptor\": {\n                \"_retval\": \"json\"\n              }\n           }\n         }\n      ]\n    }\n  }\n}\n","module.exports={\n  \"types\": {\n    \"longstractor\": {\n      \"category\": \"actor\",\n      \"typeName\": \"longstractor\",\n      \"methods\": [\n        {\n          \"name\": \"substring\",\n          \"request\": {\n            \"type\": \"substring\",\n            \"start\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"end\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"substring\": {\n              \"_retval\": \"primitive\"\n            }\n          }\n        },\n        {\n          \"name\": \"release\",\n          \"release\": true,\n          \"request\": {\n            \"type\": \"release\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"stylesheet\": {\n      \"category\": \"actor\",\n      \"typeName\": \"stylesheet\",\n      \"methods\": [\n        {\n          \"name\": \"toggleDisabled\",\n          \"request\": {\n            \"type\": \"toggleDisabled\"\n          },\n          \"response\": {\n            \"disabled\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"getText\",\n          \"request\": {\n            \"type\": \"getText\"\n          },\n          \"response\": {\n            \"text\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"getOriginalSources\",\n          \"request\": {\n            \"type\": \"getOriginalSources\"\n          },\n          \"response\": {\n            \"originalSources\": {\n              \"_retval\": \"nullable:array:originalsource\"\n            }\n          }\n        },\n        {\n          \"name\": \"getOriginalLocation\",\n          \"request\": {\n            \"type\": \"getOriginalLocation\",\n            \"line\": {\n              \"_arg\": 0,\n              \"type\": \"number\"\n            },\n            \"column\": {\n              \"_arg\": 1,\n              \"type\": \"number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"originallocationresponse\"\n          }\n        },\n        {\n          \"name\": \"update\",\n          \"request\": {\n            \"type\": \"update\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"transition\": {\n              \"_arg\": 1,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {\n        \"property-change\": {\n          \"type\": \"propertyChange\",\n          \"property\": {\n            \"_arg\": 0,\n            \"type\": \"string\"\n          },\n          \"value\": {\n            \"_arg\": 1,\n            \"type\": \"json\"\n          }\n        },\n        \"style-applied\": {\n          \"type\": \"styleApplied\"\n        }\n      }\n    },\n    \"originalsource\": {\n      \"category\": \"actor\",\n      \"typeName\": \"originalsource\",\n      \"methods\": [\n        {\n          \"name\": \"getText\",\n          \"request\": {\n            \"type\": \"getText\"\n          },\n          \"response\": {\n            \"text\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"stylesheets\": {\n      \"category\": \"actor\",\n      \"typeName\": \"stylesheets\",\n      \"methods\": [\n        {\n          \"name\": \"getStyleSheets\",\n          \"request\": {\n            \"type\": \"getStyleSheets\"\n          },\n          \"response\": {\n            \"styleSheets\": {\n              \"_retval\": \"array:stylesheet\"\n            }\n          }\n        },\n        {\n          \"name\": \"addStyleSheet\",\n          \"request\": {\n            \"type\": \"addStyleSheet\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"styleSheet\": {\n              \"_retval\": \"stylesheet\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"originallocationresponse\": {\n      \"category\": \"dict\",\n      \"typeName\": \"originallocationresponse\",\n      \"specializations\": {\n        \"source\": \"string\",\n        \"line\": \"number\",\n        \"column\": \"number\"\n      }\n    },\n    \"domnode\": {\n      \"category\": \"actor\",\n      \"typeName\": \"domnode\",\n      \"methods\": [\n        {\n          \"name\": \"getNodeValue\",\n          \"request\": {\n            \"type\": \"getNodeValue\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"setNodeValue\",\n          \"request\": {\n            \"type\": \"setNodeValue\",\n            \"value\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"getImageData\",\n          \"request\": {\n            \"type\": \"getImageData\",\n            \"maxDim\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"imageData\"\n          }\n        },\n        {\n          \"name\": \"modifyAttributes\",\n          \"request\": {\n            \"type\": \"modifyAttributes\",\n            \"modifications\": {\n              \"_arg\": 0,\n              \"type\": \"array:json\"\n            }\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"appliedstyle\": {\n      \"category\": \"dict\",\n      \"typeName\": \"appliedstyle\",\n      \"specializations\": {\n        \"rule\": \"domstylerule#actorid\",\n        \"inherited\": \"nullable:domnode#actorid\"\n      }\n    },\n    \"matchedselector\": {\n      \"category\": \"dict\",\n      \"typeName\": \"matchedselector\",\n      \"specializations\": {\n        \"rule\": \"domstylerule#actorid\",\n        \"selector\": \"string\",\n        \"value\": \"string\",\n        \"status\": \"number\"\n      }\n    },\n    \"matchedselectorresponse\": {\n      \"category\": \"dict\",\n      \"typeName\": \"matchedselectorresponse\",\n      \"specializations\": {\n        \"rules\": \"array:domstylerule\",\n        \"sheets\": \"array:stylesheet\",\n        \"matched\": \"array:matchedselector\"\n      }\n    },\n    \"appliedStylesReturn\": {\n      \"category\": \"dict\",\n      \"typeName\": \"appliedStylesReturn\",\n      \"specializations\": {\n        \"entries\": \"array:appliedstyle\",\n        \"rules\": \"array:domstylerule\",\n        \"sheets\": \"array:stylesheet\"\n      }\n    },\n    \"pagestyle\": {\n      \"category\": \"actor\",\n      \"typeName\": \"pagestyle\",\n      \"methods\": [\n        {\n          \"name\": \"getComputed\",\n          \"request\": {\n            \"type\": \"getComputed\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"markMatched\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            },\n            \"onlyMatched\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            },\n            \"filter\": {\n              \"_option\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"computed\": {\n              \"_retval\": \"json\"\n            }\n          }\n        },\n        {\n          \"name\": \"getMatchedSelectors\",\n          \"request\": {\n            \"type\": \"getMatchedSelectors\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"property\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            },\n            \"filter\": {\n              \"_option\": 2,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"matchedselectorresponse\"\n          }\n        },\n        {\n          \"name\": \"getApplied\",\n          \"request\": {\n            \"type\": \"getApplied\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"inherited\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            },\n            \"matchedSelectors\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            },\n            \"filter\": {\n              \"_option\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"appliedStylesReturn\"\n          }\n        },\n        {\n          \"name\": \"getLayout\",\n          \"request\": {\n            \"type\": \"getLayout\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"autoMargins\": {\n              \"_option\": 1,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"domstylerule\": {\n      \"category\": \"actor\",\n      \"typeName\": \"domstylerule\",\n      \"methods\": [\n        {\n          \"name\": \"modifyProperties\",\n          \"request\": {\n            \"type\": \"modifyProperties\",\n            \"modifications\": {\n              \"_arg\": 0,\n              \"type\": \"array:json\"\n            }\n          },\n          \"response\": {\n            \"rule\": {\n              \"_retval\": \"domstylerule\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"highlighter\": {\n      \"category\": \"actor\",\n      \"typeName\": \"highlighter\",\n      \"methods\": [\n        {\n          \"name\": \"showBoxModel\",\n          \"request\": {\n            \"type\": \"showBoxModel\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"region\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"hideBoxModel\",\n          \"request\": {\n            \"type\": \"hideBoxModel\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"pick\",\n          \"request\": {\n            \"type\": \"pick\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"cancelPick\",\n          \"request\": {\n            \"type\": \"cancelPick\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"imageData\": {\n      \"category\": \"dict\",\n      \"typeName\": \"imageData\",\n      \"specializations\": {\n        \"data\": \"nullable:longstring\",\n        \"size\": \"json\"\n      }\n    },\n    \"disconnectedNode\": {\n      \"category\": \"dict\",\n      \"typeName\": \"disconnectedNode\",\n      \"specializations\": {\n        \"node\": \"domnode\",\n        \"newParents\": \"array:domnode\"\n      }\n    },\n    \"disconnectedNodeArray\": {\n      \"category\": \"dict\",\n      \"typeName\": \"disconnectedNodeArray\",\n      \"specializations\": {\n        \"nodes\": \"array:domnode\",\n        \"newParents\": \"array:domnode\"\n      }\n    },\n    \"dommutation\": {\n      \"category\": \"dict\",\n      \"typeName\": \"dommutation\",\n      \"specializations\": {}\n    },\n    \"domnodelist\": {\n      \"category\": \"actor\",\n      \"typeName\": \"domnodelist\",\n      \"methods\": [\n        {\n          \"name\": \"item\",\n          \"request\": {\n            \"type\": \"item\",\n            \"item\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"disconnectedNode\"\n          }\n        },\n        {\n          \"name\": \"items\",\n          \"request\": {\n            \"type\": \"items\",\n            \"start\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:number\"\n            },\n            \"end\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"disconnectedNodeArray\"\n          }\n        },\n        {\n          \"name\": \"release\",\n          \"release\": true,\n          \"request\": {\n            \"type\": \"release\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"domtraversalarray\": {\n      \"category\": \"dict\",\n      \"typeName\": \"domtraversalarray\",\n      \"specializations\": {\n        \"nodes\": \"array:domnode\"\n      }\n    },\n    \"domwalker\": {\n      \"category\": \"actor\",\n      \"typeName\": \"domwalker\",\n      \"methods\": [\n        {\n          \"name\": \"release\",\n          \"release\": true,\n          \"request\": {\n            \"type\": \"release\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"pick\",\n          \"request\": {\n            \"type\": \"pick\"\n          },\n          \"response\": {\n            \"_retval\": \"disconnectedNode\"\n          }\n        },\n        {\n          \"name\": \"cancelPick\",\n          \"request\": {\n            \"type\": \"cancelPick\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"highlight\",\n          \"request\": {\n            \"type\": \"highlight\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"document\",\n          \"request\": {\n            \"type\": \"document\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {\n            \"node\": {\n              \"_retval\": \"domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"documentElement\",\n          \"request\": {\n            \"type\": \"documentElement\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {\n            \"node\": {\n              \"_retval\": \"domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"parents\",\n          \"request\": {\n            \"type\": \"parents\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"sameDocument\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"nodes\": {\n              \"_retval\": \"array:domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"retainNode\",\n          \"request\": {\n            \"type\": \"retainNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"unretainNode\",\n          \"request\": {\n            \"type\": \"unretainNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"releaseNode\",\n          \"request\": {\n            \"type\": \"releaseNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"force\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"children\",\n          \"request\": {\n            \"type\": \"children\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"maxNodes\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            },\n            \"center\": {\n              \"_option\": 1,\n              \"type\": \"domnode\"\n            },\n            \"start\": {\n              \"_option\": 1,\n              \"type\": \"domnode\"\n            },\n            \"whatToShow\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"domtraversalarray\"\n          }\n        },\n        {\n          \"name\": \"siblings\",\n          \"request\": {\n            \"type\": \"siblings\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"maxNodes\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            },\n            \"center\": {\n              \"_option\": 1,\n              \"type\": \"domnode\"\n            },\n            \"start\": {\n              \"_option\": 1,\n              \"type\": \"domnode\"\n            },\n            \"whatToShow\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"domtraversalarray\"\n          }\n        },\n        {\n          \"name\": \"nextSibling\",\n          \"request\": {\n            \"type\": \"nextSibling\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"whatToShow\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"node\": {\n              \"_retval\": \"nullable:domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"previousSibling\",\n          \"request\": {\n            \"type\": \"previousSibling\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"whatToShow\": {\n              \"_option\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"node\": {\n              \"_retval\": \"nullable:domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"querySelector\",\n          \"request\": {\n            \"type\": \"querySelector\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"selector\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"disconnectedNode\"\n          }\n        },\n        {\n          \"name\": \"querySelectorAll\",\n          \"request\": {\n            \"type\": \"querySelectorAll\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"selector\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"list\": {\n              \"_retval\": \"domnodelist\"\n            }\n          }\n        },\n        {\n          \"name\": \"getSuggestionsForQuery\",\n          \"request\": {\n            \"type\": \"getSuggestionsForQuery\",\n            \"query\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"completing\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            },\n            \"selectorState\": {\n              \"_arg\": 2,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"list\": {\n              \"_retval\": \"array:array:string\"\n            }\n          }\n        },\n        {\n          \"name\": \"addPseudoClassLock\",\n          \"request\": {\n            \"type\": \"addPseudoClassLock\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"pseudoClass\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            },\n            \"parents\": {\n              \"_option\": 2,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"hideNode\",\n          \"request\": {\n            \"type\": \"hideNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"unhideNode\",\n          \"request\": {\n            \"type\": \"unhideNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"removePseudoClassLock\",\n          \"request\": {\n            \"type\": \"removePseudoClassLock\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"pseudoClass\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            },\n            \"parents\": {\n              \"_option\": 2,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"clearPseudoClassLocks\",\n          \"request\": {\n            \"type\": \"clearPseudoClassLocks\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"innerHTML\",\n          \"request\": {\n            \"type\": \"innerHTML\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"outerHTML\",\n          \"request\": {\n            \"type\": \"outerHTML\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"setOuterHTML\",\n          \"request\": {\n            \"type\": \"setOuterHTML\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"removeNode\",\n          \"request\": {\n            \"type\": \"removeNode\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {\n            \"nextSibling\": {\n              \"_retval\": \"nullable:domnode\"\n            }\n          }\n        },\n        {\n          \"name\": \"insertBefore\",\n          \"request\": {\n            \"type\": \"insertBefore\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            },\n            \"parent\": {\n              \"_arg\": 1,\n              \"type\": \"domnode\"\n            },\n            \"sibling\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:domnode\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"getMutations\",\n          \"request\": {\n            \"type\": \"getMutations\",\n            \"cleanup\": {\n              \"_option\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"mutations\": {\n              \"_retval\": \"array:dommutation\"\n            }\n          }\n        },\n        {\n          \"name\": \"isInDOMTree\",\n          \"request\": {\n            \"type\": \"isInDOMTree\",\n            \"node\": {\n              \"_arg\": 0,\n              \"type\": \"domnode\"\n            }\n          },\n          \"response\": {\n            \"attached\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"getNodeActorFromObjectActor\",\n          \"request\": {\n            \"type\": \"getNodeActorFromObjectActor\",\n            \"objectActorID\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"nodeFront\": {\n              \"_retval\": \"nullable:disconnectedNode\"\n            }\n          }\n        }\n      ],\n      \"events\": {\n        \"new-mutations\": {\n          \"type\": \"newMutations\"\n        },\n        \"picker-node-picked\": {\n          \"type\": \"pickerNodePicked\",\n          \"node\": {\n            \"_arg\": 0,\n            \"type\": \"disconnectedNode\"\n          }\n        },\n        \"picker-node-hovered\": {\n          \"type\": \"pickerNodeHovered\",\n          \"node\": {\n            \"_arg\": 0,\n            \"type\": \"disconnectedNode\"\n          }\n        },\n        \"highlighter-ready\": {\n          \"type\": \"highlighter-ready\"\n        },\n        \"highlighter-hide\": {\n          \"type\": \"highlighter-hide\"\n        }\n      }\n    },\n    \"inspector\": {\n      \"category\": \"actor\",\n      \"typeName\": \"inspector\",\n      \"methods\": [\n        {\n          \"name\": \"getWalker\",\n          \"request\": {\n            \"type\": \"getWalker\"\n          },\n          \"response\": {\n            \"walker\": {\n              \"_retval\": \"domwalker\"\n            }\n          }\n        },\n        {\n          \"name\": \"getPageStyle\",\n          \"request\": {\n            \"type\": \"getPageStyle\"\n          },\n          \"response\": {\n            \"pageStyle\": {\n              \"_retval\": \"pagestyle\"\n            }\n          }\n        },\n        {\n          \"name\": \"getHighlighter\",\n          \"request\": {\n            \"type\": \"getHighlighter\",\n            \"autohide\": {\n              \"_arg\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {\n            \"highligter\": {\n              \"_retval\": \"highlighter\"\n            }\n          }\n        },\n        {\n          \"name\": \"getImageDataFromURL\",\n          \"request\": {\n            \"type\": \"getImageDataFromURL\",\n            \"url\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"maxDim\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"imageData\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"call-stack-item\": {\n      \"category\": \"dict\",\n      \"typeName\": \"call-stack-item\",\n      \"specializations\": {\n        \"name\": \"string\",\n        \"file\": \"string\",\n        \"line\": \"number\"\n      }\n    },\n    \"call-details\": {\n      \"category\": \"dict\",\n      \"typeName\": \"call-details\",\n      \"specializations\": {\n        \"type\": \"number\",\n        \"name\": \"string\",\n        \"stack\": \"array:call-stack-item\"\n      }\n    },\n    \"function-call\": {\n      \"category\": \"actor\",\n      \"typeName\": \"function-call\",\n      \"methods\": [\n        {\n          \"name\": \"getDetails\",\n          \"request\": {\n            \"type\": \"getDetails\"\n          },\n          \"response\": {\n            \"info\": {\n              \"_retval\": \"call-details\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"call-watcher\": {\n      \"category\": \"actor\",\n      \"typeName\": \"call-watcher\",\n      \"methods\": [\n        {\n          \"name\": \"setup\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"setup\",\n            \"tracedGlobals\": {\n              \"_option\": 0,\n              \"type\": \"nullable:array:string\"\n            },\n            \"tracedFunctions\": {\n              \"_option\": 0,\n              \"type\": \"nullable:array:string\"\n            },\n            \"startRecording\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            },\n            \"performReload\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"finalize\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"finalize\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"isRecording\",\n          \"request\": {\n            \"type\": \"isRecording\"\n          },\n          \"response\": {\n            \"_retval\": \"boolean\"\n          }\n        },\n        {\n          \"name\": \"resumeRecording\",\n          \"request\": {\n            \"type\": \"resumeRecording\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"pauseRecording\",\n          \"request\": {\n            \"type\": \"pauseRecording\"\n          },\n          \"response\": {\n            \"calls\": {\n              \"_retval\": \"array:function-call\"\n            }\n          }\n        },\n        {\n          \"name\": \"eraseRecording\",\n          \"request\": {\n            \"type\": \"eraseRecording\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"snapshot-image\": {\n      \"category\": \"dict\",\n      \"typeName\": \"snapshot-image\",\n      \"specializations\": {\n        \"index\": \"number\",\n        \"width\": \"number\",\n        \"height\": \"number\",\n        \"flipped\": \"boolean\",\n        \"pixels\": \"uint32-array\"\n      }\n    },\n    \"snapshot-overview\": {\n      \"category\": \"dict\",\n      \"typeName\": \"snapshot-overview\",\n      \"specializations\": {\n        \"calls\": \"array:function-call\",\n        \"thumbnails\": \"array:snapshot-image\",\n        \"screenshot\": \"snapshot-image\"\n      }\n    },\n    \"frame-snapshot\": {\n      \"category\": \"actor\",\n      \"typeName\": \"frame-snapshot\",\n      \"methods\": [\n        {\n          \"name\": \"getOverview\",\n          \"request\": {\n            \"type\": \"getOverview\"\n          },\n          \"response\": {\n            \"overview\": {\n              \"_retval\": \"snapshot-overview\"\n            }\n          }\n        },\n        {\n          \"name\": \"generateScreenshotFor\",\n          \"request\": {\n            \"type\": \"generateScreenshotFor\",\n            \"call\": {\n              \"_arg\": 0,\n              \"type\": \"function-call\"\n            }\n          },\n          \"response\": {\n            \"screenshot\": {\n              \"_retval\": \"snapshot-image\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"canvas\": {\n      \"category\": \"actor\",\n      \"typeName\": \"canvas\",\n      \"methods\": [\n        {\n          \"name\": \"setup\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"setup\",\n            \"reload\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"finalize\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"finalize\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"isInitialized\",\n          \"request\": {\n            \"type\": \"isInitialized\"\n          },\n          \"response\": {\n            \"initialized\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"recordAnimationFrame\",\n          \"request\": {\n            \"type\": \"recordAnimationFrame\"\n          },\n          \"response\": {\n            \"snapshot\": {\n              \"_retval\": \"frame-snapshot\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"gl-shader\": {\n      \"category\": \"actor\",\n      \"typeName\": \"gl-shader\",\n      \"methods\": [\n        {\n          \"name\": \"getText\",\n          \"request\": {\n            \"type\": \"getText\"\n          },\n          \"response\": {\n            \"text\": {\n              \"_retval\": \"string\"\n            }\n          }\n        },\n        {\n          \"name\": \"compile\",\n          \"request\": {\n            \"type\": \"compile\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"error\": {\n              \"_retval\": \"nullable:json\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"gl-program\": {\n      \"category\": \"actor\",\n      \"typeName\": \"gl-program\",\n      \"methods\": [\n        {\n          \"name\": \"getVertexShader\",\n          \"request\": {\n            \"type\": \"getVertexShader\"\n          },\n          \"response\": {\n            \"shader\": {\n              \"_retval\": \"gl-shader\"\n            }\n          }\n        },\n        {\n          \"name\": \"getFragmentShader\",\n          \"request\": {\n            \"type\": \"getFragmentShader\"\n          },\n          \"response\": {\n            \"shader\": {\n              \"_retval\": \"gl-shader\"\n            }\n          }\n        },\n        {\n          \"name\": \"highlight\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"highlight\",\n            \"tint\": {\n              \"_arg\": 0,\n              \"type\": \"array:number\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"unhighlight\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"unhighlight\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"blackbox\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"blackbox\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"unblackbox\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"unblackbox\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"webgl\": {\n      \"category\": \"actor\",\n      \"typeName\": \"webgl\",\n      \"methods\": [\n        {\n          \"name\": \"setup\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"setup\",\n            \"reload\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"finalize\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"finalize\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"getPrograms\",\n          \"request\": {\n            \"type\": \"getPrograms\"\n          },\n          \"response\": {\n            \"programs\": {\n              \"_retval\": \"array:gl-program\"\n            }\n          }\n        }\n      ],\n      \"events\": {\n        \"program-linked\": {\n          \"type\": \"programLinked\",\n          \"program\": {\n            \"_arg\": 0,\n            \"type\": \"gl-program\"\n          }\n        }\n      }\n    },\n    \"audionode\": {\n      \"category\": \"actor\",\n      \"typeName\": \"audionode\",\n      \"methods\": [\n        {\n          \"name\": \"getType\",\n          \"request\": {\n            \"type\": \"getType\"\n          },\n          \"response\": {\n            \"type\": {\n              \"_retval\": \"string\"\n            }\n          }\n        },\n        {\n          \"name\": \"isSource\",\n          \"request\": {\n            \"type\": \"isSource\"\n          },\n          \"response\": {\n            \"source\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"setParam\",\n          \"request\": {\n            \"type\": \"setParam\",\n            \"param\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:primitive\"\n            }\n          },\n          \"response\": {\n            \"error\": {\n              \"_retval\": \"nullable:json\"\n            }\n          }\n        },\n        {\n          \"name\": \"getParam\",\n          \"request\": {\n            \"type\": \"getParam\",\n            \"param\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"text\": {\n              \"_retval\": \"nullable:primitive\"\n            }\n          }\n        },\n        {\n          \"name\": \"getParamFlags\",\n          \"request\": {\n            \"type\": \"getParamFlags\",\n            \"param\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"flags\": {\n              \"_retval\": \"nullable:primitive\"\n            }\n          }\n        },\n        {\n          \"name\": \"getParams\",\n          \"request\": {\n            \"type\": \"getParams\"\n          },\n          \"response\": {\n            \"params\": {\n              \"_retval\": \"json\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"webaudio\": {\n      \"category\": \"actor\",\n      \"typeName\": \"webaudio\",\n      \"methods\": [\n        {\n          \"name\": \"setup\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"setup\",\n            \"reload\": {\n              \"_option\": 0,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"finalize\",\n          \"oneway\": true,\n          \"request\": {\n            \"type\": \"finalize\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {\n        \"start-context\": {\n          \"type\": \"startContext\"\n        },\n        \"connect-node\": {\n          \"type\": \"connectNode\",\n          \"source\": {\n            \"_option\": 0,\n            \"type\": \"audionode\"\n          },\n          \"dest\": {\n            \"_option\": 0,\n            \"type\": \"audionode\"\n          }\n        },\n        \"disconnect-node\": {\n          \"type\": \"disconnectNode\",\n          \"source\": {\n            \"_arg\": 0,\n            \"type\": \"audionode\"\n          }\n        },\n        \"connect-param\": {\n          \"type\": \"connectParam\",\n          \"source\": {\n            \"_arg\": 0,\n            \"type\": \"audionode\"\n          },\n          \"param\": {\n            \"_arg\": 1,\n            \"type\": \"string\"\n          }\n        },\n        \"change-param\": {\n          \"type\": \"changeParam\",\n          \"source\": {\n            \"_option\": 0,\n            \"type\": \"audionode\"\n          },\n          \"param\": {\n            \"_option\": 0,\n            \"type\": \"string\"\n          },\n          \"value\": {\n            \"_option\": 0,\n            \"type\": \"string\"\n          }\n        },\n        \"create-node\": {\n          \"type\": \"createNode\",\n          \"source\": {\n            \"_arg\": 0,\n            \"type\": \"audionode\"\n          }\n        }\n      }\n    },\n    \"old-stylesheet\": {\n      \"category\": \"actor\",\n      \"typeName\": \"old-stylesheet\",\n      \"methods\": [\n        {\n          \"name\": \"toggleDisabled\",\n          \"request\": {\n            \"type\": \"toggleDisabled\"\n          },\n          \"response\": {\n            \"disabled\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"fetchSource\",\n          \"request\": {\n            \"type\": \"fetchSource\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"update\",\n          \"request\": {\n            \"type\": \"update\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"transition\": {\n              \"_arg\": 1,\n              \"type\": \"boolean\"\n            }\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {\n        \"property-change\": {\n          \"type\": \"propertyChange\",\n          \"property\": {\n            \"_arg\": 0,\n            \"type\": \"string\"\n          },\n          \"value\": {\n            \"_arg\": 1,\n            \"type\": \"json\"\n          }\n        },\n        \"source-load\": {\n          \"type\": \"sourceLoad\",\n          \"source\": {\n            \"_arg\": 0,\n            \"type\": \"string\"\n          }\n        },\n        \"style-applied\": {\n          \"type\": \"styleApplied\"\n        }\n      }\n    },\n    \"styleeditor\": {\n      \"category\": \"actor\",\n      \"typeName\": \"styleeditor\",\n      \"methods\": [\n        {\n          \"name\": \"newDocument\",\n          \"request\": {\n            \"type\": \"newDocument\"\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"newStyleSheet\",\n          \"request\": {\n            \"type\": \"newStyleSheet\",\n            \"text\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"styleSheet\": {\n              \"_retval\": \"old-stylesheet\"\n            }\n          }\n        }\n      ],\n      \"events\": {\n        \"document-load\": {\n          \"type\": \"documentLoad\",\n          \"styleSheets\": {\n            \"_arg\": 0,\n            \"type\": \"array:old-stylesheet\"\n          }\n        }\n      }\n    },\n    \"cookieobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"cookieobject\",\n      \"specializations\": {\n        \"name\": \"string\",\n        \"value\": \"longstring\",\n        \"path\": \"nullable:string\",\n        \"host\": \"string\",\n        \"isDomain\": \"boolean\",\n        \"isSecure\": \"boolean\",\n        \"isHttpOnly\": \"boolean\",\n        \"creationTime\": \"number\",\n        \"lastAccessed\": \"number\",\n        \"expires\": \"number\"\n      }\n    },\n    \"cookiestoreobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"cookiestoreobject\",\n      \"specializations\": {\n        \"total\": \"number\",\n        \"offset\": \"number\",\n        \"data\": \"array:nullable:cookieobject\"\n      }\n    },\n    \"storageobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"storageobject\",\n      \"specializations\": {\n        \"name\": \"string\",\n        \"value\": \"longstring\"\n      }\n    },\n    \"storagestoreobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"storagestoreobject\",\n      \"specializations\": {\n        \"total\": \"number\",\n        \"offset\": \"number\",\n        \"data\": \"array:nullable:storageobject\"\n      }\n    },\n    \"idbobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"idbobject\",\n      \"specializations\": {\n        \"name\": \"nullable:string\",\n        \"db\": \"nullable:string\",\n        \"objectStore\": \"nullable:string\",\n        \"origin\": \"nullable:string\",\n        \"version\": \"nullable:number\",\n        \"objectStores\": \"nullable:number\",\n        \"keyPath\": \"nullable:string\",\n        \"autoIncrement\": \"nullable:boolean\",\n        \"indexes\": \"nullable:string\",\n        \"value\": \"nullable:longstring\"\n      }\n    },\n    \"idbstoreobject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"idbstoreobject\",\n      \"specializations\": {\n        \"total\": \"number\",\n        \"offset\": \"number\",\n        \"data\": \"array:nullable:idbobject\"\n      }\n    },\n    \"storeUpdateObject\": {\n      \"category\": \"dict\",\n      \"typeName\": \"storeUpdateObject\",\n      \"specializations\": {\n        \"changed\": \"nullable:json\",\n        \"deleted\": \"nullable:json\",\n        \"added\": \"nullable:json\"\n      }\n    },\n    \"cookies\": {\n      \"category\": \"actor\",\n      \"typeName\": \"cookies\",\n      \"methods\": [\n        {\n          \"name\": \"getStoreObjects\",\n          \"request\": {\n            \"type\": \"getStoreObjects\",\n            \"host\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"names\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:array:string\"\n            },\n            \"options\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:json\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"cookiestoreobject\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"localStorage\": {\n      \"category\": \"actor\",\n      \"typeName\": \"localStorage\",\n      \"methods\": [\n        {\n          \"name\": \"getStoreObjects\",\n          \"request\": {\n            \"type\": \"getStoreObjects\",\n            \"host\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"names\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:array:string\"\n            },\n            \"options\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:json\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"storagestoreobject\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"sessionStorage\": {\n      \"category\": \"actor\",\n      \"typeName\": \"sessionStorage\",\n      \"methods\": [\n        {\n          \"name\": \"getStoreObjects\",\n          \"request\": {\n            \"type\": \"getStoreObjects\",\n            \"host\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"names\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:array:string\"\n            },\n            \"options\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:json\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"storagestoreobject\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"indexedDB\": {\n      \"category\": \"actor\",\n      \"typeName\": \"indexedDB\",\n      \"methods\": [\n        {\n          \"name\": \"getStoreObjects\",\n          \"request\": {\n            \"type\": \"getStoreObjects\",\n            \"host\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"names\": {\n              \"_arg\": 1,\n              \"type\": \"nullable:array:string\"\n            },\n            \"options\": {\n              \"_arg\": 2,\n              \"type\": \"nullable:json\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"idbstoreobject\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"storelist\": {\n      \"category\": \"dict\",\n      \"typeName\": \"storelist\",\n      \"specializations\": {\n        \"cookies\": \"cookies\",\n        \"localStorage\": \"localStorage\",\n        \"sessionStorage\": \"sessionStorage\",\n        \"indexedDB\": \"indexedDB\"\n      }\n    },\n    \"storage\": {\n      \"category\": \"actor\",\n      \"typeName\": \"storage\",\n      \"methods\": [\n        {\n          \"name\": \"listStores\",\n          \"request\": {\n            \"type\": \"listStores\"\n          },\n          \"response\": {\n            \"_retval\": \"storelist\"\n          }\n        }\n      ],\n      \"events\": {\n        \"stores-update\": {\n          \"type\": \"storesUpdate\",\n          \"data\": {\n            \"_arg\": 0,\n            \"type\": \"storeUpdateObject\"\n          }\n        },\n        \"stores-cleared\": {\n          \"type\": \"storesCleared\",\n          \"data\": {\n            \"_arg\": 0,\n            \"type\": \"json\"\n          }\n        },\n        \"stores-reloaded\": {\n          \"type\": \"storesRelaoded\",\n          \"data\": {\n            \"_arg\": 0,\n            \"type\": \"json\"\n          }\n        }\n      }\n    },\n    \"gcli\": {\n      \"category\": \"actor\",\n      \"typeName\": \"gcli\",\n      \"methods\": [\n        {\n          \"name\": \"specs\",\n          \"request\": {\n            \"type\": \"specs\"\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        },\n        {\n          \"name\": \"execute\",\n          \"request\": {\n            \"type\": \"execute\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        },\n        {\n          \"name\": \"state\",\n          \"request\": {\n            \"type\": \"state\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"start\": {\n              \"_arg\": 1,\n              \"type\": \"number\"\n            },\n            \"rank\": {\n              \"_arg\": 2,\n              \"type\": \"number\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        },\n        {\n          \"name\": \"typeparse\",\n          \"request\": {\n            \"type\": \"typeparse\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"param\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        },\n        {\n          \"name\": \"typeincrement\",\n          \"request\": {\n            \"type\": \"typeincrement\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"param\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"string\"\n          }\n        },\n        {\n          \"name\": \"typedecrement\",\n          \"request\": {\n            \"type\": \"typedecrement\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"param\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"string\"\n          }\n        },\n        {\n          \"name\": \"selectioninfo\",\n          \"request\": {\n            \"type\": \"selectioninfo\",\n            \"typed\": {\n              \"_arg\": 0,\n              \"type\": \"string\"\n            },\n            \"param\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            },\n            \"action\": {\n              \"_arg\": 1,\n              \"type\": \"string\"\n            }\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"memory\": {\n      \"category\": \"actor\",\n      \"typeName\": \"memory\",\n      \"methods\": [\n        {\n          \"name\": \"measure\",\n          \"request\": {\n            \"type\": \"measure\"\n          },\n          \"response\": {\n            \"_retval\": \"json\"\n          }\n        }\n      ],\n      \"events\": {}\n    },\n    \"eventLoopLag\": {\n      \"category\": \"actor\",\n      \"typeName\": \"eventLoopLag\",\n      \"methods\": [\n        {\n          \"name\": \"start\",\n          \"request\": {\n            \"type\": \"start\"\n          },\n          \"response\": {\n            \"success\": {\n              \"_retval\": \"number\"\n            }\n          }\n        },\n        {\n          \"name\": \"stop\",\n          \"request\": {\n            \"type\": \"stop\"\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {\n        \"event-loop-lag\": {\n          \"type\": \"event-loop-lag\",\n          \"time\": {\n            \"_arg\": 0,\n            \"type\": \"number\"\n          }\n        }\n      }\n    },\n    \"preference\": {\n      \"category\": \"actor\",\n      \"typeName\": \"preference\",\n      \"methods\": [\n        {\n          \"name\": \"getBoolPref\",\n          \"request\": {\n            \"type\": \"getBoolPref\",\n            \"value\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"boolean\"\n            }\n          }\n        },\n        {\n          \"name\": \"getCharPref\",\n          \"request\": {\n            \"type\": \"getCharPref\",\n            \"value\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"string\"\n            }\n          }\n        },\n        {\n          \"name\": \"getIntPref\",\n          \"request\": {\n            \"type\": \"getIntPref\",\n            \"value\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"number\"\n            }\n          }\n        },\n        {\n          \"name\": \"getAllPrefs\",\n          \"request\": {\n            \"type\": \"getAllPrefs\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"json\"\n            }\n          }\n        },\n        {\n          \"name\": \"setBoolPref\",\n          \"request\": {\n            \"type\": \"setBoolPref\",\n            \"name\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"setCharPref\",\n          \"request\": {\n            \"type\": \"setCharPref\",\n            \"name\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"setIntPref\",\n          \"request\": {\n            \"type\": \"setIntPref\",\n            \"name\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            },\n            \"value\": {\n              \"_arg\": 1,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        },\n        {\n          \"name\": \"clearUserPref\",\n          \"request\": {\n            \"type\": \"clearUserPref\",\n            \"name\": {\n              \"_arg\": 0,\n              \"type\": \"primitive\"\n            }\n          },\n          \"response\": {}\n        }\n      ],\n      \"events\": {}\n    },\n    \"device\": {\n      \"category\": \"actor\",\n      \"typeName\": \"device\",\n      \"methods\": [\n        {\n          \"name\": \"getDescription\",\n          \"request\": {\n            \"type\": \"getDescription\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"json\"\n            }\n          }\n        },\n        {\n          \"name\": \"getWallpaper\",\n          \"request\": {\n            \"type\": \"getWallpaper\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"screenshotToDataURL\",\n          \"request\": {\n            \"type\": \"screenshotToDataURL\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"longstring\"\n            }\n          }\n        },\n        {\n          \"name\": \"getRawPermissionsTable\",\n          \"request\": {\n            \"type\": \"getRawPermissionsTable\"\n          },\n          \"response\": {\n            \"value\": {\n              \"_retval\": \"json\"\n            }\n          }\n        }\n      ],\n      \"events\": {}\n    }\n  },\n  \"from\": \"root\"\n}\n","\"use strict\";\n\nvar Class = require(\"./class\").Class;\nvar util = require(\"./util\");\nvar keys = util.keys;\nvar values = util.values;\nvar pairs = util.pairs;\nvar query = util.query;\nvar findPath = util.findPath;\nvar EventTarget = require(\"./event\").EventTarget;\n\nvar TypeSystem = Class({\n  constructor: function(client) {\n    var types = Object.create(null);\n    var specification = Object.create(null);\n\n    this.specification = specification;\n    this.types = types;\n\n    var typeFor = function typeFor(typeName) {\n      typeName = typeName || \"primitive\";\n      if (!types[typeName]) {\n        defineType(typeName);\n      }\n\n      return types[typeName];\n    };\n    this.typeFor = typeFor;\n\n    var defineType = function(descriptor) {\n      var type = void(0);\n      if (typeof(descriptor) === \"string\") {\n        if (descriptor.indexOf(\":\") > 0)\n          type = makeCompoundType(descriptor);\n        else if (descriptor.indexOf(\"#\") > 0)\n          type = new ActorDetail(descriptor);\n          else if (specification[descriptor])\n            type = makeCategoryType(specification[descriptor]);\n      } else {\n        type = makeCategoryType(descriptor);\n      }\n\n      if (type)\n        types[type.name] = type;\n      else\n        throw TypeError(\"Invalid type: \" + descriptor);\n    };\n    this.defineType = defineType;\n\n\n    var makeCompoundType = function(name) {\n      var index = name.indexOf(\":\");\n      var baseType = name.slice(0, index);\n      var subType = name.slice(index + 1);\n\n      return baseType === \"array\" ? new ArrayOf(subType) :\n      baseType === \"nullable\" ? new Maybe(subType) :\n      null;\n    };\n\n    var makeCategoryType = function(descriptor) {\n      var category = descriptor.category;\n      return category === \"dict\" ? new Dictionary(descriptor) :\n      category === \"actor\" ? new Actor(descriptor) :\n      null;\n    };\n\n    var read = function(input, context, typeName) {\n      return typeFor(typeName).read(input, context);\n    }\n    this.read = read;\n\n    var write = function(input, context, typeName) {\n      return typeFor(typeName).write(input);\n    };\n    this.write = write;\n\n\n    var Type = Class({\n      constructor: function() {\n      },\n      get name() {\n        return this.category ? this.category + \":\" + this.type :\n        this.type;\n      },\n      read: function(input, context) {\n        throw new TypeError(\"`Type` subclass must implement `read`\");\n      },\n      write: function(input, context) {\n        throw new TypeError(\"`Type` subclass must implement `write`\");\n      }\n    });\n\n    var Primitve = Class({\n      extends: Type,\n      constuctor: function(type) {\n        this.type = type;\n      },\n      read: function(input, context) {\n        return input;\n      },\n      write: function(input, context) {\n        return input;\n      }\n    });\n\n    var Maybe = Class({\n      extends: Type,\n      category: \"nullable\",\n      constructor: function(type) {\n        this.type = type;\n      },\n      read: function(input, context) {\n        return input === null ? null :\n        input === void(0) ? void(0) :\n        read(input, context, this.type);\n      },\n      write: function(input, context) {\n        return input === null ? null :\n        input === void(0) ? void(0) :\n        write(input, context, this.type);\n      }\n    });\n\n    var ArrayOf = Class({\n      extends: Type,\n      category: \"array\",\n      constructor: function(type) {\n        this.type = type;\n      },\n      read: function(input, context) {\n        var type = this.type;\n        return input.map(function($) { return read($, context, type) });\n      },\n      write: function(input, context) {\n        var type = this.type;\n        return input.map(function($) { return write($, context, type) });\n      }\n    });\n\n    var makeField = function makeField(name, type) {\n      return {\n        enumerable: true,\n        configurable: true,\n        get: function() {\n          Object.defineProperty(this, name, {\n            configurable: false,\n            value: read(this.state[name], this.context, type)\n          });\n          return this[name];\n        }\n      }\n    };\n\n    var makeFields = function(descriptor) {\n      return pairs(descriptor).reduce(function(fields, pair) {\n        var name = pair[0], type = pair[1];\n        fields[name] = makeField(name, type);\n        return fields;\n      }, {});\n    }\n\n    var DictionaryType = Class({});\n\n    var Dictionary = Class({\n      extends: Type,\n      category: \"dict\",\n      get name() { return this.type; },\n      constructor: function(descriptor) {\n        this.type = descriptor.typeName;\n        this.types = descriptor.specializations;\n\n        var proto = Object.defineProperties({\n          extends: DictionaryType,\n          constructor: function(state, context) {\n            Object.defineProperties(this, {\n              state: {\n                enumerable: false,\n                writable: true,\n                configurable: true,\n                value: state\n              },\n              context: {\n                enumerable: false,\n                writable: false,\n                configurable: true,\n                value: context\n              }\n            });\n          }\n        }, makeFields(this.types));\n\n        this.class = new Class(proto);\n      },\n      read: function(input, context) {\n        return new this.class(input, context);\n      },\n      write: function(input, context) {\n        var output = {};\n        for (var key in input) {\n          output[key] = write(value, context, types[key]);\n        }\n        return output;\n      }\n    });\n\n    var makeMethods = function(descriptors) {\n      return descriptors.reduce(function(methods, descriptor) {\n        methods[descriptor.name] = {\n          enumerable: true,\n          configurable: true,\n          writable: false,\n          value: makeMethod(descriptor)\n        };\n        return methods;\n      }, {});\n    };\n\n    var makeEvents = function(descriptors) {\n      return pairs(descriptors).reduce(function(events, pair) {\n        var name = pair[0], descriptor = pair[1];\n        var event = new Event(name, descriptor);\n        events[event.eventType] = event;\n        return events;\n      }, Object.create(null));\n    };\n\n    var Actor = Class({\n      extends: Type,\n      category: \"actor\",\n      get name() { return this.type; },\n      constructor: function(descriptor) {\n        this.type = descriptor.typeName;\n\n        var events = makeEvents(descriptor.events || {});\n        var fields = makeFields(descriptor.fields || {});\n        var methods = makeMethods(descriptor.methods || []);\n\n\n        var proto = {\n          extends: Front,\n          constructor: function() {\n            Front.apply(this, arguments);\n          },\n          events: events\n        };\n        Object.defineProperties(proto, fields);\n        Object.defineProperties(proto, methods);\n\n        this.class = Class(proto);\n      },\n      read: function(input, context, detail) {\n        var state = typeof(input) === \"string\" ? { actor: input } : input;\n\n        var actor = client.get(state.actor) || new this.class(state, context);\n        actor.form(state, detail, context);\n\n        return actor;\n      },\n      write: function(input, context, detail) {\n        return input.id;\n      }\n    });\n    exports.Actor = Actor;\n\n\n    var ActorDetail = Class({\n      extends: Actor,\n      constructor: function(name) {\n        var parts = name.split(\"#\")\n        this.actorType = parts[0]\n        this.detail = parts[1];\n      },\n      read: function(input, context) {\n        return typeFor(this.actorType).read(input, context, this.detail);\n      },\n      write: function(input, context) {\n        return typeFor(this.actorType).write(input, context, this.detail);\n      }\n    });\n    exports.ActorDetail = ActorDetail;\n\n    var Method = Class({\n      extends: Type,\n      constructor: function(descriptor) {\n        this.type = descriptor.name;\n        this.path = findPath(descriptor.response, \"_retval\");\n        this.responseType = this.path && query(descriptor.response, this.path)._retval;\n        this.requestType = descriptor.request.type;\n\n        var params = [];\n        for (var key in descriptor.request) {\n          if (key !== \"type\") {\n            var param = descriptor.request[key];\n            var index = \"_arg\" in param ? param._arg : param._option;\n            var isParam = param._option === index;\n            var isArgument = param._arg === index;\n            params[index] = {\n              type: param.type,\n              key: key,\n              index: index,\n              isParam: isParam,\n              isArgument: isArgument\n            };\n          }\n        }\n        this.params = params;\n      },\n      read: function(input, context) {\n        return read(query(input, this.path), context, this.responseType);\n      },\n      write: function(input, context) {\n        return this.params.reduce(function(result, param) {\n          result[param.key] = write(input[param.index], context, param.type);\n          return result;\n        }, {type: this.type});\n      }\n    });\n    exports.Method = Method;\n\n    var profiler = function(method, id) {\n      return function() {\n        var start = new Date();\n        return method.apply(this, arguments).then(function(result) {\n          var end = new Date();\n          client.telemetry.add(id, +end - start);\n          return result;\n        });\n      };\n    };\n\n    var destructor = function(method) {\n      return function() {\n        return method.apply(this, arguments).then(function(result) {\n          client.release(this);\n          return result;\n        });\n      };\n    };\n\n    function makeMethod(descriptor) {\n      var type = new Method(descriptor);\n      var method = descriptor.oneway ? makeUnidirecationalMethod(descriptor, type) :\n                   makeBidirectionalMethod(descriptor, type);\n\n      if (descriptor.telemetry)\n        method = profiler(method);\n      if (descriptor.release)\n        method = destructor(method);\n\n      return method;\n    }\n\n    var makeUnidirecationalMethod = function(descriptor, type) {\n      return function() {\n        var packet = type.write(arguments, this);\n        packet.to = this.id;\n        client.send(packet);\n        return Promise.resolve(void(0));\n      };\n    };\n\n    var makeBidirectionalMethod = function(descriptor, type) {\n      return function() {\n        var context = this.context;\n        var packet = type.write(arguments, context);\n        var context = this.context;\n        packet.to = this.id;\n        return client.request(packet).then(function(packet) {\n          return type.read(packet, context);\n        });\n      };\n    };\n\n    var Event = Class({\n      constructor: function(name, descriptor) {\n        this.name = descriptor.type || name;\n        this.eventType = descriptor.type || name;\n        this.types = Object.create(null);\n\n        var types = this.types;\n        for (var key in descriptor) {\n          if (key === \"type\") {\n            types[key] = \"string\";\n          } else {\n            types[key] = descriptor[key].type;\n          }\n        }\n      },\n      read: function(input, context) {\n        var output = {};\n        var types = this.types;\n        for (var key in input) {\n          output[key] = read(input[key], context, types[key]);\n        }\n        return output;\n      },\n      write: function(input, context) {\n        var output = {};\n        var types = this.types;\n        for (var key in this.types) {\n          output[key] = write(input[key], context, types[key]);\n        }\n        return output;\n      }\n    });\n\n    var Front = Class({\n      extends: EventTarget,\n      EventTarget: EventTarget,\n      constructor: function(state) {\n        this.EventTarget();\n        Object.defineProperties(this,  {\n          state: {\n            enumerable: false,\n            writable: true,\n            configurable: true,\n            value: state\n          }\n        });\n\n        client.register(this);\n      },\n      get id() {\n        return this.state.actor;\n      },\n      get context() {\n        return this;\n      },\n      form: function(state, detail, context) {\n        if (this.state !== state) {\n          if (detail) {\n            this.state[detail] = state[detail];\n          } else {\n            pairs(state).forEach(function(pair) {\n              var key = pair[0], value = pair[1];\n              this.state[key] = value;\n            }, this);\n          }\n        }\n\n        if (context) {\n          client.supervise(context, this);\n        }\n      },\n      requestTypes: function() {\n        return client.request({\n          to: this.id,\n          type: \"requestTypes\"\n        }).then(function(packet) {\n          return packet.requestTypes;\n        });\n      }\n    });\n    types.primitive = new Primitve(\"primitive\");\n    types.string = new Primitve(\"string\");\n    types.number = new Primitve(\"number\");\n    types.boolean = new Primitve(\"boolean\");\n    types.json = new Primitve(\"json\");\n    types.array = new Primitve(\"array\");\n  },\n  registerTypes: function(descriptor) {\n    var specification = this.specification;\n    values(descriptor.types).forEach(function(descriptor) {\n      specification[descriptor.typeName] = descriptor;\n    });\n  }\n});\nexports.TypeSystem = TypeSystem;\n","\"use strict\";\n\nvar keys = Object.keys;\nexports.keys = keys;\n\n// Returns array of values for the given object.\nvar values = function(object) {\n  return keys(object).map(function(key) {\n    return object[key]\n  });\n};\nexports.values = values;\n\n// Returns [key, value] pairs for the given object.\nvar pairs = function(object) {\n  return keys(object).map(function(key) {\n    return [key, object[key]]\n  });\n};\nexports.pairs = pairs;\n\n\n// Queries an object for the field nested with in it.\nvar query = function(object, path) {\n  return path.reduce(function(object, entry) {\n    return object && object[entry]\n  }, object);\n};\nexports.query = query;\n\nvar isObject = function(x) {\n  return x && typeof(x) === \"object\"\n}\n\nvar findPath = function(object, key) {\n  var path = void(0);\n  if (object && typeof(object) === \"object\") {\n    var names = keys(object);\n    if (names.indexOf(key) >= 0) {\n      path = [];\n    } else {\n      var index = 0;\n      var count = names.length;\n      while (index < count && !path){\n        var head = names[index];\n        var tail = findPath(object[head], key);\n        path = tail ? [head].concat(tail) : tail;\n        index = index + 1\n      }\n    }\n  }\n  return path;\n};\nexports.findPath = findPath;\n"]}
+(1)
+});
diff --git a/toolkit/jetpack/diffpatcher/.travis.yml b/toolkit/jetpack/diffpatcher/.travis.yml
new file mode 100644
index 000000000..780731a47
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/.travis.yml
@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 0.4
+  - 0.5
+  - 0.6
diff --git a/toolkit/jetpack/diffpatcher/History.md b/toolkit/jetpack/diffpatcher/History.md
new file mode 100644
index 000000000..d38978805
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/History.md
@@ -0,0 +1,14 @@
+# Changes
+
+## 1.0.1 / 2013-05-01
+
+  - Update method library version.
+
+## 1.0.0 / 2012-11-09
+
+  - Test integration for browsers.
+  - New method library.
+
+## 0.0.1 / 2012-10-22
+
+  - Initial release
diff --git a/toolkit/jetpack/diffpatcher/License.md b/toolkit/jetpack/diffpatcher/License.md
new file mode 100644
index 000000000..ed76489a3
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/License.md
@@ -0,0 +1,18 @@
+Copyright 2012 Irakli Gozalishvili. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
diff --git a/toolkit/jetpack/diffpatcher/Readme.md b/toolkit/jetpack/diffpatcher/Readme.md
new file mode 100644
index 000000000..1520b1c37
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/Readme.md
@@ -0,0 +1,70 @@
+# diffpatcher
+
+[![Build Status](https://secure.travis-ci.org/Gozala/diffpatcher.png)](http://travis-ci.org/Gozala/diffpatcher)
+
+[![Browser support](https://ci.testling.com/Gozala/diffpatcher.png)](http://ci.testling.com/Gozala/diffpatcher)
+
+Diffpatcher is a small library that lets you treat hashes as if they were
+git repositories.
+
+## diff
+
+Diff function that takes two hashes and returns delta hash.
+
+```js
+var diff = require("diffpatcher/diff")
+
+diff({ a: { b: 1 }, c: { d: 2 } },      // hash#1
+     { a: { e: 3 }, c: { d: 4 } })      // hash#2
+
+// => {                                 // delta
+//      a: {
+//        b: null,        // -
+//        e: 3            // +
+//      },
+//      c: {
+//        d: 4            // ±
+//      }
+//    }
+```
+
+As you can see from the example above `delta` makes no real distinction between
+proprety upadate and property addition. Try to think of additions as an update
+from `undefined` to whatever it's being updated to.
+
+## patch
+
+Patch fuction takes a `hash` and a `delta` and returns a new `hash` which is
+just like orginial but with delta applied to it. Let's apply delta from the
+previous example to the first hash from the same example
+
+
+```js
+var patch = require("diffpatcher/patch")
+
+patch({ a: { b: 1 }, c: { d: 2 } },     // hash#1
+      {                                 // delta
+        a: {
+          b: null,        // -
+          e: 3            // +
+        },
+        c: {
+          d: 4            // ±
+        }
+      })
+
+// => { a: { e: 3 }, c: { d: 4 } }      // hash#2
+```
+
+That's about it really, just diffing hashes and applying thes diffs on them.
+
+
+### rebase
+
+And as Linus mentioned everything in git can be expressed with `rebase`, that
+also pretty much the case for `diffpatcher`. `rebase` takes `target` hash,
+and rebases `parent` onto it with `diff` applied.
+
+## Install
+
+    npm install diffpatcher
diff --git a/toolkit/jetpack/diffpatcher/diff.js b/toolkit/jetpack/diffpatcher/diff.js
new file mode 100644
index 000000000..967c137e6
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/diff.js
@@ -0,0 +1,45 @@
+"use strict";
+
+var method = require("../method/core")
+
+// Method is designed to work with data structures representing application
+// state. Calling it with a state should return object representing `delta`
+// that has being applied to a previous state to get to a current state.
+//
+// Example
+//
+// diff(state) // => { "item-id-1": { title: "some title" } "item-id-2": null }
+var diff = method("diff@diffpatcher")
+
+// diff between `null` / `undefined` to any hash is a hash itself.
+diff.define(null, function(from, to) { return to })
+diff.define(undefined, function(from, to) { return to })
+diff.define(Object, function(from, to) {
+  return calculate(from, to || {}) || {}
+})
+
+function calculate(from, to) {
+  var diff = {}
+  var changes = 0
+  Object.keys(from).forEach(function(key) {
+    changes = changes + 1
+    if (!(key in to) && from[key] != null) diff[key] = null
+    else changes = changes - 1
+  })
+  Object.keys(to).forEach(function(key) {
+    changes = changes + 1
+    var previous = from[key]
+    var current = to[key]
+    if (previous === current) return (changes = changes - 1)
+    if (typeof(current) !== "object") return diff[key] = current
+    if (typeof(previous) !== "object") return diff[key] = current
+    var delta = calculate(previous, current)
+    if (delta) diff[key] = delta
+    else changes = changes - 1
+  })
+  return changes ? diff : null
+}
+
+diff.calculate = calculate
+
+module.exports = diff
diff --git a/toolkit/jetpack/diffpatcher/index.js b/toolkit/jetpack/diffpatcher/index.js
new file mode 100644
index 000000000..91ddba425
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/index.js
@@ -0,0 +1,5 @@
+"use strict";
+
+exports.diff = require("./diff")
+exports.patch = require("./patch")
+exports.rebase = require("./rebase")
diff --git a/toolkit/jetpack/diffpatcher/package.json b/toolkit/jetpack/diffpatcher/package.json
new file mode 100644
index 000000000..54e085d2e
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/package.json
@@ -0,0 +1,54 @@
+{
+  "name": "diffpatcher",
+  "id": "diffpatcher",
+  "version": "1.2.0",
+  "description": "Utilities for diff-ing & patch-ing hashes",
+  "keywords": [
+    "diff", "patch", "rebase", "hash", "changes", "versions"
+  ],
+  "author": "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)",
+  "homepage": "https://github.com/Gozala/diffpatcher",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gozala/diffpatcher.git",
+    "web": "https://github.com/Gozala/diffpatcher"
+  },
+  "bugs": {
+    "url": "http://github.com/Gozala/diffpatcher/issues/"
+  },
+  "dependencies": {
+    "method": "~2.0.0"
+  },
+  "devDependencies": {
+    "test": "~0.x.0",
+    "phantomify": "~0.x.0",
+    "retape": "~0.x.0",
+    "tape": "~0.1.5"
+  },
+  "main": "./index.js",
+  "scripts": {
+    "test": "npm run test-node && npm run test-browser",
+    "test-browser": "node ./node_modules/phantomify/bin/cmd.js ./test/common.js",
+    "test-node": "node ./test/common.js",
+    "test-tap": "node ./test/tap.js"
+  },
+  "testling": {
+    "files": "test/tap.js",
+    "browsers": [
+      "ie/9..latest",
+      "chrome/25..latest",
+      "firefox/20..latest",
+      "safari/6..latest",
+      "opera/11.0..latest",
+      "iphone/6..latest",
+      "ipad/6..latest",
+      "android-browser/4.2..latest"
+    ]
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/Gozala/diffpatcher/License.md"
+    }
+  ]
+}
diff --git a/toolkit/jetpack/diffpatcher/patch.js b/toolkit/jetpack/diffpatcher/patch.js
new file mode 100644
index 000000000..9271e8893
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/patch.js
@@ -0,0 +1,21 @@
+"use strict";
+
+var method = require("../method/core")
+var rebase = require("./rebase")
+
+// Method is designed to work with data structures representing application
+// state. Calling it with a state and delta should return object representing
+// new state, with changes in `delta` being applied to previous.
+//
+// ## Example
+//
+// patch(state, {
+//   "item-id-1": { completed: false }, // update
+//   "item-id-2": null                  // delete
+// })
+var patch = method("patch@diffpatcher")
+patch.define(Object, function patch(hash, delta) {
+  return rebase({}, hash, delta)
+})
+
+module.exports = patch
diff --git a/toolkit/jetpack/diffpatcher/rebase.js b/toolkit/jetpack/diffpatcher/rebase.js
new file mode 100644
index 000000000..03c756fee
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/rebase.js
@@ -0,0 +1,36 @@
+"use strict";
+
+var nil = {}
+var owns = ({}).hasOwnProperty
+
+function rebase(result, parent, delta) {
+  var key, current, previous, update
+  for (key in parent) {
+    if (owns.call(parent, key)) {
+      previous = parent[key]
+      update = owns.call(delta, key) ? delta[key] : nil
+      if (previous === null) continue
+      else if (previous === void(0)) continue
+      else if (update === null) continue
+      else if (update === void(0)) continue
+      else result[key] = previous
+    }
+  }
+  for (key in delta) {
+    if (owns.call(delta, key)) {
+      update = delta[key]
+      current = owns.call(result, key) ? result[key] : nil
+      if (current === update) continue
+      else if (update === null) continue
+      else if (update === void(0)) continue
+      else if (current === nil) result[key] = update
+      else if (typeof(update) !== "object") result[key] = update
+      else if (typeof(current) !== "object") result[key] = update
+      else result[key]= rebase({}, current, update)
+    }
+  }
+
+  return result
+}
+
+module.exports = rebase
diff --git a/toolkit/jetpack/diffpatcher/test/common.js b/toolkit/jetpack/diffpatcher/test/common.js
new file mode 100644
index 000000000..dbc79013c
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/test/common.js
@@ -0,0 +1,3 @@
+"use strict";
+
+require("test").run(require("./index"))
diff --git a/toolkit/jetpack/diffpatcher/test/diff.js b/toolkit/jetpack/diffpatcher/test/diff.js
new file mode 100644
index 000000000..d1d674005
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/test/diff.js
@@ -0,0 +1,59 @@
+"use strict";
+
+var diff = require("../diff")
+
+exports["test diff from null"] = function(assert) {
+  var to = { a: 1, b: 2 }
+  assert.equal(diff(null, to), to, "diff null to x returns x")
+  assert.equal(diff(void(0), to), to, "diff undefined to x returns x")
+
+}
+
+exports["test diff to null"] = function(assert) {
+  var from = { a: 1, b: 2 }
+  assert.deepEqual(diff({ a: 1, b: 2 }, null),
+                   { a: null, b: null },
+                   "diff x null returns x with all properties nullified")
+}
+
+exports["test diff identical"] = function(assert) {
+  assert.deepEqual(diff({}, {}), {}, "diff on empty objects is {}")
+
+  assert.deepEqual(diff({ a: 1, b: 2 }, { a: 1, b: 2 }), {},
+                   "if properties match diff is {}")
+
+  assert.deepEqual(diff({ a: 1, b: { c: { d: 3, e: 4 } } },
+                        { a: 1, b: { c: { d: 3, e: 4 } } }), {},
+                   "diff between identical nested hashes is {}")
+
+}
+
+exports["test diff delete"] = function(assert) {
+  assert.deepEqual(diff({ a: 1, b: 2 }, { b: 2 }), { a: null },
+                   "missing property is deleted")
+  assert.deepEqual(diff({ a: 1, b: 2 }, { a: 2 }), { a: 2, b: null },
+                   "missing property is deleted another updated")
+  assert.deepEqual(diff({ a: 1, b: 2 }, {}), { a: null, b: null },
+                   "missing propertes are deleted")
+  assert.deepEqual(diff({ a: 1, b: { c: { d: 2 } } }, {}),
+                   { a: null, b: null },
+                   "missing deep propertes are deleted")
+  assert.deepEqual(diff({ a: 1, b: { c: { d: 2 } } }, { b: { c: {} } }),
+                   { a: null, b: { c: { d: null } } },
+                   "missing nested propertes are deleted")
+}
+
+exports["test add update"] = function(assert) {
+  assert.deepEqual(diff({ a: 1, b: 2 }, { b: 2, c: 3 }), { a: null, c: 3 },
+                   "delete and add")
+  assert.deepEqual(diff({ a: 1, b: 2 }, { a: 2, c: 3 }), { a: 2, b: null, c: 3 },
+                   "delete and adds")
+  assert.deepEqual(diff({}, { a: 1, b: 2 }), { a: 1, b: 2 },
+                   "diff on empty objcet returns equivalen of to")
+  assert.deepEqual(diff({ a: 1, b: { c: { d: 2 } } }, { d: 3 }),
+                   { a: null, b: null, d: 3 },
+                   "missing deep propertes are deleted")
+  assert.deepEqual(diff({ b: { c: {} }, d: null }, { a: 1, b: { c: { d: 2 } } }),
+                   { a: 1, b: { c: { d: 2 } } },
+                   "missing nested propertes are deleted")
+}
diff --git a/toolkit/jetpack/diffpatcher/test/index.js b/toolkit/jetpack/diffpatcher/test/index.js
new file mode 100644
index 000000000..c06407e7c
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/test/index.js
@@ -0,0 +1,14 @@
+"use strict";
+
+var diff = require("../diff")
+var patch = require("../patch")
+
+exports["test diff"] = require("./diff")
+exports["test patch"] = require("./patch")
+
+exports["test patch(a, diff(a, b)) => b"] = function(assert) {
+  var a = { a: { b: 1 }, c: { d: 2 } }
+  var b = { a: { e: 3 }, c: { d: 4 } }
+
+  assert.deepEqual(patch(a, diff(a, b)), b, "patch(a, diff(a, b)) => b")
+}
diff --git a/toolkit/jetpack/diffpatcher/test/patch.js b/toolkit/jetpack/diffpatcher/test/patch.js
new file mode 100644
index 000000000..dc2e38229
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/test/patch.js
@@ -0,0 +1,83 @@
+"use strict";
+
+var patch = require("../patch")
+
+exports["test patch delete"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, { a: null }), { b: 2 }, "null removes property")
+}
+
+exports["test patch delete with void"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, { a: void(0) }), { b: 2 },
+                   "void(0) removes property")
+}
+
+exports["test patch delete missing"] = function(assert) {
+  assert.deepEqual(patch({ a: 1, b: 2 }, { c: null }),
+                   { a: 1, b: 2 },
+                   "null removes property if exists");
+
+  assert.deepEqual(patch({ a: 1, b: 2 }, { c: void(0) }),
+                   { a: 1, b: 2 },
+                   "void removes property if exists");
+}
+
+exports["test delete deleted"] = function(assert) {
+  assert.deepEqual(patch({ a: null, b: 2, c: 3, d: void(0)},
+                         { a: void(0), b: null, d: null }),
+                   {c: 3},
+                  "removed all existing and non existing");
+}
+
+exports["test update deleted"] = function(assert) {
+  assert.deepEqual(patch({ a: null, b: void(0), c: 3},
+                         { a: { b: 2 } }),
+                   { a: { b: 2 }, c: 3 },
+                   "replace deleted");
+}
+
+exports["test patch delete with void"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, { a: void(0) }), { b: 2 },
+                   "void(0) removes property")
+}
+
+
+exports["test patch addition"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, { c: 3 }), { a: 1, b: 2, c: 3 },
+                   "new properties are added")
+}
+
+exports["test patch addition"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, { c: 3 }), { a: 1, b: 2, c: 3 },
+                   "new properties are added")
+}
+
+exports["test hash on itself"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, hash), hash,
+                   "applying hash to itself returns hash itself")
+}
+
+exports["test patch with empty delta"] = function(assert) {
+  var hash = { a: 1, b: 2 }
+
+  assert.deepEqual(patch(hash, {}), hash,
+                   "applying empty delta results in no changes")
+}
+
+exports["test patch nested data"] = function(assert) {
+  assert.deepEqual(patch({ a: { b: 1 }, c: { d: 2 } },
+                         { a: { b: null, e: 3 }, c: { d: 4 } }),
+                   { a: { e: 3 }, c: { d: 4 } },
+                   "nested structures can also be patched")
+}
diff --git a/toolkit/jetpack/diffpatcher/test/tap.js b/toolkit/jetpack/diffpatcher/test/tap.js
new file mode 100644
index 000000000..e550b82f5
--- /dev/null
+++ b/toolkit/jetpack/diffpatcher/test/tap.js
@@ -0,0 +1,3 @@
+"use strict";
+
+require("retape")(require("./index"))
diff --git a/toolkit/jetpack/framescript/FrameScriptManager.jsm b/toolkit/jetpack/framescript/FrameScriptManager.jsm
new file mode 100644
index 000000000..1ce6ceb07
--- /dev/null
+++ b/toolkit/jetpack/framescript/FrameScriptManager.jsm
@@ -0,0 +1,27 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const globalMM = Components.classes["@mozilla.org/globalmessagemanager;1"].
+                 getService(Components.interfaces.nsIMessageListenerManager);
+
+// Load frame scripts from the same dir as this module.
+// Since this JSM will be loaded using require(), PATH will be
+// overridden while running tests, just like any other module.
+const PATH = __URI__.replace('framescript/FrameScriptManager.jsm', '');
+
+// Builds a unique loader ID for this runtime. We prefix with the SDK path so
+// overriden versions of the SDK don't conflict
+var LOADER_ID = 0;
+this.getNewLoaderID = () => {
+  return PATH + ":" + LOADER_ID++;
+}
+
+const frame_script = function(contentFrame, PATH) {
+  let { registerContentFrame } = Components.utils.import(PATH + 'framescript/content.jsm', {});
+  registerContentFrame(contentFrame);
+}
+globalMM.loadFrameScript("data:,(" + frame_script.toString() + ")(this, " + JSON.stringify(PATH) + ");", true);
+
+this.EXPORTED_SYMBOLS = ['getNewLoaderID'];
diff --git a/toolkit/jetpack/framescript/content.jsm b/toolkit/jetpack/framescript/content.jsm
new file mode 100644
index 000000000..eaee26be3
--- /dev/null
+++ b/toolkit/jetpack/framescript/content.jsm
@@ -0,0 +1,94 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { utils: Cu, classes: Cc, interfaces: Ci } = Components;
+const { Services } = Cu.import('resource://gre/modules/Services.jsm');
+
+const cpmm = Cc['@mozilla.org/childprocessmessagemanager;1'].
+             getService(Ci.nsISyncMessageSender);
+
+this.EXPORTED_SYMBOLS = ["registerContentFrame"];
+
+// This may be an overriden version of the SDK so use the PATH as a key for the
+// initial messages before we have a loaderID.
+const PATH = __URI__.replace('framescript/content.jsm', '');
+
+const { Loader } = Cu.import(PATH + 'toolkit/loader.js', {});
+
+// one Loader instance per addon (per @loader/options to be precise)
+var addons = new Map();
+
+// Tell the parent that a new process is ready
+cpmm.sendAsyncMessage('sdk/remote/process/start', {
+  modulePath: PATH
+});
+
+// Load a child process module loader with the given loader options
+cpmm.addMessageListener('sdk/remote/process/load', ({ data: { modulePath, loaderID, options, reason } }) => {
+  if (modulePath != PATH)
+    return;
+
+  // During startup races can mean we get a second load message
+  if (addons.has(loaderID))
+    return;
+
+  options.waiveInterposition = true;
+
+  let loader = Loader.Loader(options);
+  let addon = {
+    loader,
+    require: Loader.Require(loader, { id: 'LoaderHelper' }),
+  }
+  addons.set(loaderID, addon);
+
+  cpmm.sendAsyncMessage('sdk/remote/process/attach', {
+    loaderID,
+    processID: Services.appinfo.processID,
+    isRemote: Services.appinfo.processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT
+  });
+
+  addon.child = addon.require('sdk/remote/child');
+
+  for (let contentFrame of frames.values())
+    addon.child.registerContentFrame(contentFrame);
+});
+
+// Unload a child process loader
+cpmm.addMessageListener('sdk/remote/process/unload', ({ data: { loaderID, reason } }) => {
+  if (!addons.has(loaderID))
+    return;
+
+  let addon = addons.get(loaderID);
+  Loader.unload(addon.loader, reason);
+
+  // We want to drop the reference to the loader but never allow creating a new
+  // loader with the same ID
+  addons.set(loaderID, {});
+})
+
+
+var frames = new Set();
+
+this.registerContentFrame = contentFrame => {
+  contentFrame.addEventListener("unload", () => {
+    unregisterContentFrame(contentFrame);
+  }, false);
+
+  frames.add(contentFrame);
+
+  for (let addon of addons.values()) {
+    if ("child" in addon)
+      addon.child.registerContentFrame(contentFrame);
+  }
+};
+
+function unregisterContentFrame(contentFrame) {
+  frames.delete(contentFrame);
+
+  for (let addon of addons.values()) {
+    if ("child" in addon)
+      addon.child.unregisterContentFrame(contentFrame);
+  }
+}
diff --git a/toolkit/jetpack/framescript/context-menu.js b/toolkit/jetpack/framescript/context-menu.js
new file mode 100644
index 000000000..3915b7cd8
--- /dev/null
+++ b/toolkit/jetpack/framescript/context-menu.js
@@ -0,0 +1,215 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { query, constant, cache } = require("sdk/lang/functional");
+const { pairs, each, map, object } = require("sdk/util/sequence");
+const { nodeToMessageManager } = require("./util");
+
+// Decorator function that takes `f` function and returns one that attempts
+// to run `f` with given arguments. In case of exception error is logged
+// and `fallback` is returned instead.
+const Try = (fn, fallback=null) => (...args) => {
+  try {
+    return fn(...args);
+  } catch(error) {
+    console.error(error);
+    return fallback;
+  }
+};
+
+// Decorator funciton that takes `f` function and returns one that returns
+// JSON cloned result of whatever `f` returns for given arguments.
+const JSONReturn = f => (...args) => JSON.parse(JSON.stringify(f(...args)));
+
+const Null = constant(null);
+
+// Table of readers mapped to field names they're going to be reading.
+const readers = Object.create(null);
+// Read function takes "contextmenu" event target `node` and returns table of
+// read field names mapped to appropriate values. Read uses above defined read
+// table to read data for all registered readers.
+const read = node =>
+  object(...map(([id, read]) => [id, read(node, id)], pairs(readers)));
+
+// Table of built-in readers, each takes a descriptor and returns a reader:
+// descriptor -> node -> JSON
+const parsers = Object.create(null)
+// Function takes a descriptor of the remotely defined reader and parsese it
+// to construct a local reader that's going to read out data from context menu
+// target.
+const parse = descriptor => {
+  const parser = parsers[descriptor.category];
+  if (!parser) {
+    console.error("Unknown reader descriptor was received", descriptor, `"${descriptor.category}"`);
+    return Null
+  }
+  return Try(parser(descriptor));
+}
+
+// TODO: Test how chrome's mediaType behaves to try and match it's behavior.
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+const SVG_NS = "http://www.w3.org/2000/svg";
+
+// Firefox always creates a HTMLVideoElement when loading an ogg file
+// directly. If the media is actually audio, be smarter and provide a
+// context menu with audio operations.
+// Source: https://github.com/mozilla/gecko-dev/blob/28c2fca3753c5371643843fc2f2f205146b083b7/browser/base/content/nsContextMenu.js#L632-L637
+const isVideoLoadingAudio = node =>
+  node.readyState >= node.HAVE_METADATA &&
+    (node.videoWidth == 0 || node.videoHeight == 0)
+
+const isVideo = node =>
+  node instanceof node.ownerDocument.defaultView.HTMLVideoElement &&
+  !isVideoLoadingAudio(node);
+
+const isAudio = node => {
+  const {HTMLVideoElement, HTMLAudioElement} = node.ownerDocument.defaultView;
+  return node instanceof HTMLAudioElement ? true :
+         node instanceof HTMLVideoElement ? isVideoLoadingAudio(node) :
+         false;
+};
+
+const isImage = ({namespaceURI, localName}) =>
+  namespaceURI === HTML_NS && localName === "img" ? true :
+  namespaceURI === XUL_NS && localName === "image" ? true :
+  namespaceURI === SVG_NS && localName === "image" ? true :
+  false;
+
+parsers["reader/MediaType()"] = constant(node =>
+  isImage(node) ? "image" :
+  isAudio(node) ? "audio" :
+  isVideo(node) ? "video" :
+  null);
+
+
+const readLink = node =>
+  node.namespaceURI === HTML_NS && node.localName === "a" ? node.href :
+  readLink(node.parentNode);
+
+parsers["reader/LinkURL()"] = constant(node =>
+  node.matches("a, a *") ? readLink(node) : null);
+
+// Reader that reads out `true` if "contextmenu" `event.target` matches
+// `descriptor.selector` and `false` if it does not.
+parsers["reader/SelectorMatch()"] = ({selector}) =>
+  node => node.matches(selector);
+
+// Accessing `selectionStart` and `selectionEnd` properties on non
+// editable input nodes throw exceptions, there for we need this util
+// function to guard us against them.
+const getInputSelection = node => {
+  try {
+    if ("selectionStart" in node && "selectionEnd" in node) {
+      const {selectionStart, selectionEnd} = node;
+      return {selectionStart, selectionEnd}
+    }
+  }
+  catch(_) {}
+
+  return null;
+}
+
+// Selection reader does not really cares about descriptor so it is
+// a constant function returning selection reader. Selection reader
+// returns string of the selected text or `null` if there is no selection.
+parsers["reader/Selection()"] = constant(node => {
+  const selection = node.ownerDocument.getSelection();
+  if (!selection.isCollapsed) {
+    return selection.toString();
+  }
+  // If target node is editable (text, input, textarea, etc..) document does
+  // not really handles selections there. There for we fallback to checking
+  // `selectionStart` `selectionEnd` properties and if they are present we
+  // extract selections manually from the `node.value`.
+  else {
+    const selection = getInputSelection(node);
+    const isSelected = selection &&
+                       Number.isInteger(selection.selectionStart) &&
+                       Number.isInteger(selection.selectionEnd) &&
+                       selection.selectionStart !== selection.selectionEnd;
+    return  isSelected ? node.value.substring(selection.selectionStart,
+                                              selection.selectionEnd) :
+            null;
+  }
+});
+
+// Query reader just reads out properties from the node, so we just use `query`
+// utility function.
+parsers["reader/Query()"] = ({path}) => JSONReturn(query(path));
+// Attribute reader just reads attribute of the event target node.
+parsers["reader/Attribute()"] = ({name}) => node => node.getAttribute(name);
+
+// Extractor reader defines generates a reader out of serialized function, who's
+// return value is JSON cloned. Note: We do know source will evaluate to function
+// as that's what we serialized on the other end, it's also ok if generated function
+// is going to throw as registered readers are wrapped in try catch to avoid breakting
+// unrelated readers.
+parsers["reader/Extractor()"] = ({source}) =>
+  JSONReturn(new Function("return (" + source + ")")());
+
+// If the context-menu target node or any of its ancestors is one of these,
+// Firefox uses a tailored context menu, and so the page context doesn't apply.
+// There for `reader/isPage()` will read `false` in that case otherwise it's going
+// to read `true`.
+const nonPageElements = ["a", "applet", "area", "button", "canvas", "object",
+                         "embed", "img", "input", "map", "video", "audio", "menu",
+                         "option", "select", "textarea", "[contenteditable=true]"];
+const nonPageSelector = nonPageElements.
+                          concat(nonPageElements.map(tag => `${tag} *`)).
+                          join(", ");
+
+// Note: isPageContext implementation could have actually used SelectorMatch reader,
+// but old implementation was also checked for collapsed selection there for to keep
+// the behavior same we end up implementing a new reader.
+parsers["reader/isPage()"] = constant(node =>
+  node.ownerDocument.defaultView.getSelection().isCollapsed &&
+  !node.matches(nonPageSelector));
+
+// Reads `true` if node is in an iframe otherwise returns true.
+parsers["reader/isFrame()"] = constant(node =>
+  !!node.ownerDocument.defaultView.frameElement);
+
+parsers["reader/isEditable()"] = constant(node => {
+  const selection = getInputSelection(node);
+  return selection ? !node.readOnly && !node.disabled : node.isContentEditable;
+});
+
+
+// TODO: Add some reader to read out tab id.
+
+const onReadersUpdate = message => {
+  each(([id, descriptor]) => {
+    if (descriptor) {
+      readers[id] = parse(descriptor);
+    }
+    else {
+      delete readers[id];
+    }
+  }, pairs(message.data));
+};
+exports.onReadersUpdate = onReadersUpdate;
+
+
+const onContextMenu = event => {
+  if (!event.defaultPrevented) {
+    const manager = nodeToMessageManager(event.target);
+    manager.sendSyncMessage("sdk/context-menu/read", read(event.target), readers);
+  }
+};
+exports.onContextMenu = onContextMenu;
+
+
+const onContentFrame = (frame) => {
+  // Listen for contextmenu events in on this frame.
+  frame.addEventListener("contextmenu", onContextMenu);
+  // Listen to registered reader changes and update registry.
+  frame.addMessageListener("sdk/context-menu/readers", onReadersUpdate);
+
+  // Request table of readers (if this is loaded in a new process some table
+  // changes may be missed, this is way to sync up).
+  frame.sendAsyncMessage("sdk/context-menu/readers?");
+};
+exports.onContentFrame = onContentFrame;
diff --git a/toolkit/jetpack/framescript/manager.js b/toolkit/jetpack/framescript/manager.js
new file mode 100644
index 000000000..1f261e1fa
--- /dev/null
+++ b/toolkit/jetpack/framescript/manager.js
@@ -0,0 +1,26 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const mime = "application/javascript";
+const requireURI = module.uri.replace("framescript/manager.js",
+                                      "toolkit/require.js");
+
+const requireLoadURI = `data:${mime},this["Components"].utils.import("${requireURI}")`
+
+// Loads module with given `id` into given `messageManager` via shared module loader. If `init`
+// string is passed, will call module export with that name and pass frame script environment
+// of the `messageManager` into it. Since module will load only once per process (which is
+// once for chrome proces & second for content process) it is useful to have an init function
+// to setup event listeners on each content frame.
+const loadModule = (messageManager, id, allowDelayed, init) => {
+  const moduleLoadURI = `${requireLoadURI}.require("${id}")`
+  const uri = init ? `${moduleLoadURI}.${init}(this)` : moduleLoadURI;
+  messageManager.loadFrameScript(uri, allowDelayed);
+};
+exports.loadModule = loadModule;
diff --git a/toolkit/jetpack/framescript/util.js b/toolkit/jetpack/framescript/util.js
new file mode 100644
index 000000000..fb6834608
--- /dev/null
+++ b/toolkit/jetpack/framescript/util.js
@@ -0,0 +1,25 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+
+const { Ci } = require("chrome");
+
+const windowToMessageManager = window =>
+  window.
+    QueryInterface(Ci.nsIInterfaceRequestor).
+    getInterface(Ci.nsIDocShell).
+    sameTypeRootTreeItem.
+    QueryInterface(Ci.nsIDocShell).
+    QueryInterface(Ci.nsIInterfaceRequestor).
+    getInterface(Ci.nsIContentFrameMessageManager);
+exports.windowToMessageManager = windowToMessageManager;
+
+const nodeToMessageManager = node =>
+  windowToMessageManager(node.ownerDocument.defaultView);
+exports.nodeToMessageManager = nodeToMessageManager;
diff --git a/toolkit/jetpack/index.js b/toolkit/jetpack/index.js
new file mode 100644
index 000000000..e0032240a
--- /dev/null
+++ b/toolkit/jetpack/index.js
@@ -0,0 +1,3 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
diff --git a/toolkit/jetpack/jetpack-id/index.js b/toolkit/jetpack/jetpack-id/index.js
new file mode 100644
index 000000000..6c1493f1d
--- /dev/null
+++ b/toolkit/jetpack/jetpack-id/index.js
@@ -0,0 +1,53 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Takes parsed `package.json` manifest and returns
+ * valid add-on id for it.
+ */
+function getID(manifest) {
+  manifest = manifest || {};
+
+  if (manifest.id) {
+
+    if (typeof manifest.id !== "string") {
+      return null;
+    }
+
+    // If manifest.id is already valid (as domain or GUID), use it
+    if (isValidAOMName(manifest.id)) {
+      return manifest.id;
+    }
+    // Otherwise, this ID is invalid so return `null`
+    return null;
+  }
+
+  // If no `id` defined, turn `name` into a domain ID,
+  // as we transition to `name` being an id, similar to node/npm, but
+  // append a '@' to make it compatible with Firefox requirements
+  if (manifest.name) {
+
+    if (typeof manifest.name !== "string") {
+      return null;
+    }
+
+    var modifiedName = "@" + manifest.name;
+    return isValidAOMName(modifiedName) ? modifiedName : null;
+  }
+
+  // If no `id` or `name` property, return null as this manifest
+  // is invalid
+  return null;
+}
+
+module.exports = getID;
+
+/**
+ * Regex taken from XPIProvider.jsm in the Addon Manager to validate proper
+ * IDs that are able to be used.
+ * http://mxr.mozilla.org/mozilla-central/source/toolkit/mozapps/extensions/internal/XPIProvider.jsm#209
+ */
+function isValidAOMName (s) {
+  return /^(\{[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\}|[a-z0-9-\._]*\@[a-z0-9-\._]+)$/i.test(s || "");
+}
diff --git a/toolkit/jetpack/jetpack-id/package.json b/toolkit/jetpack/jetpack-id/package.json
new file mode 100644
index 000000000..62a1c73ba
--- /dev/null
+++ b/toolkit/jetpack/jetpack-id/package.json
@@ -0,0 +1,28 @@
+{
+  "name": "jetpack-id",
+  "version": "1.0.0",
+  "description": "Creates an ID from a Firefox Jetpack manifest",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "http://github.com/jsantell/jetpack-id"
+  },
+  "author": {
+    "name": "Jordan Santell",
+    "url": "http://github.com/jsantell"
+  },
+  "license": "MPL-2.0",
+  "scripts": {
+    "test": "./node_modules/.bin/mocha --reporter spec --ui bdd"
+  },
+  "keywords": [
+    "jetpack",
+    "addon",
+    "mozilla",
+    "firefox"
+  ],
+  "devDependencies": {
+    "mocha": "*",
+    "chai": "*"
+  }
+}
diff --git a/toolkit/jetpack/method/.travis.yml b/toolkit/jetpack/method/.travis.yml
new file mode 100644
index 000000000..780731a47
--- /dev/null
+++ b/toolkit/jetpack/method/.travis.yml
@@ -0,0 +1,5 @@
+language: node_js
+node_js:
+  - 0.4
+  - 0.5
+  - 0.6
diff --git a/toolkit/jetpack/method/History.md b/toolkit/jetpack/method/History.md
new file mode 100644
index 000000000..95258c45f
--- /dev/null
+++ b/toolkit/jetpack/method/History.md
@@ -0,0 +1,55 @@
+# Changes
+
+## 1.0.2 / 2012-12-26
+
+  - Delegate to polymorphic methods from `.define` and `.implement` so, they
+    can be overidden.
+
+## 1.0.1 / 2012-11-11
+
+  - Fix issues with different `Error` types as they all inherit from
+    `Error`.
+
+## 1.0.0 / 2012-11-09
+
+  - Add browser test integration.
+  - Fix cross-browser incompatibilities & test failures.
+  - Add support for host objects.
+  - Add optional `hint` argument for method to ease debugging.
+  - Remove default implementation at definition time.
+
+## 0.1.1 / 2012-10-15
+
+ - Fix regression causing custom type implementation to be stored on objects.
+
+## 0.1.0 / 2012-10-15
+
+ - Remove dependency on name module.
+ - Implement fallback for engines that do not support ES5.
+ - Add support for built-in type extensions without extending their prototypes.
+ - Make API for default definitions more intuitive.
+   Skipping type argument now defines default:
+
+      isFoo.define(function(value) {
+        return false
+      })
+
+ - Make exposed `define` and `implement` polymorphic.
+ - Removed dev dependency on swank-js.
+ - Primitive types `string, number, boolean` no longer inherit method
+   implementations from `Object`.
+
+## 0.0.3 / 2012-07-17
+
+  - Remove module boilerplate
+
+## 0.0.2 / 2012-06-26
+
+  - Name changes to make it less conflicting with other library conventions.
+  - Expose function version of `define` & `implement` methods.
+  - Expose `Null` and `Undefined` object holding implementations for an
+    associated types.
+
+## 0.0.1 / 2012-06-25
+
+  - Initial release
diff --git a/toolkit/jetpack/method/License.md b/toolkit/jetpack/method/License.md
new file mode 100644
index 000000000..ed76489a3
--- /dev/null
+++ b/toolkit/jetpack/method/License.md
@@ -0,0 +1,18 @@
+Copyright 2012 Irakli Gozalishvili. All rights reserved.
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.
diff --git a/toolkit/jetpack/method/Readme.md b/toolkit/jetpack/method/Readme.md
new file mode 100644
index 000000000..9584c9160
--- /dev/null
+++ b/toolkit/jetpack/method/Readme.md
@@ -0,0 +1,117 @@
+# method
+
+[![Build Status](https://secure.travis-ci.org/Gozala/method.png)](http://travis-ci.org/Gozala/method)
+
+Library provides an API for defining polymorphic methods that dispatch on the
+first argument type. This provides a powerful way for decouple abstraction
+interface definition from an actual implementation per type, without risks
+of interference with other libraries.
+
+### Motivation
+
+  - Provide a high-performance, dynamic polymorphism construct as an
+    alternative to existing object methods that does not provides any
+    mechanics for guarding against name conflicts.
+  - Allow independent extension of types, and implementations of methods
+    on types, by different parties.
+
+## Install
+
+    npm install method
+
+## Use
+
+```js
+var method = require("method")
+
+// Define `isWatchable` method that can be implemented for any type.
+var isWatchable = method("isWatchable")
+
+// If you call it on any object it will
+// throw as nothing implements that method yet.
+//isWatchable({}) // => Exception: method is not implemented
+
+// If you define private method on `Object.prototype`
+// all objects will inherit it.
+Object.prototype[isWatchable] = function() {
+  return false;
+}
+
+isWatchable({}) // => false
+
+
+// Although `isWatchable` property above will be enumerable and there for
+// may damage some assumbtions made by other libraries. There for it"s
+// recomended to use built-in helpers methods that will define extension
+// without breaking assumbtions made by other libraries:
+
+isWatchable.define(Object, function() { return false })
+
+
+// There are primitive types in JS that won"t inherit methods from Object:
+isWatchable(null) // => Exception: method is not implemented
+
+// One could either implement methods for such types:
+isWatchable.define(null, function() { return false })
+isWatchable.define(undefined, function() { return false })
+
+// Or simply define default implementation:
+isWatchable.define(function() { return false })
+
+// Alternatively default implementation may be provided at creation:
+isWatchable = method(function() { return false })
+
+// Method dispatches on an first argument type. That allows us to create
+// new types with an alternative implementations:
+function Watchable() {}
+isWatchable.define(Watchable, function() { return true })
+
+// This will make all `Watchable` instances watchable!
+isWatchable(new Watchable()) // => true
+
+// Arbitrary objects can also be extended to implement given method. For example
+// any object can simply made watchable:
+function watchable(object) {
+  return isWatchable.implement(objct, function() { return true })
+}
+
+isWatchable(watchable({})) // => true
+
+// Full protocols can be defined with such methods:
+var observers = "observers@" + module.filename
+var watchers = method("watchers")
+var watch = method("watch")
+var unwatch = method("unwatch")
+
+watchers.define(Watchable, function(target) {
+  return target[observers] || (target[observers] = [])
+})
+
+watch.define(Watchable, function(target, watcher) {
+  var observers = watchers(target)
+  if (observers.indexOf(watcher) < 0) observers.push(watcher)
+  return target
+})
+unwatch.define(Watchable, function(target, watcher) {
+  var observers = watchers(target)
+  var index = observers.indexOf(watcher)
+  if (observers.indexOf(watcher) >= 0) observers.unshift(watcher)
+  return target
+})
+
+// Define type Port that inherits form Watchable
+
+function Port() {}
+Port.prototype = Object.create(Watchable.prototype)
+
+var emit = method("emit")
+emit.define(Port, function(port, message) {
+  watchers(port).slice().forEach(function(watcher) {
+    watcher(message)
+  })
+})
+
+var p = new Port()
+watch(p, console.log)
+emit(p, "hello world") // => info: "hello world"
+```
diff --git a/toolkit/jetpack/method/core.js b/toolkit/jetpack/method/core.js
new file mode 100644
index 000000000..a6a5261e6
--- /dev/null
+++ b/toolkit/jetpack/method/core.js
@@ -0,0 +1,225 @@
+"use strict";
+
+var defineProperty = Object.defineProperty || function(object, name, property) {
+  object[name] = property.value
+  return object
+}
+
+// Shortcut for `Object.prototype.toString` for faster access.
+var typefy = Object.prototype.toString
+
+// Map to for jumping from typeof(value) to associated type prefix used
+// as a hash in the map of builtin implementations.
+var types = { "function": "Object", "object": "Object" }
+
+// Array is used to save method implementations for the host objects in order
+// to avoid extending them with non-primitive values that could cause leaks.
+var host = []
+// Hash map is used to save method implementations for builtin types in order
+// to avoid extending their prototypes. This also allows to share method
+// implementations for types across diff contexts / frames / compartments.
+var builtin = {}
+
+function Primitive() {}
+function ObjectType() {}
+ObjectType.prototype = new Primitive()
+function ErrorType() {}
+ErrorType.prototype = new ObjectType()
+
+var Default = builtin.Default = Primitive.prototype
+var Null = builtin.Null = new Primitive()
+var Void = builtin.Void = new Primitive()
+builtin.String = new Primitive()
+builtin.Number = new Primitive()
+builtin.Boolean = new Primitive()
+
+builtin.Object = ObjectType.prototype
+builtin.Error = ErrorType.prototype
+
+builtin.EvalError = new ErrorType()
+builtin.InternalError = new ErrorType()
+builtin.RangeError = new ErrorType()
+builtin.ReferenceError = new ErrorType()
+builtin.StopIteration = new ErrorType()
+builtin.SyntaxError = new ErrorType()
+builtin.TypeError = new ErrorType()
+builtin.URIError = new ErrorType()
+
+
+function Method(hint) {
+  /**
+  Private Method is a callable private name that dispatches on the first
+  arguments same named Method:
+
+      method(object, ...rest) => object[method](...rest)
+
+  Optionally hint string may be provided that will be used in generated names
+  to ease debugging.
+
+  ## Example
+
+      var foo = Method()
+
+      // Implementation for any types
+      foo.define(function(value, arg1, arg2) {
+        // ...
+      })
+
+      // Implementation for a specific type
+      foo.define(BarType, function(bar, arg1, arg2) {
+        // ...
+      })
+  **/
+
+  // Create an internal unique name if `hint` is provided it is used to
+  // prefix name to ease debugging.
+  var name = (hint || "") + "#" + Math.random().toString(32).substr(2)
+
+  function dispatch(value) {
+    // Method dispatches on type of the first argument.
+    // If first argument is `null` or `void` associated implementation is
+    // looked up in the `builtin` hash where implementations for built-ins
+    // are stored.
+    var type = null
+    var method = value === null ? Null[name] :
+                 value === void(0) ? Void[name] :
+                 // Otherwise attempt to use method with a generated private
+                 // `name` that is supposedly in the prototype chain of the
+                 // `target`.
+                 value[name] ||
+                 // Otherwise assume it's one of the built-in type instances,
+                 // in which case implementation is stored in a `builtin` hash.
+                 // Attempt to find a implementation for the given built-in
+                 // via constructor name and method name.
+                 ((type = builtin[(value.constructor || "").name]) &&
+                  type[name]) ||
+                 // Otherwise assume it's a host object. For host objects
+                 // actual method implementations are stored in the `host`
+                 // array and only index for the implementation is stored
+                 // in the host object's prototype chain. This avoids memory
+                 // leaks that otherwise could happen when saving JS objects
+                 // on host object.
+                 host[value["!" + name] || void(0)] ||
+                 // Otherwise attempt to lookup implementation for builtins by
+                 // a type of the value. This basically makes sure that all
+                 // non primitive values will delegate to an `Object`.
+                 ((type = builtin[types[typeof(value)]]) && type[name])
+
+
+    // If method implementation for the type is still not found then
+    // just fallback for default implementation.
+    method = method || Default[name]
+
+
+    // If implementation is still not found (which also means there is no
+    // default) just throw an error with a descriptive message.
+    if (!method) throw TypeError("Type does not implements method: " + name)
+
+    // If implementation was found then just delegate.
+    return method.apply(method, arguments)
+  }
+
+  // Make `toString` of the dispatch return a private name, this enables
+  // method definition without sugar:
+  //
+  //    var method = Method()
+  //    object[method] = function() { /***/ }
+  dispatch.toString = function toString() { return name }
+
+  // Copy utility methods for convenient API.
+  dispatch.implement = implementMethod
+  dispatch.define = defineMethod
+
+  return dispatch
+}
+
+// Create method shortcuts form functions.
+var defineMethod = function defineMethod(Type, lambda) {
+  return define(this, Type, lambda)
+}
+var implementMethod = function implementMethod(object, lambda) {
+  return implement(this, object, lambda)
+}
+
+// Define `implement` and `define` polymorphic methods to allow definitions
+// and implementations through them.
+var implement = Method("implement")
+var define = Method("define")
+
+
+function _implement(method, object, lambda) {
+  /**
+  Implements `Method` for the given `object` with a provided `implementation`.
+  Calling `Method` with `object` as a first argument will dispatch on provided
+  implementation.
+  **/
+  return defineProperty(object, method.toString(), {
+    enumerable: false,
+    configurable: false,
+    writable: false,
+    value: lambda
+  })
+}
+
+function _define(method, Type, lambda) {
+  /**
+  Defines `Method` for the given `Type` with a provided `implementation`.
+  Calling `Method` with a first argument of this `Type` will dispatch on
+  provided `implementation`. If `Type` is a `Method` default implementation
+  is defined. If `Type` is a `null` or `undefined` `Method` is implemented
+  for that value type.
+  **/
+
+  // Attempt to guess a type via `Object.prototype.toString.call` hack.
+  var type = Type && typefy.call(Type.prototype)
+
+  // If only two arguments are passed then `Type` is actually an implementation
+  // for a default type.
+  if (!lambda) Default[method] = Type
+  // If `Type` is `null` or `void` store implementation accordingly.
+  else if (Type === null) Null[method] = lambda
+  else if (Type === void(0)) Void[method] = lambda
+  // If `type` hack indicates built-in type and type has a name us it to
+  // store a implementation into associated hash. If hash for this type does
+  // not exists yet create one.
+  else if (type !== "[object Object]" && Type.name) {
+    var Bulitin = builtin[Type.name] || (builtin[Type.name] = new ObjectType())
+    Bulitin[method] = lambda
+  }
+  // If `type` hack indicates an object, that may be either object or any
+  // JS defined "Class". If name of the constructor is `Object`, assume it's
+  // built-in `Object` and store implementation accordingly.
+  else if (Type.name === "Object")
+    builtin.Object[method] = lambda
+  // Host objects are pain!!! Every browser does some crazy stuff for them
+  // So far all browser seem to not implement `call` method for host object
+  // constructors. If that is a case here, assume it's a host object and
+  // store implementation in a `host` array and store `index` in the array
+  // in a `Type.prototype` itself. This avoids memory leaks that could be
+  // caused by storing JS objects on a host objects.
+  else if (Type.call === void(0)) {
+    var index = host.indexOf(lambda)
+    if (index < 0) index = host.push(lambda) - 1
+    // Prefix private name with `!` so it can be dispatched from the method
+    // without type checks.
+    implement("!" + method, Type.prototype, index)
+  }
+  // If Got that far `Type` is user defined JS `Class`. Define private name
+  // as hidden property on it's prototype.
+  else
+    implement(method, Type.prototype, lambda)
+}
+
+// And provided implementations for a polymorphic equivalents.
+_define(define, _define)
+_define(implement, _implement)
+
+// Define exports on `Method` as it's only thing being exported.
+Method.implement = implement
+Method.define = define
+Method.Method = Method
+Method.method = Method
+Method.builtin = builtin
+Method.host = host
+
+module.exports = Method
diff --git a/toolkit/jetpack/method/package.json b/toolkit/jetpack/method/package.json
new file mode 100644
index 000000000..7bb004e28
--- /dev/null
+++ b/toolkit/jetpack/method/package.json
@@ -0,0 +1,41 @@
+{
+  "name": "method",
+  "id": "method",
+  "version": "1.0.2",
+  "description": "Functional polymorphic method dispatch",
+  "keywords": [
+    "method",
+    "dispatch",
+    "protocol",
+    "polymorphism",
+    "type dispatch"
+  ],
+  "author": "Irakli Gozalishvili <rfobic@gmail.com> (http://jeditoolkit.com)",
+  "homepage": "https://github.com/Gozala/method",
+  "main": "./core.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Gozala/method.git",
+    "web": "https://github.com/Gozala/method"
+  },
+  "bugs": {
+    "url": "http://github.com/Gozala/method/issues/"
+  },
+  "devDependencies": {
+    "test": "~0.x.0",
+    "repl-utils": "~2.0.1",
+    "phantomify": "~0.1.0"
+  },
+  "scripts": {
+    "test": "npm run test-node && npm run test-browser",
+    "test-browser": "node ./node_modules/phantomify/bin/cmd.js ./test/browser.js",
+    "test-node": "node ./test/common.js",
+    "repl": "node node_modules/repl-utils"
+  },
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/Gozala/method/License.md"
+    }
+  ]
+}
diff --git a/toolkit/jetpack/method/test/browser.js b/toolkit/jetpack/method/test/browser.js
new file mode 100644
index 000000000..7c8e6cd52
--- /dev/null
+++ b/toolkit/jetpack/method/test/browser.js
@@ -0,0 +1,20 @@
+"use strict";
+
+exports["test common"] = require("./common")
+
+var Method = require("../core")
+
+exports["test host objects"] = function(assert) {
+  var isElement = Method("is-element")
+  isElement.define(function() { return false })
+
+  isElement.define(Element, function() { return true })
+
+  assert.notDeepEqual(typeof(Element.prototype[isElement]), "number",
+                     "Host object's prototype is extended with a number value")
+
+  assert.ok(!isElement({}), "object is not an Element")
+  assert.ok(document.createElement("div"), "Element is an element")
+}
+
+require("test").run(exports)
diff --git a/toolkit/jetpack/method/test/common.js b/toolkit/jetpack/method/test/common.js
new file mode 100644
index 000000000..0418c3a23
--- /dev/null
+++ b/toolkit/jetpack/method/test/common.js
@@ -0,0 +1,272 @@
+"use strict";
+
+var Method = require("../core")
+
+function type(value) {
+  return Object.prototype.toString.call(value).
+    split(" ").
+    pop().
+    split("]").
+    shift().
+    toLowerCase()
+}
+
+var values = [
+  null,                   // 0
+  undefined,              // 1
+  Infinity,               // 2
+  NaN,                    // 3
+  5,                      // 4
+  {},                     // 5
+  Object.create({}),      // 6
+  Object.create(null),    // 7
+  [],                     // 8
+  /foo/,                  // 9
+  new Date(),             // 10
+  Function,               // 11
+  function() {},          // 12
+  true,                   // 13
+  false,                  // 14
+  "string"                // 15
+]
+
+function True() { return true }
+function False() { return false }
+
+var trues = values.map(True)
+var falses = values.map(False)
+
+exports["test throws if not implemented"] = function(assert) {
+  var method = Method("nope")
+
+  assert.throws(function() {
+    method({})
+  }, /not implement/i, "method throws if not implemented")
+
+  assert.throws(function() {
+    method(null)
+  }, /not implement/i, "method throws on null")
+}
+
+exports["test all types inherit from default"] = function(assert) {
+  var isImplemented = Method("isImplemented")
+  isImplemented.define(function() { return true })
+
+  values.forEach(function(value) {
+    assert.ok(isImplemented(value),
+              type(value) + " inherits deafult implementation")
+  })
+}
+
+exports["test default can be implemented later"] = function(assert) {
+  var isImplemented = Method("isImplemented")
+  isImplemented.define(function() {
+    return true
+  })
+
+  values.forEach(function(value) {
+    assert.ok(isImplemented(value),
+              type(value) + " inherits deafult implementation")
+  })
+}
+
+exports["test dispatch not-implemented"] = function(assert) {
+  var isDefault = Method("isDefault")
+  values.forEach(function(value) {
+    assert.throws(function() {
+      isDefault(value)
+    }, /not implement/, type(value) + " throws if not implemented")
+  })
+}
+
+exports["test dispatch default"] = function(assert) {
+  var isDefault = Method("isDefault")
+
+  // Implement default
+  isDefault.define(True)
+  assert.deepEqual(values.map(isDefault), trues,
+                   "all implementation inherit from default")
+
+}
+
+exports["test dispatch null"] = function(assert) {
+  var isNull = Method("isNull")
+
+  // Implement default
+  isNull.define(False)
+  isNull.define(null, True)
+  assert.deepEqual(values.map(isNull),
+                   [ true ].
+                   concat(falses.slice(1)),
+                   "only null gets methods defined for null")
+}
+
+exports["test dispatch undefined"] = function(assert) {
+  var isUndefined = Method("isUndefined")
+
+  // Implement default
+  isUndefined.define(False)
+  isUndefined.define(undefined, True)
+  assert.deepEqual(values.map(isUndefined),
+                   [ false, true ].
+                   concat(falses.slice(2)),
+                   "only undefined gets methods defined for undefined")
+}
+
+exports["test dispatch object"] = function(assert) {
+  var isObject = Method("isObject")
+
+  // Implement default
+  isObject.define(False)
+  isObject.define(Object, True)
+  assert.deepEqual(values.map(isObject),
+                   [ false, false, false, false, false ].
+                   concat(trues.slice(5, 13)).
+                   concat([false, false, false]),
+                   "all values except primitives inherit Object methods")
+
+}
+
+exports["test dispatch number"] = function(assert) {
+  var isNumber = Method("isNumber")
+  isNumber.define(False)
+  isNumber.define(Number, True)
+
+  assert.deepEqual(values.map(isNumber),
+                  falses.slice(0, 2).
+                  concat(true, true, true).
+                  concat(falses.slice(5)),
+                  "all numbers inherit from Number method")
+}
+
+exports["test dispatch string"] = function(assert) {
+  var isString = Method("isString")
+  isString.define(False)
+  isString.define(String, True)
+
+  assert.deepEqual(values.map(isString),
+                  falses.slice(0, 15).
+                  concat(true),
+                  "all strings inherit from String method")
+}
+
+exports["test dispatch function"] = function(assert) {
+  var isFunction = Method("isFunction")
+  isFunction.define(False)
+  isFunction.define(Function, True)
+
+  assert.deepEqual(values.map(isFunction),
+                  falses.slice(0, 11).
+                  concat(true, true).
+                  concat(falses.slice(13)),
+                  "all functions inherit from Function method")
+}
+
+exports["test dispatch date"] = function(assert) {
+  var isDate = Method("isDate")
+  isDate.define(False)
+  isDate.define(Date, True)
+
+  assert.deepEqual(values.map(isDate),
+                  falses.slice(0, 10).
+                  concat(true).
+                  concat(falses.slice(11)),
+                  "all dates inherit from Date method")
+}
+
+exports["test dispatch RegExp"] = function(assert) {
+  var isRegExp = Method("isRegExp")
+  isRegExp.define(False)
+  isRegExp.define(RegExp, True)
+
+  assert.deepEqual(values.map(isRegExp),
+                  falses.slice(0, 9).
+                  concat(true).
+                  concat(falses.slice(10)),
+                  "all regexps inherit from RegExp method")
+}
+
+exports["test redefine for descendant"] = function(assert) {
+  var isFoo = Method("isFoo")
+  var ancestor = {}
+  isFoo.implement(ancestor, function() { return true })
+  var descendant = Object.create(ancestor)
+  isFoo.implement(descendant, function() { return false })
+
+  assert.ok(isFoo(ancestor), "defined on ancestor")
+  assert.ok(!isFoo(descendant), "overrided for descendant")
+}
+
+exports["test on custom types"] = function(assert) {
+  function Bar() {}
+  var isBar = Method("isBar")
+
+  isBar.define(function() { return false })
+  isBar.define(Bar, function() { return true })
+
+  assert.ok(!isBar({}), "object is get's default implementation")
+  assert.ok(isBar(new Bar()), "Foo type objects get own implementation")
+
+  var isObject = Method("isObject")
+  isObject.define(function() { return false })
+  isObject.define(Object, function() { return true })
+
+  assert.ok(isObject(new Bar()), "foo inherits implementation from object")
+
+
+  isObject.define(Bar, function() { return false })
+
+  assert.ok(!isObject(new Bar()),
+            "implementation inherited form object can be overrided")
+}
+
+
+exports["test error types"] = function(assert) {
+  var isError = Method("isError")
+  isError.define(function() { return false })
+  isError.define(Error, function() { return true })
+
+  assert.ok(isError(Error("boom")), "error is error")
+  assert.ok(isError(TypeError("boom")), "type error is an error")
+  assert.ok(isError(EvalError("boom")), "eval error is an error")
+  assert.ok(isError(RangeError("boom")), "range error is an error")
+  assert.ok(isError(ReferenceError("boom")), "reference error is an error")
+  assert.ok(isError(SyntaxError("boom")), "syntax error is an error")
+  assert.ok(isError(URIError("boom")), "URI error is an error")
+}
+
+exports["test override define polymorphic method"] = function(assert) {
+  var define = Method.define
+  var implement = Method.implement
+
+  var fn = Method("fn")
+  var methods = {}
+  implement(define, fn, function(method, label, implementation) {
+    methods[label] = implementation
+  })
+
+  function foo() {}
+
+  define(fn, "foo-case", foo)
+
+  assert.equal(methods["foo-case"], foo, "define set property")
+}
+
+exports["test override define via method API"] = function(assert) {
+  var define = Method.define
+  var implement = Method.implement
+
+  var fn = Method("fn")
+  var methods = {}
+  define.implement(fn, function(method, label, implementation) {
+    methods[label] = implementation
+  })
+
+  function foo() {}
+
+  define(fn, "foo-case", foo)
+
+  assert.equal(methods["foo-case"], foo, "define set property")
+}
+
+require("test").run(exports)
diff --git a/toolkit/jetpack/modules/system/Startup.js b/toolkit/jetpack/modules/system/Startup.js
new file mode 100644
index 000000000..b9e5d88b3
--- /dev/null
+++ b/toolkit/jetpack/modules/system/Startup.js
@@ -0,0 +1,57 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+var EXPORTED_SYMBOLS = ["Startup"];
+
+var { utils: Cu, interfaces: Ci, classes: Cc } = Components;
+const { Services } = Cu.import("resource://gre/modules/Services.jsm", {});
+const { defer } = Cu.import("resource://gre/modules/Promise.jsm", {}).Promise;
+
+const { XulApp } = Cu.import("resource://gre/modules/commonjs/sdk/system/xul-app.jsm", {});
+
+const appStartupSrv = Cc["@mozilla.org/toolkit/app-startup;1"]
+                       .getService(Ci.nsIAppStartup);
+
+const NAME2TOPIC = {
+  'Firefox': 'sessionstore-windows-restored',
+  'Fennec': 'sessionstore-windows-restored',
+  'SeaMonkey': 'sessionstore-windows-restored',
+  'Thunderbird': 'mail-startup-done',
+  'Instantbird': 'xul-window-visible'
+};
+
+var Startup = {
+  initialized: !appStartupSrv.startingUp
+};
+var exports = Startup;
+
+var gOnceInitializedDeferred = defer();
+exports.onceInitialized = gOnceInitializedDeferred.promise;
+
+// Set 'final-ui-startup' as default topic for unknown applications
+var appStartup = 'final-ui-startup';
+
+if (Startup.initialized) {
+  gOnceInitializedDeferred.resolve()
+}
+else {
+  // Gets the topic that fit best as application startup event, in according with
+  // the current application (e.g. Firefox, Fennec, Thunderbird...)
+  for (let name of Object.keys(NAME2TOPIC)) {
+    if (XulApp.is(name)) {
+      appStartup = NAME2TOPIC[name];
+      break;
+    }
+  }
+
+  let listener = function (subject, topic) {
+    Services.obs.removeObserver(this, topic);
+    Startup.initialized = true;
+    Services.tm.currentThread.dispatch(() => gOnceInitializedDeferred.resolve(),
+                                       Ci.nsIThread.DISPATCH_NORMAL);
+  }
+
+  Services.obs.addObserver(listener, appStartup, false);
+}
diff --git a/toolkit/jetpack/modules/system/moz.build b/toolkit/jetpack/modules/system/moz.build
new file mode 100644
index 000000000..60fec1c9e
--- /dev/null
+++ b/toolkit/jetpack/modules/system/moz.build
@@ -0,0 +1,9 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXTRA_JS_MODULES.sdk.system += [
+    'Startup.js',
+]
diff --git a/toolkit/jetpack/moz.build b/toolkit/jetpack/moz.build
new file mode 100644
index 000000000..2024e6a7c
--- /dev/null
+++ b/toolkit/jetpack/moz.build
@@ -0,0 +1,481 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+EXTRA_JS_MODULES.sdk += [
+    'app-extension/bootstrap.js',
+]
+
+EXTRA_JS_MODULES.sdk.system += [
+    'modules/system/Startup.js',
+]
+
+if CONFIG['MOZ_WIDGET_TOOLKIT'] != "gonk":
+    EXTRA_JS_MODULES.commonjs.method.test += [
+        'method/test/browser.js',
+        'method/test/common.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.deprecated += [
+        'sdk/deprecated/api-utils.js',
+        'sdk/deprecated/sync-worker.js',
+        'sdk/deprecated/unit-test-finder.js',
+        'sdk/deprecated/unit-test.js',
+        'sdk/deprecated/window-utils.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.frame += [
+        'sdk/frame/hidden-frame.js',
+        'sdk/frame/utils.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.panel += [
+        'sdk/panel/events.js',
+        'sdk/panel/utils.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.places += [
+        'sdk/places/bookmarks.js',
+        'sdk/places/contract.js',
+        'sdk/places/events.js',
+        'sdk/places/favicon.js',
+        'sdk/places/history.js',
+        'sdk/places/utils.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.places.host += [
+        'sdk/places/host/host-bookmarks.js',
+        'sdk/places/host/host-query.js',
+        'sdk/places/host/host-tags.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.tabs += [
+        'sdk/tabs/common.js',
+        'sdk/tabs/events.js',
+        'sdk/tabs/helpers.js',
+        'sdk/tabs/namespace.js',
+        'sdk/tabs/observer.js',
+        'sdk/tabs/tab-fennec.js',
+        'sdk/tabs/tab-firefox.js',
+        'sdk/tabs/tab.js',
+        'sdk/tabs/tabs-firefox.js',
+        'sdk/tabs/utils.js',
+        'sdk/tabs/worker.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.test += [
+        'sdk/test/assert.js',
+        'sdk/test/harness.js',
+        'sdk/test/httpd.js',
+        'sdk/test/loader.js',
+        'sdk/test/memory.js',
+        'sdk/test/options.js',
+        'sdk/test/runner.js',
+        'sdk/test/utils.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.ui += [
+        'sdk/ui/component.js',
+        'sdk/ui/frame.js',
+        'sdk/ui/id.js',
+        'sdk/ui/sidebar.js',
+        'sdk/ui/state.js',
+        'sdk/ui/toolbar.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.ui.button += [
+        'sdk/ui/button/action.js',
+        'sdk/ui/button/contract.js',
+        'sdk/ui/button/toggle.js',
+        'sdk/ui/button/view.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.ui.sidebar += [
+        'sdk/ui/sidebar/actions.js',
+        'sdk/ui/sidebar/contract.js',
+        'sdk/ui/sidebar/namespace.js',
+        'sdk/ui/sidebar/utils.js',
+        'sdk/ui/sidebar/view.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.window += [
+        'sdk/window/browser.js',
+        'sdk/window/events.js',
+        'sdk/window/helpers.js',
+        'sdk/window/namespace.js',
+        'sdk/window/utils.js',
+    ]
+
+    EXTRA_JS_MODULES.commonjs.sdk.windows += [
+        'sdk/windows/fennec.js',
+        'sdk/windows/firefox.js',
+        'sdk/windows/observer.js',
+        'sdk/windows/tabs-fennec.js',
+    ]
+
+EXTRA_JS_MODULES.commonjs += [
+    'index.js',
+    'test.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk += [
+    'sdk/webextension.js',
+]
+
+EXTRA_JS_MODULES.commonjs.dev += [
+    'dev/debuggee.js',
+    'dev/frame-script.js',
+    'dev/panel.js',
+    'dev/ports.js',
+    'dev/theme.js',
+    'dev/toolbox.js',
+    'dev/utils.js',
+    'dev/volcan.js',
+]
+
+EXTRA_JS_MODULES.commonjs.dev.panel += [
+    'dev/panel/view.js',
+]
+
+EXTRA_JS_MODULES.commonjs.dev.theme += [
+    'dev/theme/hooks.js',
+]
+
+EXTRA_JS_MODULES.commonjs.diffpatcher += [
+    'diffpatcher/diff.js',
+    'diffpatcher/index.js',
+    'diffpatcher/patch.js',
+    'diffpatcher/rebase.js',
+]
+
+EXTRA_JS_MODULES.commonjs.diffpatcher.test += [
+    'diffpatcher/test/common.js',
+    'diffpatcher/test/diff.js',
+    'diffpatcher/test/index.js',
+    'diffpatcher/test/patch.js',
+    'diffpatcher/test/tap.js',
+]
+
+EXTRA_JS_MODULES.commonjs.framescript += [
+    'framescript/content.jsm',
+    'framescript/context-menu.js',
+    'framescript/FrameScriptManager.jsm',
+    'framescript/manager.js',
+    'framescript/util.js',
+]
+
+EXTRA_JS_MODULES.commonjs['jetpack-id'] += [
+    'jetpack-id/index.js',
+]
+
+EXTRA_JS_MODULES.commonjs.method += [
+    'method/core.js',
+]
+
+EXTRA_JS_MODULES.commonjs['mozilla-toolkit-versioning'] += [
+    'mozilla-toolkit-versioning/index.js',
+]
+
+EXTRA_JS_MODULES.commonjs['mozilla-toolkit-versioning'].lib += [
+    'mozilla-toolkit-versioning/lib/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.node += [
+    'node/os.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk += [
+    'sdk/base64.js',
+    'sdk/clipboard.js',
+    'sdk/context-menu.js',
+    'sdk/context-menu@2.js',
+    'sdk/hotkeys.js',
+    'sdk/indexed-db.js',
+    'sdk/l10n.js',
+    'sdk/messaging.js',
+    'sdk/notifications.js',
+    'sdk/page-mod.js',
+    'sdk/page-worker.js',
+    'sdk/panel.js',
+    'sdk/passwords.js',
+    'sdk/private-browsing.js',
+    'sdk/querystring.js',
+    'sdk/request.js',
+    'sdk/selection.js',
+    'sdk/self.js',
+    'sdk/simple-prefs.js',
+    'sdk/simple-storage.js',
+    'sdk/system.js',
+    'sdk/tabs.js',
+    'sdk/test.js',
+    'sdk/timers.js',
+    'sdk/ui.js',
+    'sdk/url.js',
+    'sdk/windows.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.addon += [
+    'sdk/addon/bootstrap.js',
+    'sdk/addon/events.js',
+    'sdk/addon/host.js',
+    'sdk/addon/installer.js',
+    'sdk/addon/manager.js',
+    'sdk/addon/runner.js',
+    'sdk/addon/window.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.browser += [
+    'sdk/browser/events.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.console += [
+    'sdk/console/plain-text.js',
+    'sdk/console/traceback.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.content += [
+    'sdk/content/content-worker.js',
+    'sdk/content/content.js',
+    'sdk/content/context-menu.js',
+    'sdk/content/events.js',
+    'sdk/content/l10n-html.js',
+    'sdk/content/loader.js',
+    'sdk/content/mod.js',
+    'sdk/content/page-mod.js',
+    'sdk/content/page-worker.js',
+    'sdk/content/sandbox.js',
+    'sdk/content/tab-events.js',
+    'sdk/content/thumbnail.js',
+    'sdk/content/utils.js',
+    'sdk/content/worker-child.js',
+    'sdk/content/worker.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.content.sandbox += [
+    'sdk/content/sandbox/events.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk['context-menu'] += [
+    'sdk/context-menu/context.js',
+    'sdk/context-menu/core.js',
+    'sdk/context-menu/readers.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.core += [
+    'sdk/core/disposable.js',
+    'sdk/core/heritage.js',
+    'sdk/core/namespace.js',
+    'sdk/core/observer.js',
+    'sdk/core/promise.js',
+    'sdk/core/reference.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.deprecated.events += [
+    'sdk/deprecated/events/assembler.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.dom += [
+    'sdk/dom/events-shimmed.js',
+    'sdk/dom/events.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.dom.events += [
+    'sdk/dom/events/keys.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.event += [
+    'sdk/event/chrome.js',
+    'sdk/event/core.js',
+    'sdk/event/dom.js',
+    'sdk/event/target.js',
+    'sdk/event/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.fs += [
+    'sdk/fs/path.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.input += [
+    'sdk/input/browser.js',
+    'sdk/input/customizable-ui.js',
+    'sdk/input/frame.js',
+    'sdk/input/system.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.io += [
+    'sdk/io/buffer.js',
+    'sdk/io/byte-streams.js',
+    'sdk/io/file.js',
+    'sdk/io/fs.js',
+    'sdk/io/stream.js',
+    'sdk/io/text-streams.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.keyboard += [
+    'sdk/keyboard/hotkeys.js',
+    'sdk/keyboard/observer.js',
+    'sdk/keyboard/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.l10n += [
+    'sdk/l10n/core.js',
+    'sdk/l10n/html.js',
+    'sdk/l10n/loader.js',
+    'sdk/l10n/locale.js',
+    'sdk/l10n/plural-rules.js',
+    'sdk/l10n/prefs.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.l10n.json += [
+    'sdk/l10n/json/core.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.l10n.properties += [
+    'sdk/l10n/properties/core.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.lang += [
+    'sdk/lang/functional.js',
+    'sdk/lang/type.js',
+    'sdk/lang/weak-set.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.lang.functional += [
+    'sdk/lang/functional/concurrent.js',
+    'sdk/lang/functional/core.js',
+    'sdk/lang/functional/helpers.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.loader += [
+    'sdk/loader/cuddlefish.js',
+    'sdk/loader/sandbox.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.model += [
+    'sdk/model/core.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.net += [
+    'sdk/net/url.js',
+    'sdk/net/xhr.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.output += [
+    'sdk/output/system.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk['page-mod'] += [
+    'sdk/page-mod/match-pattern.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.passwords += [
+    'sdk/passwords/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.platform += [
+    'sdk/platform/xpcom.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.preferences += [
+    'sdk/preferences/event-target.js',
+    'sdk/preferences/native-options.js',
+    'sdk/preferences/service.js',
+    'sdk/preferences/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk['private-browsing'] += [
+    'sdk/private-browsing/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.remote += [
+    'sdk/remote/child.js',
+    'sdk/remote/core.js',
+    'sdk/remote/parent.js',
+    'sdk/remote/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.stylesheet += [
+    'sdk/stylesheet/style.js',
+    'sdk/stylesheet/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.system += [
+    'sdk/system/child_process.js',
+    'sdk/system/environment.js',
+    'sdk/system/events-shimmed.js',
+    'sdk/system/events.js',
+    'sdk/system/globals.js',
+    'sdk/system/process.js',
+    'sdk/system/runtime.js',
+    'sdk/system/unload.js',
+    'sdk/system/xul-app.js',
+    'sdk/system/xul-app.jsm',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.system.child_process += [
+    'sdk/system/child_process/subprocess.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.tab += [
+    'sdk/tab/events.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.ui.button.view += [
+    'sdk/ui/button/view/events.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.ui.frame += [
+    'sdk/ui/frame/model.js',
+    'sdk/ui/frame/view.html',
+    'sdk/ui/frame/view.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.ui.state += [
+    'sdk/ui/state/events.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.ui.toolbar += [
+    'sdk/ui/toolbar/model.js',
+    'sdk/ui/toolbar/view.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.uri += [
+    'sdk/uri/resource.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.url += [
+    'sdk/url/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.util += [
+    'sdk/util/array.js',
+    'sdk/util/collection.js',
+    'sdk/util/contract.js',
+    'sdk/util/deprecate.js',
+    'sdk/util/dispatcher.js',
+    'sdk/util/list.js',
+    'sdk/util/match-pattern.js',
+    'sdk/util/object.js',
+    'sdk/util/rules.js',
+    'sdk/util/sequence.js',
+    'sdk/util/uuid.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.view += [
+    'sdk/view/core.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.worker += [
+    'sdk/worker/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.sdk.zip += [
+    'sdk/zip/utils.js',
+]
+
+EXTRA_JS_MODULES.commonjs.toolkit += [
+    'toolkit/loader.js',
+    'toolkit/require.js',
+]
diff --git a/toolkit/jetpack/mozilla-toolkit-versioning/index.js b/toolkit/jetpack/mozilla-toolkit-versioning/index.js
new file mode 100644
index 000000000..2f607c880
--- /dev/null
+++ b/toolkit/jetpack/mozilla-toolkit-versioning/index.js
@@ -0,0 +1,112 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+var versionParse = require('./lib/utils').versionParse;
+
+var COMPARATORS = ['>=', '<=', '>', '<', '=', '~', '^'];
+
+exports.parse = function (input) {
+  input = input || '';
+  input = input.trim();
+  if (!input)
+    throw new Error('`parse` argument must be a populated string.');
+
+  // Handle the "*" case
+  if (input === "*") {
+    return { min: undefined, max: undefined };
+  }
+
+  var inputs = input.split(' ');
+  var min;
+  var max;
+
+  // 1.2.3 - 2.3.4
+  if (inputs.length === 3 && inputs[1] === '-') {
+    return { min: inputs[0], max: inputs[2] };
+  }
+
+  inputs.forEach(function (input) {
+    var parsed = parseExpression(input);
+    var version = parsed.version;
+    var comparator = parsed.comparator;
+
+    // 1.2.3
+    if (inputs.length === 1 && !comparator)
+      min = max = version;
+
+    // Parse min
+    if (~comparator.indexOf('>')) {
+      if (~comparator.indexOf('='))
+        min = version; // >=1.2.3
+      else
+        min = increment(version); // >1.2.3
+    }
+    else if (~comparator.indexOf('<')) {
+      if (~comparator.indexOf('='))
+        max = version; // <=1.2.3
+      else
+        max = decrement(version); // <1.2.3
+    }
+  });
+
+  return {
+    min: min,
+    max : max
+  };
+};
+
+function parseExpression (input) {
+  for (var i = 0; i < COMPARATORS.length; i++)
+    if (~input.indexOf(COMPARATORS[i]))
+      return {
+        comparator: COMPARATORS[i],
+        version: input.substr(COMPARATORS[i].length)
+      };
+  return { version: input, comparator: '' };
+}
+
+/**
+ * Takes a version string ('1.2.3') and returns a version string
+ * that'll parse as one less than the input string ('1.2.3.-1').
+ *
+ * @param {String} vString
+ * @return {String}
+ */
+function decrement (vString) {
+  return vString + (vString.charAt(vString.length - 1) === '.' ? '' : '.') + '-1';
+}
+exports.decrement = decrement;
+
+/**
+ * Takes a version string ('1.2.3') and returns a version string
+ * that'll parse as greater than the input string by the smallest margin
+ * possible ('1.2.3.1').
+ * listed as number-A, string-B, number-C, string-D in
+ * Mozilla's Toolkit Format.
+ * https://developer.mozilla.org/en-US/docs/Toolkit_version_format
+ *
+ * @param {String} vString
+ * @return {String}
+ */
+function increment (vString) {
+  var match = versionParse(vString);
+  var a = match[1];
+  var b = match[2];
+  var c = match[3];
+  var d = match[4];
+  var lastPos = vString.length - 1;
+  var lastChar = vString.charAt(lastPos);
+
+  if (!b) {
+    return vString + (lastChar === '.' ? '' : '.') + '1';
+  }
+  if (!c) {
+    return vString + '1';
+  }
+  if (!d) {
+    return vString.substr(0, lastPos) + (++lastChar);
+  }
+  return vString.substr(0, lastPos) + String.fromCharCode(lastChar.charCodeAt(0) + 1);
+}
+exports.increment = increment;
diff --git a/toolkit/jetpack/mozilla-toolkit-versioning/lib/utils.js b/toolkit/jetpack/mozilla-toolkit-versioning/lib/utils.js
new file mode 100644
index 000000000..e068085c0
--- /dev/null
+++ b/toolkit/jetpack/mozilla-toolkit-versioning/lib/utils.js
@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Breaks up a version string into the 4 components
+ * defined in:
+ * https://developer.mozilla.org/en-US/docs/Toolkit_version_format
+ * @params {String} val
+ * @return {String}
+ */
+function versionParse (val) {
+  return val.match(/^([0-9\.]*)([a-zA-Z]*)([0-9\.]*)([a-zA-Z]*)$/);
+}
+exports.versionParse = versionParse;
diff --git a/toolkit/jetpack/mozilla-toolkit-versioning/package.json b/toolkit/jetpack/mozilla-toolkit-versioning/package.json
new file mode 100644
index 000000000..d9b0424e5
--- /dev/null
+++ b/toolkit/jetpack/mozilla-toolkit-versioning/package.json
@@ -0,0 +1,21 @@
+{
+  "name": "mozilla-toolkit-versioning",
+  "version": "0.0.2",
+  "description": "Parser for Mozilla's toolkit version format",
+  "main": "index.js",
+  "scripts": {
+    "test": "./node_modules/.bin/mocha --reporter spec --ui bdd"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jsantell/mozilla-toolkit-versioning.git"
+  },
+  "author": "Jordan Santell",
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "mocha": "^1.21.4",
+    "chai": "^1.9.1",
+    "mozilla-version-comparator": "^1.0.2"
+  }
+}
diff --git a/toolkit/jetpack/node/os.js b/toolkit/jetpack/node/os.js
new file mode 100644
index 000000000..1c41a9246
--- /dev/null
+++ b/toolkit/jetpack/node/os.js
@@ -0,0 +1,90 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci } = require('chrome');
+const system = require('../sdk/system');
+const runtime = require('../sdk/system/runtime');
+const { XPCOMUtils } = require("resource://gre/modules/XPCOMUtils.jsm");
+const isWindows = system.platform === 'win32';
+const endianness = ((new Uint32Array((new Uint8Array([1,2,3,4])).buffer))[0] === 0x04030201) ? 'LE' : 'BE';
+
+XPCOMUtils.defineLazyGetter(this, "oscpu", () => {
+  try {
+    return Cc["@mozilla.org/network/protocol;1?name=http"].getService(Ci.nsIHttpProtocolHandler).oscpu;
+  } catch (e) {
+    return "";
+  }
+});
+
+XPCOMUtils.defineLazyGetter(this, "hostname", () => {
+  try {
+    // On some platforms (Linux according to try), this service does not exist and fails.
+    return Cc["@mozilla.org/network/dns-service;1"].getService(Ci.nsIDNSService).myHostName;
+  } catch (e) {
+    return "";
+  }
+});
+
+/**
+ * Returns a path to a temp directory
+ */
+exports.tmpdir = () => system.pathFor('TmpD');
+
+/**
+ * Returns the endianness of the architecture: either 'LE' or 'BE'
+ */
+exports.endianness = () => endianness;
+
+/**
+ * Returns hostname of the machine
+ */
+exports.hostname = () => hostname;
+
+/**
+ * Name of the OS type
+ * Possible values:
+ * https://developer.mozilla.org/en/OS_TARGET
+ */
+exports.type = () => runtime.OS;
+
+/**
+ * Name of the OS Platform in lower case string.
+ * Possible values:
+ * https://developer.mozilla.org/en/OS_TARGET
+ */
+exports.platform = () => system.platform;
+
+/**
+ * Type of processor architecture running:
+ * 'arm', 'ia32', 'x86', 'x64'
+ */
+exports.arch = () => system.architecture;
+
+/**
+ * Returns the operating system release.
+ */
+exports.release = () => {
+  let match = oscpu.match(/(\d[\.\d]*)/);
+  return match && match.length > 1 ? match[1] : oscpu;
+};
+
+/**
+ * Returns EOL character for the OS
+ */
+exports.EOL = isWindows ? '\r\n' : '\n';
+
+/**
+ * Returns [0, 0, 0], as this is not implemented.
+ */
+exports.loadavg = () => [0, 0, 0];
+
+['uptime', 'totalmem', 'freemem', 'cpus'].forEach(method => {
+  exports[method] = () => { throw new Error('os.' + method + ' is not supported.'); };
+});
diff --git a/toolkit/jetpack/sdk/addon/bootstrap.js b/toolkit/jetpack/sdk/addon/bootstrap.js
new file mode 100644
index 000000000..0397d91e5
--- /dev/null
+++ b/toolkit/jetpack/sdk/addon/bootstrap.js
@@ -0,0 +1,182 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Cu } = require("chrome");
+const { NetUtil } = require("resource://gre/modules/NetUtil.jsm");
+const { Task: { spawn } } = require("resource://gre/modules/Task.jsm");
+const { readURI } = require("sdk/net/url");
+const { mount, unmount } = require("sdk/uri/resource");
+const { setTimeout } = require("sdk/timers");
+const { Loader, Require, Module, main, unload } = require("toolkit/loader");
+const prefs = require("sdk/preferences/service");
+
+// load below now, so that it can be used by sdk/addon/runner
+// see bug https://bugzilla.mozilla.org/show_bug.cgi?id=1042239
+const Startup = Cu.import("resource://gre/modules/sdk/system/Startup.js", {});
+
+const REASON = [ "unknown", "startup", "shutdown", "enable", "disable",
+                 "install", "uninstall", "upgrade", "downgrade" ];
+
+const UUID_PATTERN = /^\{([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\}$/;
+// Takes add-on ID and normalizes it to a domain name so that add-on
+// can be mapped to resource://domain/
+const readDomain = id =>
+  // If only `@` character is the first one, than just substract it,
+  // otherwise fallback to legacy normalization code path. Note: `.`
+  // is valid character for resource substitutaiton & we intend to
+  // make add-on URIs intuitive, so it's best to just stick to an
+  // add-on author typed input.
+  id.lastIndexOf("@") === 0 ? id.substr(1).toLowerCase() :
+  id.toLowerCase().
+     replace(/@/g, "-at-").
+     replace(/\./g, "-dot-").
+     replace(UUID_PATTERN, "$1");
+
+const readPaths = id => {
+  const base = `extensions.modules.${id}.path.`;
+  const domain = readDomain(id);
+  return prefs.keys(base).reduce((paths, key) => {
+    const value = prefs.get(key);
+    const name = key.replace(base, "");
+    const path = name.split(".").join("/");
+    const prefix = path.length ? `${path}/` : path;
+    const uri = value.endsWith("/") ? value : `${value}/`;
+    const root = `extensions.modules.${domain}.commonjs.path.${name}`;
+
+    mount(root, uri);
+
+    paths[prefix] = `resource://${root}/`;
+    return paths;
+  }, {});
+};
+
+const Bootstrap = function(mountURI) {
+  this.mountURI = mountURI;
+  this.install = this.install.bind(this);
+  this.uninstall = this.uninstall.bind(this);
+  this.startup = this.startup.bind(this);
+  this.shutdown = this.shutdown.bind(this);
+};
+Bootstrap.prototype = {
+  constructor: Bootstrap,
+  mount(domain, rootURI) {
+    mount(domain, rootURI);
+    this.domain = domain;
+  },
+  unmount() {
+    if (this.domain) {
+      unmount(this.domain);
+      this.domain = null;
+    }
+  },
+  install(addon, reason) {
+    return new Promise(resolve => resolve());
+  },
+  uninstall(addon, reason) {
+    return new Promise(resolve => {
+      const {id} = addon;
+
+      prefs.reset(`extensions.${id}.sdk.domain`);
+      prefs.reset(`extensions.${id}.sdk.version`);
+      prefs.reset(`extensions.${id}.sdk.rootURI`);
+      prefs.reset(`extensions.${id}.sdk.baseURI`);
+      prefs.reset(`extensions.${id}.sdk.load.reason`);
+
+      resolve();
+    });
+  },
+  startup(addon, reasonCode) {
+    const { id, version, resourceURI: { spec: addonURI } } = addon;
+    const rootURI = this.mountURI || addonURI;
+    const reason = REASON[reasonCode];
+    const self = this;
+
+    return spawn(function*() {
+      const metadata = JSON.parse(yield readURI(`${rootURI}package.json`));
+      const domain = readDomain(id);
+      const baseURI = `resource://${domain}/`;
+
+      this.mount(domain, rootURI);
+
+      prefs.set(`extensions.${id}.sdk.domain`, domain);
+      prefs.set(`extensions.${id}.sdk.version`, version);
+      prefs.set(`extensions.${id}.sdk.rootURI`, rootURI);
+      prefs.set(`extensions.${id}.sdk.baseURI`, baseURI);
+      prefs.set(`extensions.${id}.sdk.load.reason`, reason);
+
+      const command = prefs.get(`extensions.${id}.sdk.load.command`);
+
+      const loader = Loader({
+        id,
+        isNative: true,
+        checkCompatibility: true,
+        prefixURI: baseURI,
+        rootURI: baseURI,
+        name: metadata.name,
+        paths: Object.assign({
+          "": "resource://gre/modules/commonjs/",
+          "devtools/": "resource://devtools/",
+          "./": baseURI
+        }, readPaths(id)),
+        manifest: metadata,
+        metadata: metadata,
+        modules: {
+          "@test/options": {},
+        },
+        noQuit: prefs.get(`extensions.${id}.sdk.test.no-quit`, false)
+      });
+      self.loader = loader;
+
+      const module = Module("package.json", `${baseURI}package.json`);
+      const require = Require(loader, module);
+      const main = command === "test" ? "sdk/test/runner" : null;
+      const prefsURI = `${baseURI}defaults/preferences/prefs.js`;
+
+      // Init the 'sdk/webextension' module from the bootstrap addon parameter.
+      require("sdk/webextension").initFromBootstrapAddonParam(addon);
+
+      const { startup } = require("sdk/addon/runner");
+      startup(reason, {loader, main, prefsURI});
+    }.bind(this)).catch(error => {
+      console.error(`Failed to start ${id} addon`, error);
+      throw error;
+    });
+  },
+  shutdown(addon, code) {
+    this.unmount();
+    return this.unload(REASON[code]);
+  },
+  unload(reason) {
+    return new Promise(resolve => {
+      const { loader } = this;
+      if (loader) {
+        this.loader = null;
+        unload(loader, reason);
+
+        setTimeout(() => {
+          for (let uri of Object.keys(loader.sandboxes)) {
+            let sandbox = loader.sandboxes[uri];
+            if (Cu.getClassName(sandbox, true) == "Sandbox")
+              Cu.nukeSandbox(sandbox);
+            delete loader.sandboxes[uri];
+            delete loader.modules[uri];
+          }
+
+          try {
+            Cu.nukeSandbox(loader.sharedGlobalSandbox);
+          } catch (e) {
+            Cu.reportError(e);
+          }
+
+          resolve();
+        }, 1000);
+      }
+      else {
+        resolve();
+      }
+    });
+  }
+};
+exports.Bootstrap = Bootstrap;
diff --git a/toolkit/jetpack/sdk/addon/events.js b/toolkit/jetpack/sdk/addon/events.js
new file mode 100644
index 000000000..45bada6e1
--- /dev/null
+++ b/toolkit/jetpack/sdk/addon/events.js
@@ -0,0 +1,56 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental'
+};
+
+var { request: hostReq, response: hostRes } = require('./host');
+var { defer: async } = require('../lang/functional');
+var { defer } = require('../core/promise');
+var { emit: emitSync, on, off } = require('../event/core');
+var { uuid } = require('../util/uuid');
+var emit = async(emitSync);
+
+// Map of IDs to deferreds
+var requests = new Map();
+
+// May not be necessary to wrap this in `async`
+// once promises are async via bug 881047
+var receive = async(function ({data, id, error}) {
+  let request = requests.get(id);
+  if (request) {
+    if (error) request.reject(error);
+    else request.resolve(clone(data));
+    requests.delete(id);
+  }
+});
+on(hostRes, 'data', receive);
+
+/*
+ * Send is a helper to be used in client APIs to send
+ * a request to host
+ */
+function send (eventName, data) {
+  let id = uuid();
+  let deferred = defer();
+  requests.set(id, deferred);
+  emit(hostReq, 'data', {
+    id: id,
+    data: clone(data),
+    event: eventName
+  });
+  return deferred.promise;
+}
+exports.send = send;
+
+/*
+ * Implement internal structured cloning algorithm in the future?
+ * http://www.whatwg.org/specs/web-apps/current-work/multipage/common-dom-interfaces.html#internal-structured-cloning-algorithm
+ */
+function clone (obj) {
+  return JSON.parse(JSON.stringify(obj || {}));
+}
diff --git a/toolkit/jetpack/sdk/addon/host.js b/toolkit/jetpack/sdk/addon/host.js
new file mode 100644
index 000000000..91aa0e869
--- /dev/null
+++ b/toolkit/jetpack/sdk/addon/host.js
@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+exports.request = {};
+exports.response = {};
diff --git a/toolkit/jetpack/sdk/addon/installer.js b/toolkit/jetpack/sdk/addon/installer.js
new file mode 100644
index 000000000..bb8cf8d16
--- /dev/null
+++ b/toolkit/jetpack/sdk/addon/installer.js
@@ -0,0 +1,121 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci, Cu } = require("chrome");
+const { AddonManager } = Cu.import("resource://gre/modules/AddonManager.jsm");
+const { defer } = require("../core/promise");
+const { setTimeout } = require("../timers");
+
+/**
+ * `install` method error codes:
+ *
+ * https://developer.mozilla.org/en/Addons/Add-on_Manager/AddonManager#AddonInstall_errors
+ */
+exports.ERROR_NETWORK_FAILURE = AddonManager.ERROR_NETWORK_FAILURE;
+exports.ERROR_INCORRECT_HASH = AddonManager.ERROR_INCORRECT_HASH;
+exports.ERROR_CORRUPT_FILE = AddonManager.ERROR_CORRUPT_FILE;
+exports.ERROR_FILE_ACCESS = AddonManager.ERROR_FILE_ACCESS;
+
+/**
+ * Immediatly install an addon.
+ *
+ * @param {String} xpiPath
+ *   file path to an xpi file to install
+ * @return {Promise}
+ *   A promise resolved when the addon is finally installed.
+ *   Resolved with addon id as value or rejected with an error code.
+ */
+exports.install = function install(xpiPath) {
+  let { promise, resolve, reject } = defer();
+
+  // Create nsIFile for the xpi file
+  let file = Cc['@mozilla.org/file/local;1'].createInstance(Ci.nsILocalFile);
+  try {
+    file.initWithPath(xpiPath);
+  }
+  catch(e) {
+    reject(exports.ERROR_FILE_ACCESS);
+    return promise;
+  }
+
+  // Listen for installation end
+  let listener = {
+    onInstallEnded: function(aInstall, aAddon) {
+      aInstall.removeListener(listener);
+      // Bug 749745: on FF14+, onInstallEnded is called just before `startup()`
+      // is called, but we expect to resolve the promise only after it.
+      // As startup is called synchronously just after onInstallEnded,
+      // a simple setTimeout(0) is enough
+      setTimeout(resolve, 0, aAddon.id);
+    },
+    onInstallFailed: function (aInstall) {
+      aInstall.removeListener(listener);
+      reject(aInstall.error);
+    },
+    onDownloadFailed: function(aInstall) {
+      this.onInstallFailed(aInstall);
+    }
+  };
+
+  // Order AddonManager to install the addon
+  AddonManager.getInstallForFile(file, function(install) {
+    if (install.error == 0) {
+      install.addListener(listener);
+      install.install();
+    } else {
+      reject(install.error);
+    }
+  });
+
+  return promise;
+};
+
+exports.uninstall = function uninstall(addonId) {
+  let { promise, resolve, reject } = defer();
+
+  // Listen for uninstallation end
+  let listener = {
+    onUninstalled: function onUninstalled(aAddon) {
+      if (aAddon.id != addonId)
+        return;
+      AddonManager.removeAddonListener(listener);
+      resolve();
+    }
+  };
+  AddonManager.addAddonListener(listener);
+
+  // Order Addonmanager to uninstall the addon
+  getAddon(addonId).then(addon => addon.uninstall(), reject);
+
+  return promise;
+};
+
+exports.disable = function disable(addonId) {
+  return getAddon(addonId).then(addon => {
+    addon.userDisabled = true;
+    return addonId;
+  });
+};
+
+exports.enable = function enabled(addonId) {
+  return getAddon(addonId).then(addon => {
+    addon.userDisabled = false;
+    return addonId;
+  });
+};
+
+exports.isActive = function isActive(addonId) {
+  return getAddon(addonId).then(addon => addon.isActive && !addon.appDisabled);
+};
+
+const getAddon = function getAddon (id) {
+  let { promise, resolve, reject } = defer();
+  AddonManager.getAddonByID(id, addon => addon ? resolve(addon) : reject());
+  return promise;
+}
+exports.getAddon = getAddon;
diff --git a/toolkit/jetpack/sdk/addon/manager.js b/toolkit/jetpack/sdk/addon/manager.js
new file mode 100644
index 000000000..7ac0a7d6e
--- /dev/null
+++ b/toolkit/jetpack/sdk/addon/manager.js
@@ -0,0 +1,18 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { AddonManager } = require("resource://gre/modules/AddonManager.jsm");
+const { defer } = require("../core/promise");
+
+function getAddonByID(id) {
+  let { promise, resolve } = defer();
+  AddonManager.getAddonByID(id, resolve);
+  return promise;
+}
+exports.getAddonByID = getAddonByID;
diff --git a/toolkit/jetpack/sdk/addon/runner.js b/toolkit/jetpack/sdk/addon/runner.js
new file mode 100644
index 000000000..3977a04e4
--- /dev/null
+++ b/toolkit/jetpack/sdk/addon/runner.js
@@ -0,0 +1,180 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci, Cu } = require('chrome');
+const { rootURI, metadata, isNative } = require('@loader/options');
+const { id, loadReason } = require('../self');
+const { descriptor, Sandbox, evaluate, main, resolveURI } = require('toolkit/loader');
+const { once } = require('../system/events');
+const { exit, env, staticArgs } = require('../system');
+const { when: unload } = require('../system/unload');
+const globals = require('../system/globals');
+const xulApp = require('../system/xul-app');
+const { get } = require('../preferences/service');
+const appShellService = Cc['@mozilla.org/appshell/appShellService;1'].
+                        getService(Ci.nsIAppShellService);
+const { preferences } = metadata;
+
+const Startup = Cu.import("resource://gre/modules/sdk/system/Startup.js", {}).exports;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyGetter(this, "BrowserToolboxProcess", function () {
+  return Cu.import("resource://devtools/client/framework/ToolboxProcess.jsm", {}).
+         BrowserToolboxProcess;
+});
+
+// Initializes default preferences
+function setDefaultPrefs(prefsURI) {
+  const prefs = Cc['@mozilla.org/preferences-service;1'].
+                getService(Ci.nsIPrefService).
+                QueryInterface(Ci.nsIPrefBranch2);
+  const branch = prefs.getDefaultBranch('');
+  const sandbox = Sandbox({
+    name: prefsURI,
+    prototype: {
+      pref: function(key, val) {
+        switch (typeof val) {
+          case 'boolean':
+            branch.setBoolPref(key, val);
+            break;
+          case 'number':
+            if (val % 1 == 0) // number must be a integer, otherwise ignore it
+              branch.setIntPref(key, val);
+            break;
+          case 'string':
+            branch.setCharPref(key, val);
+            break;
+        }
+      }
+    }
+  });
+  // load preferences.
+  evaluate(sandbox, prefsURI);
+}
+
+function definePseudo(loader, id, exports) {
+  let uri = resolveURI(id, loader.mapping);
+  loader.modules[uri] = { exports: exports };
+}
+
+function startup(reason, options) {
+  return Startup.onceInitialized.then(() => {
+    // Inject globals ASAP in order to have console API working ASAP
+    Object.defineProperties(options.loader.globals, descriptor(globals));
+
+    // NOTE: Module is intentionally required only now because it relies
+    // on existence of hidden window, which does not exists until startup.
+    let { ready } = require('../addon/window');
+    // Load localization manifest and .properties files.
+    // Run the addon even in case of error (best effort approach)
+    require('../l10n/loader').
+      load(rootURI).
+      then(null, function failure(error) {
+        if (!isNative)
+          console.info("Error while loading localization: " + error.message);
+      }).
+      then(function onLocalizationReady(data) {
+        // Exports data to a pseudo module so that api-utils/l10n/core
+        // can get access to it
+        definePseudo(options.loader, '@l10n/data', data ? data : null);
+        return ready;
+      }).then(function() {
+        run(options);
+      }).then(null, console.exception);
+    return void 0; // otherwise we raise a warning, see bug 910304
+  });
+}
+
+function run(options) {
+  try {
+    // Try initializing HTML localization before running main module. Just print
+    // an exception in case of error, instead of preventing addon to be run.
+    try {
+      // Do not enable HTML localization while running test as it is hard to
+      // disable. Because unit tests are evaluated in a another Loader who
+      // doesn't have access to this current loader.
+      if (options.main !== 'sdk/test/runner') {
+        require('../l10n/html').enable();
+      }
+    }
+    catch(error) {
+      console.exception(error);
+    }
+
+    // native-options does stuff directly with preferences key from package.json
+    if (preferences && preferences.length > 0) {
+      try {
+        require('../preferences/native-options').
+          enable({ preferences: preferences, id: id }).
+          catch(console.exception);
+      }
+      catch (error) {
+        console.exception(error);
+      }
+    }
+    else {
+      // keeping support for addons packaged with older SDK versions,
+      // when cfx didn't include the 'preferences' key in @loader/options
+
+      // Initialize inline options localization, without preventing addon to be
+      // run in case of error
+      try {
+        require('../l10n/prefs').enable();
+      }
+      catch(error) {
+        console.exception(error);
+      }
+
+      // TODO: When bug 564675 is implemented this will no longer be needed
+      // Always set the default prefs, because they disappear on restart
+      if (options.prefsURI) {
+        // Only set if `prefsURI` specified
+        try {
+          setDefaultPrefs(options.prefsURI);
+        }
+        catch (err) {
+          // cfx bootstrap always passes prefsURI, even in addons without prefs
+        }
+      }
+    }
+
+    // this is where the addon's main.js finally run.
+    let program = main(options.loader, options.main);
+
+    if (typeof(program.onUnload) === 'function')
+      unload(program.onUnload);
+
+    if (typeof(program.main) === 'function') {
+      program.main({
+        loadReason: loadReason,
+        staticArgs: staticArgs
+      }, {
+        print: function print(_) { dump(_ + '\n') },
+        quit: exit
+      });
+    }
+
+    if (get("extensions." + id + ".sdk.debug.show", false)) {
+      BrowserToolboxProcess.init({ addonID: id });
+    }
+  } catch (error) {
+    console.exception(error);
+    throw error;
+  }
+}
+exports.startup = startup;
+
+// If add-on is lunched via `cfx run` we need to use `system.exit` to let
+// cfx know we're done (`cfx test` will take care of exit so we don't do
+// anything here).
+if (env.CFX_COMMAND === 'run') {
+  unload(function(reason) {
+    if (reason === 'shutdown')
+      exit(0);
+  });
+}
diff --git a/toolkit/jetpack/sdk/addon/window.js b/toolkit/jetpack/sdk/addon/window.js
new file mode 100644
index 000000000..93ed1d8dc
--- /dev/null
+++ b/toolkit/jetpack/sdk/addon/window.js
@@ -0,0 +1,66 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Ci, Cc } = require("chrome");
+const { make: makeWindow, getHiddenWindow } = require("../window/utils");
+const { create: makeFrame, getDocShell } = require("../frame/utils");
+const { defer } = require("../core/promise");
+const { when: unload } = require("../system/unload");
+const cfxArgs = require("../test/options");
+
+var addonPrincipal = Cc["@mozilla.org/systemprincipal;1"].
+                     createInstance(Ci.nsIPrincipal);
+
+var hiddenWindow = getHiddenWindow();
+
+if (cfxArgs.parseable) {
+  console.info("hiddenWindow document.documentURI:" +
+    hiddenWindow.document.documentURI);
+  console.info("hiddenWindow document.readyState:" +
+    hiddenWindow.document.readyState);
+}
+
+// Once Bug 565388 is fixed and shipped we'll be able to make invisible,
+// permanent docShells. Meanwhile we create hidden top level window and
+// use it's docShell.
+var frame = makeFrame(hiddenWindow.document, {
+  nodeName: "iframe",
+  namespaceURI: "http://www.w3.org/1999/xhtml",
+  allowJavascript: true,
+  allowPlugins: true
+})
+var docShell = getDocShell(frame);
+var eventTarget = docShell.chromeEventHandler;
+
+// We need to grant docShell system principals in order to load XUL document
+// from data URI into it.
+docShell.createAboutBlankContentViewer(addonPrincipal);
+
+// Get a reference to the DOM window of the given docShell and load
+// such document into that would allow us to create XUL iframes, that
+// are necessary for hidden frames etc..
+var window = docShell.contentViewer.DOMDocument.defaultView;
+window.location = "data:application/vnd.mozilla.xul+xml;charset=utf-8,<window/>";
+
+// Create a promise that is delivered once add-on window is interactive,
+// used by add-on runner to defer add-on loading until window is ready.
+var { promise, resolve } = defer();
+eventTarget.addEventListener("DOMContentLoaded", function handler(event) {
+  eventTarget.removeEventListener("DOMContentLoaded", handler, false);
+  resolve();
+}, false);
+
+exports.ready = promise;
+exports.window = window;
+
+// Still close window on unload to claim memory back early.
+unload(function() {
+  window.close()
+  frame.parentNode.removeChild(frame);
+});
diff --git a/toolkit/jetpack/sdk/base64.js b/toolkit/jetpack/sdk/base64.js
new file mode 100644
index 000000000..a07b302e0
--- /dev/null
+++ b/toolkit/jetpack/sdk/base64.js
@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cu } = require("chrome");
+
+// Passing an empty object as second argument to avoid scope's pollution
+// (devtools loader injects these symbols as global and prevent using
+// const here)
+var { atob, btoa } = Cu.import("resource://gre/modules/Services.jsm", {});
+
+function isUTF8(charset) {
+  let type = typeof charset;
+
+  if (type === "undefined")
+    return false;
+
+  if (type === "string" && charset.toLowerCase() === "utf-8")
+    return true;
+
+  throw new Error("The charset argument can be only 'utf-8'");
+}
+
+function toOctetChar(c) {
+  return String.fromCharCode(c.charCodeAt(0) & 0xFF);
+}
+
+exports.decode = function (data, charset) {
+  if (isUTF8(charset))
+    return decodeURIComponent(escape(atob(data)))
+
+  return atob(data);
+}
+
+exports.encode = function (data, charset) {
+  if (isUTF8(charset))
+    return btoa(unescape(encodeURIComponent(data)))
+
+  data = data.replace(/[^\x00-\xFF]/g, toOctetChar);
+  return btoa(data);
+}
diff --git a/toolkit/jetpack/sdk/browser/events.js b/toolkit/jetpack/sdk/browser/events.js
new file mode 100644
index 000000000..f91119031
--- /dev/null
+++ b/toolkit/jetpack/sdk/browser/events.js
@@ -0,0 +1,20 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { events } = require("../window/events");
+const { filter } = require("../event/utils");
+const { isBrowser } = require("../window/utils");
+
+// TODO: `isBrowser` detects weather window is a browser by checking
+// `windowtype` attribute, which means that all 'open' events will be
+// filtered out since document is not loaded yet. Maybe we can find a better
+// implementation for `isBrowser`. Either way it's not really needed yet
+// neither window tracker provides this event.
+
+exports.events = filter(events, ({target}) => isBrowser(target));
diff --git a/toolkit/jetpack/sdk/clipboard.js b/toolkit/jetpack/sdk/clipboard.js
new file mode 100644
index 000000000..048d5f2f1
--- /dev/null
+++ b/toolkit/jetpack/sdk/clipboard.js
@@ -0,0 +1,337 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "stable",
+  "engines": {
+    // TODO Fennec Support 789757
+    "Firefox": "*",
+    "SeaMonkey": "*",
+    "Thunderbird": "*"
+  }
+};
+
+const { Cc, Ci } = require("chrome");
+const { DataURL } = require("./url");
+const apiUtils = require("./deprecated/api-utils");
+/*
+While these data flavors resemble Internet media types, they do
+no directly map to them.
+*/
+const kAllowableFlavors = [
+  "text/unicode",
+  "text/html",
+  "image/png"
+  /* CURRENTLY UNSUPPORTED FLAVORS
+  "text/plain",
+  "image/jpg",
+  "image/jpeg",
+  "image/gif",
+  "text/x-moz-text-internal",
+  "AOLMAIL",
+  "application/x-moz-file",
+  "text/x-moz-url",
+  "text/x-moz-url-data",
+  "text/x-moz-url-desc",
+  "text/x-moz-url-priv",
+  "application/x-moz-nativeimage",
+  "application/x-moz-nativehtml",
+  "application/x-moz-file-promise-url",
+  "application/x-moz-file-promise-dest-filename",
+  "application/x-moz-file-promise",
+  "application/x-moz-file-promise-dir"
+  */
+];
+
+/*
+Aliases for common flavors. Not all flavors will
+get an alias. New aliases must be approved by a
+Jetpack API druid.
+*/
+const kFlavorMap = [
+  { short: "text", long: "text/unicode" },
+  { short: "html", long: "text/html" },
+  { short: "image", long: "image/png" }
+];
+
+var clipboardService = Cc["@mozilla.org/widget/clipboard;1"].
+                       getService(Ci.nsIClipboard);
+
+var clipboardHelper = Cc["@mozilla.org/widget/clipboardhelper;1"].
+                      getService(Ci.nsIClipboardHelper);
+
+var imageTools = Cc["@mozilla.org/image/tools;1"].
+               getService(Ci.imgITools);
+
+exports.set = function(aData, aDataType) {
+
+  let options = {
+    data: aData,
+    datatype: aDataType || "text"
+  };
+
+  // If `aDataType` is not given or if it's "image", the data is parsed as
+  // data URL to detect a better datatype
+  if (aData && (!aDataType || aDataType === "image")) {
+    try {
+      let dataURL = new DataURL(aData);
+
+      options.datatype = dataURL.mimeType;
+      options.data = dataURL.data;
+    }
+    catch (e) {
+      // Ignore invalid URIs
+      if (e.name !== "URIError") {
+        throw e;
+      }
+    }
+  }
+
+  options = apiUtils.validateOptions(options, {
+    data: {
+      is: ["string"]
+    },
+    datatype: {
+      is: ["string"]
+    }
+  });
+
+  let flavor = fromJetpackFlavor(options.datatype);
+
+  if (!flavor)
+    throw new Error("Invalid flavor for " + options.datatype);
+
+  // Additional checks for using the simple case
+  if (flavor == "text/unicode") {
+    clipboardHelper.copyString(options.data);
+    return true;
+  }
+
+  // Below are the more complex cases where we actually have to work with a
+  // nsITransferable object
+  var xferable = Cc["@mozilla.org/widget/transferable;1"].
+                 createInstance(Ci.nsITransferable);
+  if (!xferable)
+    throw new Error("Couldn't set the clipboard due to an internal error " +
+                    "(couldn't create a Transferable object).");
+  // Bug 769440: Starting with FF16, transferable have to be inited
+  if ("init" in xferable)
+    xferable.init(null);
+
+  switch (flavor) {
+    case "text/html":
+      // add text/html flavor
+      let str = Cc["@mozilla.org/supports-string;1"].
+                 createInstance(Ci.nsISupportsString);
+
+      str.data = options.data;
+      xferable.addDataFlavor(flavor);
+      xferable.setTransferData(flavor, str, str.data.length * 2);
+
+      // add a text/unicode flavor (html converted to plain text)
+      str = Cc["@mozilla.org/supports-string;1"].
+               createInstance(Ci.nsISupportsString);
+      let converter = Cc["@mozilla.org/feed-textconstruct;1"].
+                     createInstance(Ci.nsIFeedTextConstruct);
+
+      converter.type = "html";
+      converter.text = options.data;
+      str.data = converter.plainText();
+      xferable.addDataFlavor("text/unicode");
+      xferable.setTransferData("text/unicode", str, str.data.length * 2);
+      break;
+
+    // Set images to the clipboard is not straightforward, to have an idea how
+    // it works on platform side, see:
+    // http://mxr.mozilla.org/mozilla-central/source/content/base/src/nsCopySupport.cpp?rev=7857c5bff017#530
+    case "image/png":
+      let image = options.data;
+
+      let container = {};
+
+      try {
+        let input = Cc["@mozilla.org/io/string-input-stream;1"].
+                      createInstance(Ci.nsIStringInputStream);
+
+        input.setData(image, image.length);
+
+        imageTools.decodeImageData(input, flavor, container);
+      }
+      catch (e) {
+        throw new Error("Unable to decode data given in a valid image.");
+      }
+
+      // Store directly the input stream makes the cliboard's data available
+      // for Firefox but not to the others application or to the OS. Therefore,
+      // a `nsISupportsInterfacePointer` object that reference an `imgIContainer`
+      // with the image is needed.
+      var imgPtr = Cc["@mozilla.org/supports-interface-pointer;1"].
+                     createInstance(Ci.nsISupportsInterfacePointer);
+
+      imgPtr.data = container.value;
+
+      xferable.addDataFlavor(flavor);
+      xferable.setTransferData(flavor, imgPtr, -1);
+
+      break;
+    default:
+      throw new Error("Unable to handle the flavor " + flavor + ".");
+  }
+
+  // TODO: Not sure if this will ever actually throw. -zpao
+  try {
+    clipboardService.setData(
+      xferable,
+      null,
+      clipboardService.kGlobalClipboard
+    );
+  } catch (e) {
+    throw new Error("Couldn't set clipboard data due to an internal error: " + e);
+  }
+  return true;
+};
+
+
+exports.get = function(aDataType) {
+  let options = {
+    datatype: aDataType
+  };
+
+  // Figure out the best data type for the clipboard's data, if omitted
+  if (!aDataType) {
+    if (~currentFlavors().indexOf("image"))
+      options.datatype = "image";
+    else
+      options.datatype = "text";
+  }
+
+  options = apiUtils.validateOptions(options, {
+    datatype: {
+      is: ["string"]
+    }
+  });
+
+  var xferable = Cc["@mozilla.org/widget/transferable;1"].
+                 createInstance(Ci.nsITransferable);
+  if (!xferable)
+    throw new Error("Couldn't set the clipboard due to an internal error " +
+                    "(couldn't create a Transferable object).");
+  // Bug 769440: Starting with FF16, transferable have to be inited
+  if ("init" in xferable)
+    xferable.init(null);
+
+  var flavor = fromJetpackFlavor(options.datatype);
+
+  // Ensure that the user hasn't requested a flavor that we don't support.
+  if (!flavor)
+    throw new Error("Getting the clipboard with the flavor '" + flavor +
+                    "' is not supported.");
+
+  // TODO: Check for matching flavor first? Probably not worth it.
+
+  xferable.addDataFlavor(flavor);
+  // Get the data into our transferable.
+  clipboardService.getData(
+    xferable,
+    clipboardService.kGlobalClipboard
+  );
+
+  var data = {};
+  var dataLen = {};
+  try {
+    xferable.getTransferData(flavor, data, dataLen);
+  } catch (e) {
+    // Clipboard doesn't contain data in flavor, return null.
+    return null;
+  }
+
+  // There's no data available, return.
+  if (data.value === null)
+    return null;
+
+  // TODO: Add flavors here as we support more in kAllowableFlavors.
+  switch (flavor) {
+    case "text/unicode":
+    case "text/html":
+      data = data.value.QueryInterface(Ci.nsISupportsString).data;
+      break;
+    case "image/png":
+      let dataURL = new DataURL();
+
+      dataURL.mimeType = flavor;
+      dataURL.base64 = true;
+
+      let image = data.value;
+
+      // Due to the differences in how images could be stored in the clipboard
+      // the checks below are needed. The clipboard could already provide the
+      // image as byte streams, but also as pointer, or as image container.
+      // If it's not possible obtain a byte stream, the function returns `null`.
+      if (image instanceof Ci.nsISupportsInterfacePointer)
+        image = image.data;
+
+      if (image instanceof Ci.imgIContainer)
+        image = imageTools.encodeImage(image, flavor);
+
+      if (image instanceof Ci.nsIInputStream) {
+        let binaryStream = Cc["@mozilla.org/binaryinputstream;1"].
+                              createInstance(Ci.nsIBinaryInputStream);
+
+        binaryStream.setInputStream(image);
+
+        dataURL.data = binaryStream.readBytes(binaryStream.available());
+
+        data = dataURL.toString();
+      }
+      else
+        data = null;
+
+      break;
+    default:
+      data = null;
+  }
+
+  return data;
+};
+
+function currentFlavors() {
+  // Loop over kAllowableFlavors, calling hasDataMatchingFlavors for each.
+  // This doesn't seem like the most efficient way, but we can't get
+  // confirmation for specific flavors any other way. This is supposed to be
+  // an inexpensive call, so performance shouldn't be impacted (much).
+  var currentFlavors = [];
+  for (var flavor of kAllowableFlavors) {
+    var matches = clipboardService.hasDataMatchingFlavors(
+      [flavor],
+      1,
+      clipboardService.kGlobalClipboard
+    );
+    if (matches)
+      currentFlavors.push(toJetpackFlavor(flavor));
+  }
+  return currentFlavors;
+};
+
+Object.defineProperty(exports, "currentFlavors", { get : currentFlavors });
+
+// SUPPORT FUNCTIONS ////////////////////////////////////////////////////////
+
+function toJetpackFlavor(aFlavor) {
+  for (let flavorMap of kFlavorMap)
+    if (flavorMap.long == aFlavor)
+      return flavorMap.short;
+  // Return null in the case where we don't match
+  return null;
+}
+
+function fromJetpackFlavor(aJetpackFlavor) {
+  // TODO: Handle proper flavors better
+  for (let flavorMap of kFlavorMap)
+    if (flavorMap.short == aJetpackFlavor || flavorMap.long == aJetpackFlavor)
+      return flavorMap.long;
+  // Return null in the case where we don't match.
+  return null;
+}
diff --git a/toolkit/jetpack/sdk/console/plain-text.js b/toolkit/jetpack/sdk/console/plain-text.js
new file mode 100644
index 000000000..0e44cf106
--- /dev/null
+++ b/toolkit/jetpack/sdk/console/plain-text.js
@@ -0,0 +1,78 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci, Cu, Cr } = require("chrome");
+const self = require("../self");
+const prefs = require("../preferences/service");
+const { merge } = require("../util/object");
+const { ConsoleAPI } = Cu.import("resource://gre/modules/Console.jsm", {});
+
+const DEFAULT_LOG_LEVEL = "error";
+const ADDON_LOG_LEVEL_PREF = "extensions." + self.id + ".sdk.console.logLevel";
+const SDK_LOG_LEVEL_PREF = "extensions.sdk.console.logLevel";
+
+var logLevel = DEFAULT_LOG_LEVEL;
+function setLogLevel() {
+  logLevel = prefs.get(ADDON_LOG_LEVEL_PREF,
+                           prefs.get(SDK_LOG_LEVEL_PREF,
+                                     DEFAULT_LOG_LEVEL));
+}
+setLogLevel();
+
+var logLevelObserver = {
+  QueryInterface: function(iid) {
+    if (!iid.equals(Ci.nsIObserver) &&
+        !iid.equals(Ci.nsISupportsWeakReference) &&
+        !iid.equals(Ci.nsISupports))
+      throw Cr.NS_ERROR_NO_INTERFACE;
+    return this;
+  },
+  observe: function(subject, topic, data) {
+    setLogLevel();
+  }
+};
+var branch = Cc["@mozilla.org/preferences-service;1"].
+             getService(Ci.nsIPrefService).
+             getBranch(null);
+branch.addObserver(ADDON_LOG_LEVEL_PREF, logLevelObserver, true);
+branch.addObserver(SDK_LOG_LEVEL_PREF, logLevelObserver, true);
+
+function PlainTextConsole(print, innerID) {
+
+  let consoleOptions = {
+    prefix: self.name,
+    maxLogLevel: logLevel,
+    dump: print,
+    innerID: innerID,
+    consoleID: "addon/" + self.id
+  };
+  let console = new ConsoleAPI(consoleOptions);
+
+  // As we freeze the console object, we can't modify this property afterward
+  Object.defineProperty(console, "maxLogLevel", {
+    get: function() {
+      return logLevel;
+    }
+  });
+
+  // We defined the `__exposedProps__` in our console chrome object.
+  //
+  // Meanwhile we're investigating with the platform team if `__exposedProps__`
+  // are needed, or are just a left-over.
+
+  console.__exposedProps__ = Object.keys(ConsoleAPI.prototype).reduce(function(exposed, prop) {
+    exposed[prop] = "r";
+    return exposed;
+  }, {});
+
+  Object.freeze(console);
+  return console;
+};
+exports.PlainTextConsole = PlainTextConsole;
diff --git a/toolkit/jetpack/sdk/console/traceback.js b/toolkit/jetpack/sdk/console/traceback.js
new file mode 100644
index 000000000..be0fb7b94
--- /dev/null
+++ b/toolkit/jetpack/sdk/console/traceback.js
@@ -0,0 +1,86 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Ci, components } = require("chrome");
+const { parseStack, sourceURI } = require("toolkit/loader");
+const { readURISync } = require("../net/url");
+
+function safeGetFileLine(path, line) {
+  try {
+    var scheme = require("../url").URL(path).scheme;
+    // TODO: There should be an easier, more accurate way to figure out
+    // what's the case here.
+    if (!(scheme == "http" || scheme == "https"))
+      return readURISync(path).split("\n")[line - 1];
+  } catch (e) {}
+  return null;
+}
+
+function nsIStackFramesToJSON(frame) {
+  var stack = [];
+
+  while (frame) {
+    if (frame.filename) {
+      stack.unshift({
+        fileName: sourceURI(frame.filename),
+        lineNumber: frame.lineNumber,
+        name: frame.name
+      });
+    }
+    frame = frame.caller;
+  }
+
+  return stack;
+};
+
+var fromException = exports.fromException = function fromException(e) {
+  if (e instanceof Ci.nsIException)
+    return nsIStackFramesToJSON(e.location);
+  if (e.stack && e.stack.length)
+    return parseStack(e.stack);
+  if (e.fileName && typeof(e.lineNumber == "number"))
+    return [{fileName: sourceURI(e.fileName),
+             lineNumber: e.lineNumber,
+             name: null}];
+  return [];
+};
+
+var get = exports.get = function get() {
+  return nsIStackFramesToJSON(components.stack.caller);
+};
+
+var format = exports.format = function format(tbOrException) {
+  if (tbOrException === undefined) {
+    tbOrException = get();
+    tbOrException.pop();
+  }
+
+  var tb;
+  if (typeof(tbOrException) == "object" &&
+      tbOrException.constructor.name == "Array")
+    tb = tbOrException;
+  else
+    tb = fromException(tbOrException);
+
+  var lines = ["Traceback (most recent call last):"];
+
+  tb.forEach(
+    function(frame) {
+      if (!(frame.fileName || frame.lineNumber || frame.name))
+      	return;
+
+      lines.push('  File "' + frame.fileName + '", line ' +
+                 frame.lineNumber + ', in ' + frame.name);
+      var sourceLine = safeGetFileLine(frame.fileName, frame.lineNumber);
+      if (sourceLine)
+        lines.push('    ' + sourceLine.trim());
+    });
+
+  return lines.join("\n");
+};
diff --git a/toolkit/jetpack/sdk/content/content-worker.js b/toolkit/jetpack/sdk/content/content-worker.js
new file mode 100644
index 000000000..0a8225733
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/content-worker.js
@@ -0,0 +1,305 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+Object.freeze({
+  // TODO: Bug 727854 Use same implementation than common JS modules,
+  // i.e. EventEmitter module
+
+  /**
+   * Create an EventEmitter instance.
+   */
+  createEventEmitter: function createEventEmitter(emit) {
+    let listeners = Object.create(null);
+    let eventEmitter = Object.freeze({
+      emit: emit,
+      on: function on(name, callback) {
+        if (typeof callback !== "function")
+          return this;
+        if (!(name in listeners))
+          listeners[name] = [];
+        listeners[name].push(callback);
+        return this;
+      },
+      once: function once(name, callback) {
+        eventEmitter.on(name, function onceCallback() {
+          eventEmitter.removeListener(name, onceCallback);
+          callback.apply(callback, arguments);
+        });
+      },
+      removeListener: function removeListener(name, callback) {
+        if (!(name in listeners))
+          return;
+        let index = listeners[name].indexOf(callback);
+        if (index == -1)
+          return;
+        listeners[name].splice(index, 1);
+      }
+    });
+    function onEvent(name) {
+      if (!(name in listeners))
+        return [];
+      let args = Array.slice(arguments, 1);
+      let results = [];
+      for (let callback of listeners[name]) {
+        results.push(callback.apply(null, args));
+      }
+      return results;
+    }
+    return {
+      eventEmitter: eventEmitter,
+      emit: onEvent
+    };
+  },
+
+  /**
+   * Create an EventEmitter instance to communicate with chrome module
+   * by passing only strings between compartments.
+   * This function expects `emitToChrome` function, that allows to send
+   * events to the chrome module. It returns the EventEmitter as `pipe`
+   * attribute, and, `onChromeEvent` a function that allows chrome module
+   * to send event into the EventEmitter.
+   *
+   *                  pipe.emit --> emitToChrome
+   *              onChromeEvent --> callback registered through pipe.on
+   */
+  createPipe: function createPipe(emitToChrome) {
+    let ContentWorker = this;
+    function onEvent(type, ...args) {
+      // JSON.stringify is buggy with cross-sandbox values,
+      // it may return "{}" on functions. Use a replacer to match them correctly.
+      let replacer = (k, v) =>
+        typeof(v) === "function"
+          ? (type === "console" ? Function.toString.call(v) : void(0))
+          : v;
+
+      let str = JSON.stringify([type, ...args], replacer);
+      emitToChrome(str);
+    }
+
+    let { eventEmitter, emit } =
+      ContentWorker.createEventEmitter(onEvent);
+
+    return {
+      pipe: eventEmitter,
+      onChromeEvent: function onChromeEvent(array) {
+        // We either receive a stringified array, or a real array.
+        // We still allow to pass an array of objects, in WorkerSandbox.emitSync
+        // in order to allow sending DOM node reference between content script
+        // and modules (only used for context-menu API)
+        let args = typeof array == "string" ? JSON.parse(array) : array;
+        return emit.apply(null, args);
+      }
+    };
+  },
+
+  injectConsole: function injectConsole(exports, pipe) {
+    exports.console = Object.freeze({
+      log: pipe.emit.bind(null, "console", "log"),
+      info: pipe.emit.bind(null, "console", "info"),
+      warn: pipe.emit.bind(null, "console", "warn"),
+      error: pipe.emit.bind(null, "console", "error"),
+      debug: pipe.emit.bind(null, "console", "debug"),
+      exception: pipe.emit.bind(null, "console", "exception"),
+      trace: pipe.emit.bind(null, "console", "trace"),
+      time: pipe.emit.bind(null, "console", "time"),
+      timeEnd: pipe.emit.bind(null, "console", "timeEnd")
+    });
+  },
+
+  injectTimers: function injectTimers(exports, chromeAPI, pipe, console) {
+    // wrapped functions from `'timer'` module.
+    // Wrapper adds `try catch` blocks to the callbacks in order to
+    // emit `error` event if exception is thrown in
+    // the Worker global scope.
+    // @see http://www.w3.org/TR/workers/#workerutils
+
+    // List of all living timeouts/intervals
+    let _timers = Object.create(null);
+
+    // Keep a reference to original timeout functions
+    let {
+      setTimeout: chromeSetTimeout,
+      setInterval: chromeSetInterval,
+      clearTimeout: chromeClearTimeout,
+      clearInterval: chromeClearInterval
+    } = chromeAPI.timers;
+
+    function registerTimer(timer) {
+      let registerMethod = null;
+      if (timer.kind == "timeout")
+        registerMethod = chromeSetTimeout;
+      else if (timer.kind == "interval")
+        registerMethod = chromeSetInterval;
+      else
+        throw new Error("Unknown timer kind: " + timer.kind);
+
+      if (typeof timer.fun == 'string') {
+        let code = timer.fun;
+        timer.fun = () => chromeAPI.sandbox.evaluate(exports, code);
+      } else if (typeof timer.fun != 'function') {
+        throw new Error('Unsupported callback type' + typeof timer.fun);
+      }
+
+      let id = registerMethod(onFire, timer.delay);
+      function onFire() {
+        try {
+          if (timer.kind == "timeout")
+            delete _timers[id];
+          timer.fun.apply(null, timer.args);
+        } catch(e) {
+          console.exception(e);
+          let wrapper = {
+            instanceOfError: instanceOf(e, Error),
+            value: e,
+          };
+          if (wrapper.instanceOfError) {
+            wrapper.value = {
+              message: e.message,
+              fileName: e.fileName,
+              lineNumber: e.lineNumber,
+              stack: e.stack,
+              name: e.name,
+            };
+          }
+          pipe.emit('error', wrapper);
+        }
+      }
+      _timers[id] = timer;
+      return id;
+    }
+
+    // copied from sdk/lang/type.js since modules are not available here
+    function instanceOf(value, Type) {
+      var isConstructorNameSame;
+      var isConstructorSourceSame;
+
+      // If `instanceof` returned `true` we know result right away.
+      var isInstanceOf = value instanceof Type;
+
+      // If `instanceof` returned `false` we do ducktype check since `Type` may be
+      // from a different sandbox. If a constructor of the `value` or a constructor
+      // of the value's prototype has same name and source we assume that it's an
+      // instance of the Type.
+      if (!isInstanceOf && value) {
+        isConstructorNameSame = value.constructor.name === Type.name;
+        isConstructorSourceSame = String(value.constructor) == String(Type);
+        isInstanceOf = (isConstructorNameSame && isConstructorSourceSame) ||
+                        instanceOf(Object.getPrototypeOf(value), Type);
+      }
+      return isInstanceOf;
+    }
+
+    function unregisterTimer(id) {
+      if (!(id in _timers))
+        return;
+      let { kind } = _timers[id];
+      delete _timers[id];
+      if (kind == "timeout")
+        chromeClearTimeout(id);
+      else if (kind == "interval")
+        chromeClearInterval(id);
+      else
+        throw new Error("Unknown timer kind: " + kind);
+    }
+
+    function disableAllTimers() {
+      Object.keys(_timers).forEach(unregisterTimer);
+    }
+
+    exports.setTimeout = function ContentScriptSetTimeout(callback, delay) {
+      return registerTimer({
+        kind: "timeout",
+        fun: callback,
+        delay: delay,
+        args: Array.slice(arguments, 2)
+      });
+    };
+    exports.clearTimeout = function ContentScriptClearTimeout(id) {
+      unregisterTimer(id);
+    };
+
+    exports.setInterval = function ContentScriptSetInterval(callback, delay) {
+      return registerTimer({
+        kind: "interval",
+        fun: callback,
+        delay: delay,
+        args: Array.slice(arguments, 2)
+      });
+    };
+    exports.clearInterval = function ContentScriptClearInterval(id) {
+      unregisterTimer(id);
+    };
+
+    // On page-hide, save a list of all existing timers before disabling them,
+    // in order to be able to restore them on page-show.
+    // These events are fired when the page goes in/out of bfcache.
+    // https://developer.mozilla.org/En/Working_with_BFCache
+    let frozenTimers = [];
+    pipe.on("pageshow", function onPageShow() {
+      frozenTimers.forEach(registerTimer);
+    });
+    pipe.on("pagehide", function onPageHide() {
+      frozenTimers = [];
+      for (let id in _timers)
+        frozenTimers.push(_timers[id]);
+      disableAllTimers();
+      // Some other pagehide listeners may register some timers that won't be
+      // frozen as this particular pagehide listener is called first.
+      // So freeze these timers on next cycle.
+      chromeSetTimeout(function () {
+        for (let id in _timers)
+          frozenTimers.push(_timers[id]);
+        disableAllTimers();
+      }, 0);
+    });
+
+    // Unregister all timers when the page is destroyed
+    // (i.e. when it is removed from bfcache)
+    pipe.on("detach", function clearTimeouts() {
+      disableAllTimers();
+      _timers = {};
+      frozenTimers = [];
+    });
+  },
+
+  injectMessageAPI: function injectMessageAPI(exports, pipe, console) {
+
+    let ContentWorker = this;
+    let { eventEmitter: port, emit : portEmit } =
+      ContentWorker.createEventEmitter(pipe.emit.bind(null, "event"));
+    pipe.on("event", portEmit);
+
+    let self = {
+      port: port,
+      postMessage: pipe.emit.bind(null, "message"),
+      on: pipe.on.bind(null),
+      once: pipe.once.bind(null),
+      removeListener: pipe.removeListener.bind(null),
+    };
+    Object.defineProperty(exports, "self", {
+      value: self
+    });
+  },
+
+  injectOptions: function (exports, options) {
+    Object.defineProperty( exports.self, "options", { value: JSON.parse( options ) });
+  },
+
+  inject: function (exports, chromeAPI, emitToChrome, options) {
+    let ContentWorker = this;
+    let { pipe, onChromeEvent } =
+      ContentWorker.createPipe(emitToChrome);
+
+    ContentWorker.injectConsole(exports, pipe);
+    ContentWorker.injectTimers(exports, chromeAPI, pipe, exports.console);
+    ContentWorker.injectMessageAPI(exports, pipe, exports.console);
+    if ( options !== undefined ) {
+      ContentWorker.injectOptions(exports, options);
+    }
+
+    Object.freeze( exports.self );
+
+    return onChromeEvent;
+  }
+});
diff --git a/toolkit/jetpack/sdk/content/content.js b/toolkit/jetpack/sdk/content/content.js
new file mode 100644
index 000000000..9655223a3
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/content.js
@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "deprecated"
+};
+
+const { deprecateUsage } = require('../util/deprecate');
+
+Object.defineProperty(exports, "Worker", {
+  get: function() {
+    deprecateUsage('`sdk/content/content` is deprecated. Please use `sdk/content/worker` directly.');
+    return require('./worker').Worker;
+  }
+});
diff --git a/toolkit/jetpack/sdk/content/context-menu.js b/toolkit/jetpack/sdk/content/context-menu.js
new file mode 100644
index 000000000..2955e2f09
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/context-menu.js
@@ -0,0 +1,408 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Class } = require("../core/heritage");
+const self = require("../self");
+const { WorkerChild } = require("./worker-child");
+const { getInnerId } = require("../window/utils");
+const { Ci } = require("chrome");
+const { Services } = require("resource://gre/modules/Services.jsm");
+const system = require('../system/events');
+const { process } = require('../remote/child');
+
+// These functions are roughly copied from sdk/selection which doesn't work
+// in the content process
+function getElementWithSelection(window) {
+  let element = Services.focus.getFocusedElementForWindow(window, false, {});
+  if (!element)
+    return null;
+
+  try {
+    // Accessing selectionStart and selectionEnd on e.g. a button
+    // results in an exception thrown as per the HTML5 spec.  See
+    // http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#textFieldSelection
+
+    let { value, selectionStart, selectionEnd } = element;
+
+    let hasSelection = typeof value === "string" &&
+                      !isNaN(selectionStart) &&
+                      !isNaN(selectionEnd) &&
+                      selectionStart !== selectionEnd;
+
+    return hasSelection ? element : null;
+  }
+  catch (err) {
+    console.exception(err);
+    return null;
+  }
+}
+
+function safeGetRange(selection, rangeNumber) {
+  try {
+    let { rangeCount } = selection;
+    let range = null;
+
+    for (let rangeNumber = 0; rangeNumber < rangeCount; rangeNumber++ ) {
+      range = selection.getRangeAt(rangeNumber);
+
+      if (range && range.toString())
+        break;
+
+      range = null;
+    }
+
+    return range;
+  }
+  catch (e) {
+    return null;
+  }
+}
+
+function getSelection(window) {
+  let selection = window.getSelection();
+  let range = safeGetRange(selection);
+  if (range)
+    return range.toString();
+
+  let node = getElementWithSelection(window);
+  if (!node)
+    return null;
+
+  return node.value.substring(node.selectionStart, node.selectionEnd);
+}
+
+//These are used by PageContext.isCurrent below. If the popupNode or any of
+//its ancestors is one of these, Firefox uses a tailored context menu, and so
+//the page context doesn't apply.
+const NON_PAGE_CONTEXT_ELTS = [
+  Ci.nsIDOMHTMLAnchorElement,
+  Ci.nsIDOMHTMLAppletElement,
+  Ci.nsIDOMHTMLAreaElement,
+  Ci.nsIDOMHTMLButtonElement,
+  Ci.nsIDOMHTMLCanvasElement,
+  Ci.nsIDOMHTMLEmbedElement,
+  Ci.nsIDOMHTMLImageElement,
+  Ci.nsIDOMHTMLInputElement,
+  Ci.nsIDOMHTMLMapElement,
+  Ci.nsIDOMHTMLMediaElement,
+  Ci.nsIDOMHTMLMenuElement,
+  Ci.nsIDOMHTMLObjectElement,
+  Ci.nsIDOMHTMLOptionElement,
+  Ci.nsIDOMHTMLSelectElement,
+  Ci.nsIDOMHTMLTextAreaElement,
+];
+
+// List all editable types of inputs.  Or is it better to have a list
+// of non-editable inputs?
+var editableInputs = {
+  email: true,
+  number: true,
+  password: true,
+  search: true,
+  tel: true,
+  text: true,
+  textarea: true,
+  url: true
+};
+
+var CONTEXTS = {};
+
+var Context = Class({
+  initialize: function(id) {
+    this.id = id;
+  },
+
+  adjustPopupNode: function adjustPopupNode(popupNode) {
+    return popupNode;
+  },
+
+  // Gets state to pass through to the parent process for the node the user
+  // clicked on
+  getState: function(popupNode) {
+    return false;
+  }
+});
+
+// Matches when the context-clicked node doesn't have any of
+// NON_PAGE_CONTEXT_ELTS in its ancestors
+CONTEXTS.PageContext = Class({
+  extends: Context,
+
+  getState: function(popupNode) {
+    // If there is a selection in the window then this context does not match
+    if (!popupNode.ownerDocument.defaultView.getSelection().isCollapsed)
+      return false;
+
+    // If the clicked node or any of its ancestors is one of the blocked
+    // NON_PAGE_CONTEXT_ELTS then this context does not match
+    while (!(popupNode instanceof Ci.nsIDOMDocument)) {
+      if (NON_PAGE_CONTEXT_ELTS.some(type => popupNode instanceof type))
+        return false;
+
+      popupNode = popupNode.parentNode;
+    }
+
+    return true;
+  }
+});
+
+// Matches when there is an active selection in the window
+CONTEXTS.SelectionContext = Class({
+  extends: Context,
+
+  getState: function(popupNode) {
+    if (!popupNode.ownerDocument.defaultView.getSelection().isCollapsed)
+      return true;
+
+    try {
+      // The node may be a text box which has selectionStart and selectionEnd
+      // properties. If not this will throw.
+      let { selectionStart, selectionEnd } = popupNode;
+      return !isNaN(selectionStart) && !isNaN(selectionEnd) &&
+             selectionStart !== selectionEnd;
+    }
+    catch (e) {
+      return false;
+    }
+  }
+});
+
+// Matches when the context-clicked node or any of its ancestors matches the
+// selector given
+CONTEXTS.SelectorContext = Class({
+  extends: Context,
+
+  initialize: function initialize(id, selector) {
+    Context.prototype.initialize.call(this, id);
+    this.selector = selector;
+  },
+
+  adjustPopupNode: function adjustPopupNode(popupNode) {
+    let selector = this.selector;
+
+    while (!(popupNode instanceof Ci.nsIDOMDocument)) {
+      if (popupNode.matches(selector))
+        return popupNode;
+
+      popupNode = popupNode.parentNode;
+    }
+
+    return null;
+  },
+
+  getState: function(popupNode) {
+    return !!this.adjustPopupNode(popupNode);
+  }
+});
+
+// Matches when the page url matches any of the patterns given
+CONTEXTS.URLContext = Class({
+  extends: Context,
+
+  getState: function(popupNode) {
+    return popupNode.ownerDocument.URL;
+  }
+});
+
+// Matches when the user-supplied predicate returns true
+CONTEXTS.PredicateContext = Class({
+  extends: Context,
+
+  getState: function(node) {
+    let window = node.ownerDocument.defaultView;
+    let data = {};
+
+    data.documentType = node.ownerDocument.contentType;
+
+    data.documentURL = node.ownerDocument.location.href;
+    data.targetName = node.nodeName.toLowerCase();
+    data.targetID = node.id || null ;
+
+    if ((data.targetName === 'input' && editableInputs[node.type]) ||
+        data.targetName === 'textarea') {
+      data.isEditable = !node.readOnly && !node.disabled;
+    }
+    else {
+      data.isEditable = node.isContentEditable;
+    }
+
+    data.selectionText = getSelection(window, "TEXT");
+
+    data.srcURL = node.src || null;
+    data.value = node.value || null;
+
+    while (!data.linkURL && node) {
+      data.linkURL = node.href || null;
+      node = node.parentNode;
+    }
+
+    return data;
+  },
+});
+
+function instantiateContext({ id, type, args }) {
+  if (!(type in CONTEXTS)) {
+    console.error("Attempt to use unknown context " + type);
+    return;
+  }
+  return new CONTEXTS[type](id, ...args);
+}
+
+var ContextWorker = Class({
+  implements: [ WorkerChild ],
+
+  // Calls the context workers context listeners and returns the first result
+  // that is either a string or a value that evaluates to true. If all of the
+  // listeners returned false then returns false. If there are no listeners,
+  // returns true (show the menu item by default).
+  getMatchedContext: function getCurrentContexts(popupNode) {
+    let results = this.sandbox.emitSync("context", popupNode);
+    if (!results.length)
+      return true;
+    return results.reduce((val, result) => val || result);
+  },
+
+  // Emits a click event in the worker's port. popupNode is the node that was
+  // context-clicked, and clickedItemData is the data of the item that was
+  // clicked.
+  fireClick: function fireClick(popupNode, clickedItemData) {
+    this.sandbox.emitSync("click", popupNode, clickedItemData);
+  }
+});
+
+// Gets the item's content script worker for a window, creating one if necessary
+// Once created it will be automatically destroyed when the window unloads.
+// If there is not content scripts for the item then null will be returned.
+function getItemWorkerForWindow(item, window) {
+  if (!item.contentScript && !item.contentScriptFile)
+    return null;
+
+  let id = getInnerId(window);
+  let worker = item.workerMap.get(id);
+
+  if (worker)
+    return worker;
+
+  worker = ContextWorker({
+    id: item.id,
+    window,
+    manager: item.manager,
+    contentScript: item.contentScript,
+    contentScriptFile: item.contentScriptFile,
+    onDetach: function() {
+      item.workerMap.delete(id);
+    }
+  });
+
+  item.workerMap.set(id, worker);
+
+  return worker;
+}
+
+// A very simple remote proxy for every item. It's job is to provide data for
+// the main process to use to determine visibility state and to call into
+// content scripts when clicked.
+var RemoteItem = Class({
+  initialize: function(options, manager) {
+    this.id = options.id;
+    this.contexts = options.contexts.map(instantiateContext);
+    this.contentScript = options.contentScript;
+    this.contentScriptFile = options.contentScriptFile;
+
+    this.manager = manager;
+
+    this.workerMap = new Map();
+    keepAlive.set(this.id, this);
+  },
+
+  destroy: function() {
+    for (let worker of this.workerMap.values()) {
+      worker.destroy();
+    }
+    keepAlive.delete(this.id);
+  },
+
+  activate: function(popupNode, data) {
+    let worker = getItemWorkerForWindow(this, popupNode.ownerDocument.defaultView);
+    if (!worker)
+      return;
+
+    for (let context of this.contexts)
+      popupNode = context.adjustPopupNode(popupNode);
+
+    worker.fireClick(popupNode, data);
+  },
+
+  // Fills addonInfo with state data to send through to the main process
+  getContextState: function(popupNode, addonInfo) {
+    if (!(self.id in addonInfo)) {
+      addonInfo[self.id] = {
+        processID: process.id,
+        items: {}
+      };
+    }
+
+    let worker = getItemWorkerForWindow(this, popupNode.ownerDocument.defaultView);
+    let contextStates = {};
+    for (let context of this.contexts)
+      contextStates[context.id] = context.getState(popupNode);
+
+    addonInfo[self.id].items[this.id] = {
+      // It isn't ideal to create a PageContext for every item but there isn't
+      // a good shared place to do it.
+      pageContext: (new CONTEXTS.PageContext()).getState(popupNode),
+      contextStates,
+      hasWorker: !!worker,
+      workerContext: worker ? worker.getMatchedContext(popupNode) : true
+    }
+  }
+});
+exports.RemoteItem = RemoteItem;
+
+// Holds remote items for this frame.
+var keepAlive = new Map();
+
+// Called to create remote proxies for items. If they already exist we destroy
+// and recreate. This can happen if the item changes in some way or in odd
+// timing cases where the frame script is create around the same time as the
+// item is created in the main process
+process.port.on('sdk/contextmenu/createitems', (process, items) => {
+  for (let itemoptions of items) {
+    let oldItem = keepAlive.get(itemoptions.id);
+    if (oldItem) {
+      oldItem.destroy();
+    }
+
+    let item = new RemoteItem(itemoptions, this);
+  }
+});
+
+process.port.on('sdk/contextmenu/destroyitems', (process, items) => {
+  for (let id of items) {
+    let item = keepAlive.get(id);
+    item.destroy();
+  }
+});
+
+var lastPopupNode = null;
+
+system.on('content-contextmenu', ({ subject }) => {
+  let { event: { target: popupNode }, addonInfo } = subject.wrappedJSObject;
+  lastPopupNode = popupNode;
+
+  for (let item of keepAlive.values()) {
+    item.getContextState(popupNode, addonInfo);
+  }
+}, true);
+
+process.port.on('sdk/contextmenu/activateitems', (process, items, data) => {
+  for (let id of items) {
+    let item = keepAlive.get(id);
+    if (!item)
+      continue;
+
+    item.activate(lastPopupNode, data);
+  }
+});
diff --git a/toolkit/jetpack/sdk/content/events.js b/toolkit/jetpack/sdk/content/events.js
new file mode 100644
index 000000000..c085b6179
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/events.js
@@ -0,0 +1,57 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Ci } = require("chrome");
+const { open } = require("../event/dom");
+const { observe } = require("../event/chrome");
+const { filter, merge, map, expand } = require("../event/utils");
+const { windows } = require("../window/utils");
+const { events: windowEvents } = require("sdk/window/events");
+
+// Note: Please note that even though pagehide event is included
+// it's not observable reliably since it's not always triggered
+// when closing tabs. Implementation can be imrpoved once that
+// event will be necessary.
+var TYPES = ["DOMContentLoaded", "load", "pageshow", "pagehide"];
+
+var insert = observe("document-element-inserted");
+var windowCreate = merge([
+  observe("content-document-global-created"),
+  observe("chrome-document-global-created")
+]);
+var create = map(windowCreate, function({target, data, type}) {
+  return { target: target.document, type: type, data: data }
+});
+
+function streamEventsFrom({document}) {
+  // Map supported event types to a streams of those events on the given
+  // `window` for the inserted document and than merge these streams into
+  // single form stream off all window state change events.
+  let stateChanges = TYPES.map(function(type) {
+    return open(document, type, { capture: true });
+  });
+
+  // Since load events on document occur for every loded resource
+  return filter(merge(stateChanges), function({target}) {
+    return target instanceof Ci.nsIDOMDocument
+  })
+}
+exports.streamEventsFrom = streamEventsFrom;
+
+var opened = windows(null, { includePrivate: true });
+var state = merge(opened.map(streamEventsFrom));
+
+
+var futureReady = filter(windowEvents, ({type}) =>
+                                        type === "DOMContentLoaded");
+var futureWindows = map(futureReady, ({target}) => target);
+var futureState = expand(futureWindows, streamEventsFrom);
+
+exports.events = merge([insert, create, state, futureState]);
diff --git a/toolkit/jetpack/sdk/content/l10n-html.js b/toolkit/jetpack/sdk/content/l10n-html.js
new file mode 100644
index 000000000..f324623dc
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/l10n-html.js
@@ -0,0 +1,133 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Ci, Cc, Cu } = require("chrome");
+const core = require("../l10n/core");
+const { loadSheet, removeSheet } = require("../stylesheet/utils");
+const { process, frames } = require("../remote/child");
+var observerService = Cc["@mozilla.org/observer-service;1"]
+                      .getService(Ci.nsIObserverService);
+const { ShimWaiver } = Cu.import("resource://gre/modules/ShimWaiver.jsm");
+const addObserver = ShimWaiver.getProperty(observerService, "addObserver");
+const removeObserver = ShimWaiver.getProperty(observerService, "removeObserver");
+
+const assetsURI = require('../self').data.url();
+
+const hideSheetUri = "data:text/css,:root {visibility: hidden !important;}";
+
+function translateElementAttributes(element) {
+  // Translateable attributes
+  const attrList = ['title', 'accesskey', 'alt', 'label', 'placeholder'];
+  const ariaAttrMap = {
+          'ariaLabel': 'aria-label',
+          'ariaValueText': 'aria-valuetext',
+          'ariaMozHint': 'aria-moz-hint'
+        };
+  const attrSeparator = '.';
+  
+  // Try to translate each of the attributes
+  for (let attribute of attrList) {
+    const data = core.get(element.dataset.l10nId + attrSeparator + attribute);
+    if (data)
+      element.setAttribute(attribute, data);
+  }
+  
+  // Look for the aria attribute translations that match fxOS's aliases
+  for (let attrAlias in ariaAttrMap) {
+    const data = core.get(element.dataset.l10nId + attrSeparator + attrAlias);
+    if (data)
+      element.setAttribute(ariaAttrMap[attrAlias], data);
+  }
+}
+
+// Taken from Gaia:
+// https://github.com/andreasgal/gaia/blob/04fde2640a7f40314643016a5a6c98bf3755f5fd/webapi.js#L1470
+function translateElement(element) {
+  element = element || document;
+
+  // check all translatable children (= w/ a `data-l10n-id' attribute)
+  var children = element.querySelectorAll('*[data-l10n-id]');
+  var elementCount = children.length;
+  for (var i = 0; i < elementCount; i++) {
+    var child = children[i];
+
+    // translate the child
+    var key = child.dataset.l10nId;
+    var data = core.get(key);
+    if (data)
+      child.textContent = data;
+
+    translateElementAttributes(child);
+  }
+}
+exports.translateElement = translateElement;
+
+function onDocumentReady2Translate(event) {
+  let document = event.target;
+  document.removeEventListener("DOMContentLoaded", onDocumentReady2Translate,
+                               false);
+
+  translateElement(document);
+
+  try {
+    // Finally display document when we finished replacing all text content
+    if (document.defaultView)
+      removeSheet(document.defaultView, hideSheetUri, 'user');
+  }
+  catch(e) {
+    console.exception(e);
+  }
+}
+
+function onContentWindow(document) {
+  // Accept only HTML documents
+  if (!(document instanceof Ci.nsIDOMHTMLDocument))
+    return;
+
+  // Bug 769483: data:URI documents instanciated with nsIDOMParser
+  // have a null `location` attribute at this time
+  if (!document.location)
+    return;
+
+  // Accept only document from this addon
+  if (document.location.href.indexOf(assetsURI) !== 0)
+    return;
+
+  try {
+    // First hide content of the document in order to have content blinking
+    // between untranslated and translated states
+    loadSheet(document.defaultView, hideSheetUri, 'user');
+  }
+  catch(e) {
+    console.exception(e);
+  }
+  // Wait for DOM tree to be built before applying localization
+  document.addEventListener("DOMContentLoaded", onDocumentReady2Translate,
+                            false);
+}
+
+// Listen to creation of content documents in order to translate them as soon
+// as possible in their loading process
+const ON_CONTENT = "document-element-inserted";
+let enabled = false;
+function enable() {
+  if (enabled)
+    return;
+  addObserver(onContentWindow, ON_CONTENT, false);
+  enabled = true;
+}
+process.port.on("sdk/l10n/html/enable", enable);
+
+function disable() {
+  if (!enabled)
+    return;
+  removeObserver(onContentWindow, ON_CONTENT);
+  enabled = false;
+}
+process.port.on("sdk/l10n/html/disable", disable);
diff --git a/toolkit/jetpack/sdk/content/loader.js b/toolkit/jetpack/sdk/content/loader.js
new file mode 100644
index 000000000..e4f0dd2aa
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/loader.js
@@ -0,0 +1,74 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { isValidURI, isLocalURL, URL } = require('../url');
+const { contract } = require('../util/contract');
+const { isString, isNil, instanceOf, isJSONable } = require('../lang/type');
+const { validateOptions,
+  string, array, object, either, required } = require('../deprecated/api-utils');
+
+const isValidScriptFile = (value) =>
+  (isString(value) || instanceOf(value, URL)) && isLocalURL(value);
+
+// map of property validations
+const valid = {
+  contentURL: {
+    is: either(string, object),
+    ok: url => isNil(url) || isLocalURL(url) || isValidURI(url),
+    msg: 'The `contentURL` option must be a valid URL.'
+  },
+  contentScriptFile: {
+    is: either(string, object, array),
+    ok: value => isNil(value) || [].concat(value).every(isValidScriptFile),
+    msg: 'The `contentScriptFile` option must be a local URL or an array of URLs.'
+  },
+  contentScript: {
+    is: either(string, array),
+    ok: value => isNil(value) || [].concat(value).every(isString),
+    msg: 'The `contentScript` option must be a string or an array of strings.'
+  },
+  contentScriptWhen: {
+    is: required(string),
+    map: value => value || 'end',
+    ok: value => ~['start', 'ready', 'end'].indexOf(value),
+    msg: 'The `contentScriptWhen` option must be either "start", "ready" or "end".'
+  },
+  contentScriptOptions: {
+    ok: value => isNil(value) || isJSONable(value),
+    msg: 'The contentScriptOptions should be a jsonable value.'
+  }
+};
+exports.validationAttributes = valid;
+
+/**
+ * Shortcut function to validate property with validation.
+ * @param {Object|Number|String} suspect
+ *    value to validate
+ * @param {Object} validation
+ *    validation rule passed to `api-utils`
+ */
+function validate(suspect, validation) {
+  return validateOptions(
+    { $: suspect },
+    { $: validation }
+  ).$;
+}
+
+function Allow(script) {
+  return {
+    get script() {
+      return script;
+    },
+    set script(value) {
+      script = !!value;
+    }
+  };
+}
+
+exports.contract = contract(valid);
diff --git a/toolkit/jetpack/sdk/content/mod.js b/toolkit/jetpack/sdk/content/mod.js
new file mode 100644
index 000000000..81fe9ee42
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/mod.js
@@ -0,0 +1,68 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Ci } = require("chrome");
+const { dispatcher } = require("../util/dispatcher");
+const { add, remove, iterator } = require("../lang/weak-set");
+
+var getTargetWindow = dispatcher("getTargetWindow");
+
+getTargetWindow.define(function (target) {
+  if (target instanceof Ci.nsIDOMWindow)
+    return target;
+  if (target instanceof Ci.nsIDOMDocument)
+    return target.defaultView || null;
+
+  return null;
+});
+
+exports.getTargetWindow = getTargetWindow;
+
+var attachTo = dispatcher("attachTo");
+exports.attachTo = attachTo;
+
+var detachFrom = dispatcher("detatchFrom");
+exports.detachFrom = detachFrom;
+
+function attach(modification, target) {
+  if (!modification)
+    return;
+
+  let window = getTargetWindow(target);
+
+  attachTo(modification, window);
+
+  // modification are stored per content; `window` reference can still be the
+  // same even if the content is changed, therefore `document` is used instead.
+  add(modification, window.document);
+}
+exports.attach = attach;
+
+function detach(modification, target) {
+  if (!modification)
+    return;
+
+  if (target) {
+    let window = getTargetWindow(target);
+    detachFrom(modification, window);
+    remove(modification, window.document);
+  }
+  else {
+    let documents = iterator(modification);
+    for (let document of documents) {
+      let window = document.defaultView;
+      // The window might have already gone away
+      if (!window)
+        continue;
+      detachFrom(modification, document.defaultView);
+      remove(modification, document);
+    }
+  }
+}
+exports.detach = detach;
diff --git a/toolkit/jetpack/sdk/content/page-mod.js b/toolkit/jetpack/sdk/content/page-mod.js
new file mode 100644
index 000000000..8ff9b1e7b
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/page-mod.js
@@ -0,0 +1,236 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { getAttachEventType } = require('../content/utils');
+const { Class } = require('../core/heritage');
+const { Disposable } = require('../core/disposable');
+const { WeakReference } = require('../core/reference');
+const { WorkerChild } = require('./worker-child');
+const { EventTarget } = require('../event/target');
+const { on, emit, once, setListeners } = require('../event/core');
+const { on: domOn, removeListener: domOff } = require('../dom/events');
+const { isRegExp, isUndefined } = require('../lang/type');
+const { merge } = require('../util/object');
+const { isBrowser, getFrames } = require('../window/utils');
+const { getTabs, getURI: getTabURI } = require('../tabs/utils');
+const { ignoreWindow } = require('../private-browsing/utils');
+const { Style } = require("../stylesheet/style");
+const { attach, detach } = require("../content/mod");
+const { has, hasAny } = require("../util/array");
+const { Rules } = require("../util/rules");
+const { List, addListItem, removeListItem } = require('../util/list');
+const { when } = require("../system/unload");
+const { uuid } = require('../util/uuid');
+const { frames, process } = require('../remote/child');
+
+const pagemods = new Map();
+const styles = new WeakMap();
+var styleFor = (mod) => styles.get(mod);
+
+// Helper functions
+var modMatchesURI = (mod, uri) => mod.include.matchesAny(uri) && !mod.exclude.matchesAny(uri);
+
+/**
+ * PageMod constructor (exported below).
+ * @constructor
+ */
+const ChildPageMod = Class({
+  implements: [
+    EventTarget,
+    Disposable,
+  ],
+  setup: function PageMod(model) {
+    merge(this, model);
+
+    // Set listeners on {PageMod} itself, not the underlying worker,
+    // like `onMessage`, as it'll get piped.
+    setListeners(this, model);
+
+    function deserializeRules(rules) {
+      for (let rule of rules) {
+        yield rule.type == "string" ? rule.value
+                                    : new RegExp(rule.pattern, rule.flags);
+      }
+    }
+
+    let include = [...deserializeRules(this.include)];
+    this.include = Rules();
+    this.include.add.apply(this.include, include);
+
+    let exclude = [...deserializeRules(this.exclude)];
+    this.exclude = Rules();
+    this.exclude.add.apply(this.exclude, exclude);
+
+    if (this.contentStyle || this.contentStyleFile) {
+      styles.set(this, Style({
+        uri: this.contentStyleFile,
+        source: this.contentStyle
+      }));
+    }
+
+    pagemods.set(this.id, this);
+    this.seenDocuments = new WeakMap();
+
+    // `applyOnExistingDocuments` has to be called after `pagemods.add()`
+    // otherwise its calls to `onContent` method won't do anything.
+    if (has(this.attachTo, 'existing'))
+      applyOnExistingDocuments(this);
+  },
+
+  dispose: function() {
+    let style = styleFor(this);
+    if (style)
+      detach(style);
+
+    for (let i in this.include)
+      this.include.remove(this.include[i]);
+
+    pagemods.delete(this.id);
+  }
+});
+
+function onContentWindow({ target: document }) {
+  // Return if we have no pagemods
+  if (pagemods.size === 0)
+    return;
+
+  let window = document.defaultView;
+  // XML documents don't have windows, and we don't yet support them.
+  if (!window)
+    return;
+
+  // Frame event listeners are bound to the frame the event came from by default
+  let frame = this;
+  // We apply only on documents in tabs of Firefox
+  if (!frame.isTab)
+    return;
+
+  // When the tab is private, only addons with 'private-browsing' flag in
+  // their package.json can apply content script to private documents
+  if (ignoreWindow(window))
+    return;
+
+  for (let pagemod of pagemods.values()) {
+    if (modMatchesURI(pagemod, window.location.href))
+      onContent(pagemod, window);
+  }
+}
+frames.addEventListener("DOMDocElementInserted", onContentWindow, true);
+
+function applyOnExistingDocuments (mod) {
+  for (let frame of frames) {
+    // Fake a newly created document
+    let window = frame.content;
+    // on startup with e10s, contentWindow might not exist yet,
+    // in which case we will get notified by "document-element-inserted".
+    if (!window || !window.frames)
+      return;
+    let uri = window.location.href;
+    if (has(mod.attachTo, "top") && modMatchesURI(mod, uri))
+      onContent(mod, window);
+    if (has(mod.attachTo, "frame"))
+      getFrames(window).
+        filter(iframe => modMatchesURI(mod, iframe.location.href)).
+        forEach(frame => onContent(mod, frame));
+  }
+}
+
+function createWorker(mod, window) {
+  let workerId = String(uuid());
+
+  // Instruct the parent to connect to this worker. Do this first so the parent
+  // side is connected before the worker attempts to send any messages there
+  let frame = frames.getFrameForWindow(window.top);
+  frame.port.emit('sdk/page-mod/worker-create', mod.id, {
+    id: workerId,
+    url: window.location.href
+  });
+
+  // Create a child worker and notify the parent
+  let worker = WorkerChild({
+    id: workerId,
+    window: window,
+    contentScript: mod.contentScript,
+    contentScriptFile: mod.contentScriptFile,
+    contentScriptOptions: mod.contentScriptOptions
+  });
+
+  once(worker, 'detach', () => worker.destroy());
+}
+
+function onContent (mod, window) {
+  let isTopDocument = window.top === window;
+  // Is a top level document and `top` is not set, ignore
+  if (isTopDocument && !has(mod.attachTo, "top"))
+    return;
+  // Is a frame document and `frame` is not set, ignore
+  if (!isTopDocument && !has(mod.attachTo, "frame"))
+    return;
+
+  // ensure we attach only once per document
+  let seen = mod.seenDocuments;
+  if (seen.has(window.document))
+    return;
+  seen.set(window.document, true);
+
+  let style = styleFor(mod);
+  if (style)
+    attach(style, window);
+
+  // Immediately evaluate content script if the document state is already
+  // matching contentScriptWhen expectations
+  if (isMatchingAttachState(mod, window)) {
+    createWorker(mod, window);
+    return;
+  }
+
+  let eventName = getAttachEventType(mod) || 'load';
+  domOn(window, eventName, function onReady (e) {
+    if (e.target.defaultView !== window)
+      return;
+    domOff(window, eventName, onReady, true);
+    createWorker(mod, window);
+
+    // Attaching is asynchronous so if the document is already loaded we will
+    // miss the pageshow event so send a synthetic one.
+    if (window.document.readyState == "complete") {
+      mod.on('attach', worker => {
+        try {
+          worker.send('pageshow');
+          emit(worker, 'pageshow');
+        }
+        catch (e) {
+          // This can fail if an earlier attach listener destroyed the worker
+        }
+      });
+    }
+  }, true);
+}
+
+function isMatchingAttachState (mod, window) {
+  let state = window.document.readyState;
+  return 'start' === mod.contentScriptWhen ||
+      // Is `load` event already dispatched?
+      'complete' === state ||
+      // Is DOMContentLoaded already dispatched and waiting for it?
+      ('ready' === mod.contentScriptWhen && state === 'interactive')
+}
+
+process.port.on('sdk/page-mod/create', (process, model) => {
+  if (pagemods.has(model.id))
+    return;
+
+  new ChildPageMod(model);
+});
+
+process.port.on('sdk/page-mod/destroy', (process, id) => {
+  let mod = pagemods.get(id);
+  if (mod)
+    mod.destroy();
+});
diff --git a/toolkit/jetpack/sdk/content/page-worker.js b/toolkit/jetpack/sdk/content/page-worker.js
new file mode 100644
index 000000000..e9e741120
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/page-worker.js
@@ -0,0 +1,154 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { frames } = require("../remote/child");
+const { Class } = require("../core/heritage");
+const { Disposable } = require('../core/disposable');
+const { data } = require("../self");
+const { once } = require("../dom/events");
+const { getAttachEventType } = require("./utils");
+const { Rules } = require('../util/rules');
+const { uuid } = require('../util/uuid');
+const { WorkerChild } = require("./worker-child");
+const { Cc, Ci, Cu } = require("chrome");
+const { observe } = require("../event/chrome");
+const { on } = require("../event/core");
+
+const appShell = Cc["@mozilla.org/appshell/appShellService;1"].getService(Ci.nsIAppShellService);
+
+const { XPCOMUtils } = require("resource://gre/modules/XPCOMUtils.jsm");
+
+const pages = new Map();
+
+const DOC_INSERTED = "document-element-inserted";
+
+function isValidURL(page, url) {
+  return !page.rules || page.rules.matchesAny(url);
+}
+
+const ChildPage = Class({
+  implements: [ Disposable ],
+  setup: function(frame, id, options) {
+    this.id = id;
+    this.frame = frame;
+    this.options = options;
+
+    this.webNav = appShell.createWindowlessBrowser(false);
+    this.docShell.allowJavascript = this.options.allow.script;
+
+    // Accessing the browser's window forces the initial about:blank document to
+    // be created before we start listening for notifications
+    this.contentWindow;
+
+    this.webProgress.addProgressListener(this, Ci.nsIWebProgress.NOTIFY_LOCATION);
+
+    pages.set(this.id, this);
+
+    this.contentURL = options.contentURL;
+
+    if (options.include) {
+      this.rules = Rules();
+      this.rules.add.apply(this.rules, [].concat(options.include));
+    }
+  },
+
+  dispose: function() {
+    pages.delete(this.id);
+    this.webProgress.removeProgressListener(this);
+    this.webNav.close();
+    this.webNav = null;
+  },
+
+  attachWorker: function() {
+    if (!isValidURL(this, this.contentWindow.location.href))
+      return;
+
+    this.options.id = uuid().toString();
+    this.options.window = this.contentWindow;
+    this.frame.port.emit("sdk/frame/connect", this.id, {
+      id: this.options.id,
+      url: this.contentWindow.document.documentURIObject.spec
+    });
+    new WorkerChild(this.options);
+  },
+
+  get docShell() {
+    return this.webNav.QueryInterface(Ci.nsIInterfaceRequestor)
+                      .getInterface(Ci.nsIDocShell);
+  },
+
+  get webProgress() {
+    return this.docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+                        .getInterface(Ci.nsIWebProgress);
+  },
+
+  get contentWindow() {
+    return this.docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+                        .getInterface(Ci.nsIDOMWindow);
+  },
+
+  get contentURL() {
+    return this.options.contentURL;
+  },
+  set contentURL(url) {
+    this.options.contentURL = url;
+
+    url = this.options.contentURL ? data.url(this.options.contentURL) : "about:blank";
+    this.webNav.loadURI(url, Ci.nsIWebNavigation.LOAD_FLAGS_NONE, null, null, null);
+  },
+
+  onLocationChange: function(progress, request, location, flags) {
+    // Ignore inner-frame events
+    if (progress != this.webProgress)
+      return;
+    // Ignore events that don't change the document
+    if (flags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT)
+      return;
+
+    let event = getAttachEventType(this.options);
+    // Attaching at the start of the load is handled by the
+    // document-element-inserted listener.
+    if (event == DOC_INSERTED)
+      return;
+
+    once(this.contentWindow, event, () => {
+      this.attachWorker();
+    }, false);
+  },
+
+  QueryInterface: XPCOMUtils.generateQI(["nsIWebProgressListener", "nsISupportsWeakReference"])
+});
+
+on(observe(DOC_INSERTED), "data", ({ target }) => {
+  let page = Array.from(pages.values()).find(p => p.contentWindow.document === target);
+  if (!page)
+    return;
+
+  if (getAttachEventType(page.options) == DOC_INSERTED)
+    page.attachWorker();
+});
+
+frames.port.on("sdk/frame/create", (frame, id, options) => {
+  new ChildPage(frame, id, options);
+});
+
+frames.port.on("sdk/frame/set", (frame, id, params) => {
+  let page = pages.get(id);
+  if (!page)
+    return;
+
+  if ("allowScript" in params)
+    page.docShell.allowJavascript = params.allowScript;
+  if ("contentURL" in params)
+    page.contentURL = params.contentURL;
+});
+
+frames.port.on("sdk/frame/destroy", (frame, id) => {
+  let page = pages.get(id);
+  if (!page)
+    return;
+
+  page.destroy();
+});
diff --git a/toolkit/jetpack/sdk/content/sandbox.js b/toolkit/jetpack/sdk/content/sandbox.js
new file mode 100644
index 000000000..096ba5c87
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/sandbox.js
@@ -0,0 +1,426 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+const { Class } = require('../core/heritage');
+const { EventTarget } = require('../event/target');
+const { on, off, emit } = require('../event/core');
+const { events } = require('./sandbox/events');
+const { requiresAddonGlobal } = require('./utils');
+const { delay: async } = require('../lang/functional');
+const { Ci, Cu, Cc } = require('chrome');
+const timer = require('../timers');
+const { URL } = require('../url');
+const { sandbox, evaluate, load } = require('../loader/sandbox');
+const { merge } = require('../util/object');
+const { getTabForContentWindowNoShim } = require('../tabs/utils');
+const { getInnerId } = require('../window/utils');
+const { PlainTextConsole } = require('../console/plain-text');
+const { data } = require('../self');const { isChildLoader } = require('../remote/core');
+// WeakMap of sandboxes so we can access private values
+const sandboxes = new WeakMap();
+
+/* Trick the linker in order to ensure shipping these files in the XPI.
+  require('./content-worker.js');
+  Then, retrieve URL of these files in the XPI:
+*/
+var prefix = module.uri.split('sandbox.js')[0];
+const CONTENT_WORKER_URL = prefix + 'content-worker.js';
+const metadata = require('@loader/options').metadata;
+
+// Fetch additional list of domains to authorize access to for each content
+// script. It is stored in manifest `metadata` field which contains
+// package.json data. This list is originaly defined by authors in
+// `permissions` attribute of their package.json addon file.
+const permissions = (metadata && metadata['permissions']) || {};
+const EXPANDED_PRINCIPALS = permissions['cross-domain-content'] || [];
+
+const waiveSecurityMembrane = !!permissions['unsafe-content-script'];
+
+const nsIScriptSecurityManager = Ci.nsIScriptSecurityManager;
+const secMan = Cc["@mozilla.org/scriptsecuritymanager;1"].
+  getService(Ci.nsIScriptSecurityManager);
+
+const JS_VERSION = '1.8';
+
+// Tests whether this window is loaded in a tab
+function isWindowInTab(window) {
+  if (isChildLoader) {
+    let { frames } = require('../remote/child');
+    let frame = frames.getFrameForWindow(window.top);
+    return frame && frame.isTab;
+  }
+  else {
+    // The deprecated sync worker API still does everything in the main process
+    return getTabForContentWindowNoShim(window);
+  }
+}
+
+const WorkerSandbox = Class({
+  implements: [ EventTarget ],
+
+  /**
+   * Emit a message to the worker content sandbox
+   */
+  emit: function emit(type, ...args) {
+    // JSON.stringify is buggy with cross-sandbox values,
+    // it may return "{}" on functions. Use a replacer to match them correctly.
+    let replacer = (k, v) =>
+      typeof(v) === "function"
+        ? (type === "console" ? Function.toString.call(v) : void(0))
+        : v;
+
+    // Ensure having an asynchronous behavior
+    async(() =>
+      emitToContent(this, JSON.stringify([type, ...args], replacer))
+    );
+  },
+
+  /**
+   * Synchronous version of `emit`.
+   * /!\ Should only be used when it is strictly mandatory /!\
+   *     Doesn't ensure passing only JSON values.
+   *     Mainly used by context-menu in order to avoid breaking it.
+   */
+  emitSync: function emitSync(...args) {
+    // because the arguments could be also non JSONable values,
+    // we need to ensure the array instance is created from
+    // the content's sandbox
+    return emitToContent(this, new modelFor(this).sandbox.Array(...args));
+  },
+
+  /**
+   * Configures sandbox and loads content scripts into it.
+   * @param {Worker} worker
+   *    content worker
+   */
+  initialize: function WorkerSandbox(worker, window) {
+    let model = {};
+    sandboxes.set(this, model);
+    model.worker = worker;
+    // We receive a wrapped window, that may be an xraywrapper if it's content
+    let proto = window;
+
+    // TODO necessary?
+    // Ensure that `emit` has always the right `this`
+    this.emit = this.emit.bind(this);
+    this.emitSync = this.emitSync.bind(this);
+
+    // Use expanded principal for content-script if the content is a
+    // regular web content for better isolation.
+    // (This behavior can be turned off for now with the unsafe-content-script
+    // flag to give addon developers time for making the necessary changes)
+    // But prevent it when the Worker isn't used for a content script but for
+    // injecting `addon` object into a Panel scope, for example.
+    // That's because:
+    // 1/ It is useless to use multiple domains as the worker is only used
+    // to communicate with the addon,
+    // 2/ By using it it would prevent the document to have access to any JS
+    // value of the worker. As JS values coming from multiple domain principals
+    // can't be accessed by 'mono-principals' (principal with only one domain).
+    // Even if this principal is for a domain that is specified in the multiple
+    // domain principal.
+    let principals = window;
+    let wantGlobalProperties = [];
+    let isSystemPrincipal = secMan.isSystemPrincipal(
+      window.document.nodePrincipal);
+    if (!isSystemPrincipal && !requiresAddonGlobal(worker)) {
+      if (EXPANDED_PRINCIPALS.length > 0) {
+        // We have to replace XHR constructor of the content document
+        // with a custom cross origin one, automagically added by platform code:
+        delete proto.XMLHttpRequest;
+        wantGlobalProperties.push('XMLHttpRequest');
+      }
+      if (!waiveSecurityMembrane)
+        principals = EXPANDED_PRINCIPALS.concat(window);
+    }
+
+    // Create the sandbox and bind it to window in order for content scripts to
+    // have access to all standard globals (window, document, ...)
+    let content = sandbox(principals, {
+      sandboxPrototype: proto,
+      wantXrays: !requiresAddonGlobal(worker),
+      wantGlobalProperties: wantGlobalProperties,
+      wantExportHelpers: true,
+      sameZoneAs: window,
+      metadata: {
+        SDKContentScript: true,
+        'inner-window-id': getInnerId(window)
+      }
+    });
+    model.sandbox = content;
+
+    // We have to ensure that window.top and window.parent are the exact same
+    // object than window object, i.e. the sandbox global object. But not
+    // always, in case of iframes, top and parent are another window object.
+    let top = window.top === window ? content : content.top;
+    let parent = window.parent === window ? content : content.parent;
+    merge(content, {
+      // We need 'this === window === top' to be true in toplevel scope:
+      get window() {
+        return content;
+      },
+      get top() {
+        return top;
+      },
+      get parent() {
+        return parent;
+      }
+    });
+
+    // Use the Greasemonkey naming convention to provide access to the
+    // unwrapped window object so the content script can access document
+    // JavaScript values.
+    // NOTE: this functionality is experimental and may change or go away
+    // at any time!
+    //
+    // Note that because waivers aren't propagated between origins, we
+    // need the unsafeWindow getter to live in the sandbox.
+    var unsafeWindowGetter =
+      new content.Function('return window.wrappedJSObject || window;');
+    Object.defineProperty(content, 'unsafeWindow', {get: unsafeWindowGetter});
+
+    // Load trusted code that will inject content script API.
+    let ContentWorker = load(content, CONTENT_WORKER_URL);
+
+    // prepare a clean `self.options`
+    let options = 'contentScriptOptions' in worker ?
+      JSON.stringify(worker.contentScriptOptions) :
+      undefined;
+
+    // Then call `inject` method and communicate with this script
+    // by trading two methods that allow to send events to the other side:
+    //   - `onEvent` called by content script
+    //   - `result.emitToContent` called by addon script
+    let onEvent = Cu.exportFunction(onContentEvent.bind(null, this), ContentWorker);
+    let chromeAPI = createChromeAPI(ContentWorker);
+    let result = Cu.waiveXrays(ContentWorker).inject(content, chromeAPI, onEvent, options);
+
+    // Merge `emitToContent` into our private model of the
+    // WorkerSandbox so we can communicate with content script
+    model.emitToContent = result;
+
+    let console = new PlainTextConsole(null, getInnerId(window));
+
+    // Handle messages send by this script:
+    setListeners(this, console);
+
+    // Inject `addon` global into target document if document is trusted,
+    // `addon` in document is equivalent to `self` in content script.
+    if (requiresAddonGlobal(worker)) {
+      Object.defineProperty(getUnsafeWindow(window), 'addon', {
+          value: content.self,
+          configurable: true
+        }
+      );
+    }
+
+    // Inject our `console` into target document if worker doesn't have a tab
+    // (e.g Panel, PageWorker).
+    // `worker.tab` can't be used because bug 804935.
+    if (!isWindowInTab(window)) {
+      let win = getUnsafeWindow(window);
+
+      // export our chrome console to content window, as described here:
+      // https://developer.mozilla.org/en-US/docs/Components.utils.createObjectIn
+      let con = Cu.createObjectIn(win);
+
+      let genPropDesc = function genPropDesc(fun) {
+        return { enumerable: true, configurable: true, writable: true,
+          value: console[fun] };
+      }
+
+      const properties = {
+        log: genPropDesc('log'),
+        info: genPropDesc('info'),
+        warn: genPropDesc('warn'),
+        error: genPropDesc('error'),
+        debug: genPropDesc('debug'),
+        trace: genPropDesc('trace'),
+        dir: genPropDesc('dir'),
+        group: genPropDesc('group'),
+        groupCollapsed: genPropDesc('groupCollapsed'),
+        groupEnd: genPropDesc('groupEnd'),
+        time: genPropDesc('time'),
+        timeEnd: genPropDesc('timeEnd'),
+        profile: genPropDesc('profile'),
+        profileEnd: genPropDesc('profileEnd'),
+        exception: genPropDesc('exception'),
+        assert: genPropDesc('assert'),
+        count: genPropDesc('count'),
+        table: genPropDesc('table'),
+        clear: genPropDesc('clear'),
+        dirxml: genPropDesc('dirxml'),
+        markTimeline: genPropDesc('markTimeline'),
+        timeline: genPropDesc('timeline'),
+        timelineEnd: genPropDesc('timelineEnd'),
+        timeStamp: genPropDesc('timeStamp'),
+      };
+
+      Object.defineProperties(con, properties);
+      Cu.makeObjectPropsNormal(con);
+
+      win.console = con;
+    };
+
+    emit(events, "content-script-before-inserted", {
+      window: window,
+      worker: worker
+    });
+
+    // The order of `contentScriptFile` and `contentScript` evaluation is
+    // intentional, so programs can load libraries like jQuery from script URLs
+    // and use them in scripts.
+    let contentScriptFile = ('contentScriptFile' in worker)
+          ? worker.contentScriptFile
+          : null,
+        contentScript = ('contentScript' in worker)
+          ? worker.contentScript
+          : null;
+
+    if (contentScriptFile)
+      importScripts.apply(null, [this].concat(contentScriptFile));
+
+    if (contentScript) {
+      evaluateIn(
+        this,
+        Array.isArray(contentScript) ? contentScript.join(';\n') : contentScript
+      );
+    }
+  },
+  destroy: function destroy(reason) {
+    if (typeof reason != 'string')
+      reason = '';
+    this.emitSync('event', 'detach', reason);
+    let model = modelFor(this);
+    model.sandbox = null
+    model.worker = null;
+  },
+
+});
+
+exports.WorkerSandbox = WorkerSandbox;
+
+/**
+ * Imports scripts to the sandbox by reading files under urls and
+ * evaluating its source. If exception occurs during evaluation
+ * `'error'` event is emitted on the worker.
+ * This is actually an analog to the `importScript` method in web
+ * workers but in our case it's not exposed even though content
+ * scripts may be able to do it synchronously since IO operation
+ * takes place in the UI process.
+ */
+function importScripts (workerSandbox, ...urls) {
+  let { worker, sandbox } = modelFor(workerSandbox);
+  for (let i in urls) {
+    let contentScriptFile = data.url(urls[i]);
+
+    try {
+      let uri = URL(contentScriptFile);
+      if (uri.scheme === 'resource')
+        load(sandbox, String(uri));
+      else
+        throw Error('Unsupported `contentScriptFile` url: ' + String(uri));
+    }
+    catch(e) {
+      emit(worker, 'error', e);
+    }
+  }
+}
+
+function setListeners (workerSandbox, console) {
+  let { worker } = modelFor(workerSandbox);
+  // console.xxx calls
+  workerSandbox.on('console', function consoleListener (kind, ...args) {
+    console[kind].apply(console, args);
+  });
+
+  // self.postMessage calls
+  workerSandbox.on('message', function postMessage(data) {
+    // destroyed?
+    if (worker)
+      emit(worker, 'message', data);
+  });
+
+  // self.port.emit calls
+  workerSandbox.on('event', function portEmit (...eventArgs) {
+    // If not destroyed, emit event information to worker
+    // `eventArgs` has the event name as first element,
+    // and remaining elements are additional arguments to pass
+    if (worker)
+      emit.apply(null, [worker.port].concat(eventArgs));
+  });
+
+  // unwrap, recreate and propagate async Errors thrown from content-script
+  workerSandbox.on('error', function onError({instanceOfError, value}) {
+    if (worker) {
+      let error = value;
+      if (instanceOfError) {
+        error = new Error(value.message, value.fileName, value.lineNumber);
+        error.stack = value.stack;
+        error.name = value.name;
+      }
+      emit(worker, 'error', error);
+    }
+  });
+}
+
+/**
+ * Evaluates code in the sandbox.
+ * @param {String} code
+ *    JavaScript source to evaluate.
+ * @param {String} [filename='javascript:' + code]
+ *    Name of the file
+ */
+function evaluateIn (workerSandbox, code, filename) {
+  let { worker, sandbox } = modelFor(workerSandbox);
+  try {
+    evaluate(sandbox, code, filename || 'javascript:' + code);
+  }
+  catch(e) {
+    emit(worker, 'error', e);
+  }
+}
+
+/**
+ * Method called by the worker sandbox when it needs to send a message
+ */
+function onContentEvent (workerSandbox, args) {
+  // As `emit`, we ensure having an asynchronous behavior
+  async(function () {
+    // We emit event to chrome/addon listeners
+    emit.apply(null, [workerSandbox].concat(JSON.parse(args)));
+  });
+}
+
+
+function modelFor (workerSandbox) {
+  return sandboxes.get(workerSandbox);
+}
+
+function getUnsafeWindow (win) {
+  return win.wrappedJSObject || win;
+}
+
+function emitToContent (workerSandbox, args) {
+  return modelFor(workerSandbox).emitToContent(args);
+}
+
+function createChromeAPI (scope) {
+  return Cu.cloneInto({
+    timers: {
+      setTimeout: timer.setTimeout.bind(timer),
+      setInterval: timer.setInterval.bind(timer),
+      clearTimeout: timer.clearTimeout.bind(timer),
+      clearInterval: timer.clearInterval.bind(timer),
+    },
+    sandbox: {
+      evaluate: evaluate,
+    },
+  }, scope, {cloneFunctions: true});
+}
diff --git a/toolkit/jetpack/sdk/content/sandbox/events.js b/toolkit/jetpack/sdk/content/sandbox/events.js
new file mode 100644
index 000000000..d6f7eb004
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/sandbox/events.js
@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const events = {};
+exports.events = events;
diff --git a/toolkit/jetpack/sdk/content/tab-events.js b/toolkit/jetpack/sdk/content/tab-events.js
new file mode 100644
index 000000000..9e244a853
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/tab-events.js
@@ -0,0 +1,58 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Ci } = require('chrome');
+const system = require('sdk/system/events');
+const { frames } = require('sdk/remote/child');
+const { WorkerChild } = require('sdk/content/worker-child');
+
+// map observer topics to tab event names
+const EVENTS = {
+  'content-document-global-created': 'create',
+  'chrome-document-global-created': 'create',
+  'content-document-interactive': 'ready',
+  'chrome-document-interactive': 'ready',
+  'content-document-loaded': 'load',
+  'chrome-document-loaded': 'load',
+// 'content-page-shown': 'pageshow', // bug 1024105
+}
+
+function topicListener({ subject, type }) {
+  // NOTE detect the window from the subject:
+  // - on *-global-created the subject is the window
+  // - in the other cases it is the document object
+  let window = subject instanceof Ci.nsIDOMWindow ? subject : subject.defaultView;
+  if (!window){
+    return;
+  }
+  let frame = frames.getFrameForWindow(window);
+  if (frame) {
+    let readyState = frame.content.document.readyState;
+    frame.port.emit('sdk/tab/event', EVENTS[type], { readyState });
+  }
+}
+
+for (let topic in EVENTS)
+  system.on(topic, topicListener, true);
+
+// bug 1024105 - content-page-shown notification doesn't pass persisted param
+function eventListener({target, type, persisted}) {
+  let frame = this;
+  if (target === frame.content.document) {
+    frame.port.emit('sdk/tab/event', type, persisted);
+  }
+}
+frames.addEventListener('pageshow', eventListener, true);
+
+frames.port.on('sdk/tab/attach', (frame, options) => {
+  options.window = frame.content;
+  new WorkerChild(options);
+});
+
+// Forward the existent frames's readyState.
+for (let frame of frames) {
+  let readyState = frame.content.document.readyState;
+  frame.port.emit('sdk/tab/event', 'init', { readyState });
+}
diff --git a/toolkit/jetpack/sdk/content/thumbnail.js b/toolkit/jetpack/sdk/content/thumbnail.js
new file mode 100644
index 000000000..783615fc6
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/thumbnail.js
@@ -0,0 +1,51 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+const { Cc, Ci, Cu } = require('chrome');
+const AppShellService = Cc['@mozilla.org/appshell/appShellService;1'].
+                        getService(Ci.nsIAppShellService);
+
+const NS = 'http://www.w3.org/1999/xhtml';
+const COLOR = 'rgb(255,255,255)';
+
+/**
+ * Creates canvas element with a thumbnail of the passed window.
+ * @param {Window} window
+ * @returns {Element}
+ */
+function getThumbnailCanvasForWindow(window) {
+  let aspectRatio = 0.5625; // 16:9
+  let thumbnail = AppShellService.hiddenDOMWindow.document
+                    .createElementNS(NS, 'canvas');
+  thumbnail.mozOpaque = true;
+  thumbnail.width = Math.ceil(window.screen.availWidth / 5.75);
+  thumbnail.height = Math.round(thumbnail.width * aspectRatio);
+  let ctx = thumbnail.getContext('2d');
+  let snippetWidth = window.innerWidth * .6;
+  let scale = thumbnail.width / snippetWidth;
+  ctx.scale(scale, scale);
+  ctx.drawWindow(window, window.scrollX, window.scrollY, snippetWidth,
+                snippetWidth * aspectRatio, COLOR);
+  return thumbnail;
+}
+exports.getThumbnailCanvasForWindow = getThumbnailCanvasForWindow;
+
+/**
+ * Creates Base64 encoded data URI of the thumbnail for the passed window.
+ * @param {Window} window
+ * @returns {String}
+ */
+exports.getThumbnailURIForWindow = function getThumbnailURIForWindow(window) {
+  return getThumbnailCanvasForWindow(window).toDataURL()
+};
+
+// default 80x45 blank when not available
+exports.BLANK = 'data:image/png;base64,' +
+  'iVBORw0KGgoAAAANSUhEUgAAAFAAAAAtCAYAAAA5reyyAAAAJElEQVRoge3BAQ'+
+  'EAAACCIP+vbkhAAQAAAAAAAAAAAAAAAADXBjhtAAGQ0AF/AAAAAElFTkSuQmCC';
diff --git a/toolkit/jetpack/sdk/content/utils.js b/toolkit/jetpack/sdk/content/utils.js
new file mode 100644
index 000000000..90995a614
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/utils.js
@@ -0,0 +1,105 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+var { merge } = require('../util/object');
+var { data } = require('../self');
+var assetsURI = data.url();
+var isArray = Array.isArray;
+var method = require('../../method/core');
+var { uuid } = require('../util/uuid');
+
+const isAddonContent = ({ contentURL }) =>
+  contentURL && data.url(contentURL).startsWith(assetsURI);
+
+exports.isAddonContent = isAddonContent;
+
+function hasContentScript({ contentScript, contentScriptFile }) {
+  return (isArray(contentScript) ? contentScript.length > 0 :
+         !!contentScript) ||
+         (isArray(contentScriptFile) ? contentScriptFile.length > 0 :
+         !!contentScriptFile);
+}
+exports.hasContentScript = hasContentScript;
+
+function requiresAddonGlobal(model) {
+  return model.injectInDocument || (isAddonContent(model) && !hasContentScript(model));
+}
+exports.requiresAddonGlobal = requiresAddonGlobal;
+
+function getAttachEventType(model) {
+  if (!model) return null;
+  let when = model.contentScriptWhen;
+  return requiresAddonGlobal(model) ? 'document-element-inserted' :
+         when === 'start' ? 'document-element-inserted' :
+         when === 'ready' ? 'DOMContentLoaded' :
+         when === 'end' ? 'load' :
+         null;
+}
+exports.getAttachEventType = getAttachEventType;
+
+var attach = method('worker-attach');
+exports.attach = attach;
+
+var connect = method('worker-connect');
+exports.connect = connect;
+
+var detach = method('worker-detach');
+exports.detach = detach;
+
+var destroy = method('worker-destroy');
+exports.destroy = destroy;
+
+function WorkerHost (workerFor) {
+  // Define worker properties that just proxy to underlying worker
+  return ['postMessage', 'port', 'url', 'tab'].reduce(function(proto, name) {
+    // Use descriptor properties instead so we can call
+    // the worker function in the context of the worker so we
+    // don't have to create new functions with `fn.bind(worker)`
+    let descriptorProp = {
+      value: function (...args) {
+        let worker = workerFor(this);
+        return worker[name].apply(worker, args);
+      }
+    };
+    
+    let accessorProp = {
+      get: function () { return workerFor(this)[name]; },
+      set: function (value) { workerFor(this)[name] = value; }
+    };
+
+    Object.defineProperty(proto, name, merge({
+      enumerable: true,
+      configurable: false,
+    }, isDescriptor(name) ? descriptorProp : accessorProp));
+    return proto;
+  }, {});
+  
+  function isDescriptor (prop) {
+    return ~['postMessage'].indexOf(prop);
+  }
+}
+exports.WorkerHost = WorkerHost;
+
+function makeChildOptions(options) {
+  function makeStringArray(arrayOrValue) {
+    if (!arrayOrValue)
+      return [];
+    return [].concat(arrayOrValue).map(String);
+  }
+
+  return {
+    id: String(uuid()),
+    contentScript: makeStringArray(options.contentScript),
+    contentScriptFile: makeStringArray(options.contentScriptFile),
+    contentScriptOptions: options.contentScriptOptions ?
+                          JSON.stringify(options.contentScriptOptions) :
+                          null,
+  }
+}
+exports.makeChildOptions = makeChildOptions;
diff --git a/toolkit/jetpack/sdk/content/worker-child.js b/toolkit/jetpack/sdk/content/worker-child.js
new file mode 100644
index 000000000..dbf65a933
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/worker-child.js
@@ -0,0 +1,158 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { merge } = require('../util/object');
+const { Class } = require('../core/heritage');
+const { emit } = require('../event/core');
+const { EventTarget } = require('../event/target');
+const { getInnerId, getByInnerId } = require('../window/utils');
+const { instanceOf, isObject } = require('../lang/type');
+const system = require('../system/events');
+const { when } = require('../system/unload');
+const { WorkerSandbox } = require('./sandbox');
+const { Ci } = require('chrome');
+const { process, frames } = require('../remote/child');
+
+const EVENTS = {
+  'chrome-page-shown': 'pageshow',
+  'content-page-shown': 'pageshow',
+  'chrome-page-hidden': 'pagehide',
+  'content-page-hidden': 'pagehide',
+  'inner-window-destroyed': 'detach',
+}
+
+// The parent Worker must have been created (or an async message sent to spawn
+// its creation) before creating the WorkerChild or messages from the content
+// script to the parent will get lost.
+const WorkerChild = Class({
+  implements: [EventTarget],
+
+  initialize(options) {
+    merge(this, options);
+    keepAlive.set(this.id, this);
+
+    this.windowId = getInnerId(this.window);
+    if (this.contentScriptOptions)
+      this.contentScriptOptions = JSON.parse(this.contentScriptOptions);
+
+    this.port = EventTarget();
+    this.port.on('*', this.send.bind(this, 'event'));
+    this.on('*', this.send.bind(this));
+
+    this.observe = this.observe.bind(this);
+
+    for (let topic in EVENTS)
+      system.on(topic, this.observe);
+
+    this.receive = this.receive.bind(this);
+    process.port.on('sdk/worker/message', this.receive);
+
+    this.sandbox = WorkerSandbox(this, this.window);
+
+    // If the document has an unexpected readyState, its worker-child instance is initialized
+    // as frozen until one of the known readyState is reached.
+    let initialDocumentReadyState = this.window.document.readyState;
+    this.frozen = [
+      "loading", "interactive", "complete"
+    ].includes(initialDocumentReadyState) ? false : true;
+
+    if (this.frozen) {
+      console.warn("SDK worker-child started as frozen on unexpected initial document.readyState", {
+        initialDocumentReadyState, windowLocation: this.window.location.href,
+      });
+    }
+
+    this.frozenMessages = [];
+    this.on('pageshow', () => {
+      this.frozen = false;
+      this.frozenMessages.forEach(args => this.sandbox.emit(...args));
+      this.frozenMessages = [];
+    });
+    this.on('pagehide', () => {
+      this.frozen = true;
+    });
+  },
+
+  // messages
+  receive(process, id, args) {
+    if (id !== this.id)
+      return;
+    args = JSON.parse(args);
+
+    if (this.frozen)
+      this.frozenMessages.push(args);
+    else
+      this.sandbox.emit(...args);
+
+    if (args[0] === 'detach')
+      this.destroy(args[1]);
+  },
+
+  send(...args) {
+    process.port.emit('sdk/worker/event', this.id, JSON.stringify(args, exceptions));
+  },
+
+  // notifications
+  observe({ type, subject }) {
+    if (!this.sandbox)
+      return;
+
+    if (subject.defaultView && getInnerId(subject.defaultView) === this.windowId) {
+      this.sandbox.emitSync(EVENTS[type]);
+      emit(this, EVENTS[type]);
+    }
+
+    if (type === 'inner-window-destroyed' &&
+        subject.QueryInterface(Ci.nsISupportsPRUint64).data === this.windowId) {
+      this.destroy();
+    }
+  },
+
+  get frame() {
+    return frames.getFrameForWindow(this.window.top);
+  },
+
+  // detach/destroy: unload and release the sandbox
+  destroy(reason) {
+    if (!this.sandbox)
+      return;
+
+    for (let topic in EVENTS)
+      system.off(topic, this.observe);
+    process.port.off('sdk/worker/message', this.receive);
+
+    this.sandbox.destroy(reason);
+    this.sandbox = null;
+    keepAlive.delete(this.id);
+
+    this.send('detach');
+  }
+})
+exports.WorkerChild = WorkerChild;
+
+// Error instances JSON poorly
+function exceptions(key, value) {
+  if (!isObject(value) || !instanceOf(value, Error))
+    return value;
+  let _errorType = value.constructor.name;
+  let { message, fileName, lineNumber, stack, name } = value;
+  return { _errorType, message, fileName, lineNumber, stack, name };
+}
+
+// workers for windows in this tab
+var keepAlive = new Map();
+
+process.port.on('sdk/worker/create', (process, options, cpows) => {
+  options.window = cpows.window;
+  let worker = new WorkerChild(options);
+
+  let frame = frames.getFrameForWindow(options.window.top);
+  frame.port.emit('sdk/worker/connect', options.id, options.window.location.href);
+});
+
+when(reason => {
+  for (let worker of keepAlive.values())
+    worker.destroy(reason);
+});
diff --git a/toolkit/jetpack/sdk/content/worker.js b/toolkit/jetpack/sdk/content/worker.js
new file mode 100644
index 000000000..39b940a88
--- /dev/null
+++ b/toolkit/jetpack/sdk/content/worker.js
@@ -0,0 +1,180 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { emit } = require('../event/core');
+const { omit, merge } = require('../util/object');
+const { Class } = require('../core/heritage');
+const { method } = require('../lang/functional');
+const { getInnerId } = require('../window/utils');
+const { EventTarget } = require('../event/target');
+const { isPrivate } = require('../private-browsing/utils');
+const { getTabForBrowser, getTabForContentWindowNoShim, getBrowserForTab } = require('../tabs/utils');
+const { attach, connect, detach, destroy, makeChildOptions } = require('./utils');
+const { ensure } = require('../system/unload');
+const { on: observe } = require('../system/events');
+const { Ci, Cu } = require('chrome');
+const { modelFor: tabFor } = require('sdk/model/core');
+const { remoteRequire, processes, frames } = require('../remote/parent');
+remoteRequire('sdk/content/worker-child');
+
+const workers = new WeakMap();
+var modelFor = (worker) => workers.get(worker);
+
+const ERR_DESTROYED = "Couldn't find the worker to receive this message. " +
+  "The script may not be initialized yet, or may already have been unloaded.";
+
+// a handle for communication between content script and addon code
+const Worker = Class({
+  implements: [EventTarget],
+
+  initialize(options = {}) {
+    ensure(this, 'detach');
+
+    let model = {
+      attached: false,
+      destroyed: false,
+      earlyEvents: [],        // fired before worker was attached
+      frozen: true,           // document is not yet active
+      options,
+    };
+    workers.set(this, model);
+
+    this.on('detach', this.detach);
+    EventTarget.prototype.initialize.call(this, options);
+
+    this.receive = this.receive.bind(this);
+
+    this.port = EventTarget();
+    this.port.emit = this.send.bind(this, 'event');
+    this.postMessage = this.send.bind(this, 'message');
+
+    if ('window' in options) {
+      let window = options.window;
+      delete options.window;
+      attach(this, window);
+    }
+  },
+
+  // messages
+  receive(process, id, args) {
+    let model = modelFor(this);
+    if (id !== model.id || !model.attached)
+      return;
+    args = JSON.parse(args);
+    if (model.destroyed && args[0] != 'detach')
+      return;
+
+    if (args[0] === 'event')
+      emit(this.port, ...args.slice(1))
+    else
+      emit(this, ...args);
+  },
+
+  send(...args) {
+    let model = modelFor(this);
+    if (model.destroyed && args[0] !== 'detach')
+      throw new Error(ERR_DESTROYED);
+
+    if (!model.attached) {
+      model.earlyEvents.push(args);
+      return;
+    }
+
+    processes.port.emit('sdk/worker/message', model.id, JSON.stringify(args));
+  },
+
+  // properties
+  get url() {
+    let { url } = modelFor(this);
+    return url;
+  },
+
+  get contentURL() {
+    return this.url;
+  },
+
+  get tab() {
+    require('sdk/tabs');
+    let { frame } = modelFor(this);
+    if (!frame)
+      return null;
+    let rawTab = getTabForBrowser(frame.frameElement);
+    return rawTab && tabFor(rawTab);
+  },
+
+  toString: () => '[object Worker]',
+
+  detach: method(detach),
+  destroy: method(destroy),
+})
+exports.Worker = Worker;
+
+attach.define(Worker, function(worker, window) {
+  let model = modelFor(worker);
+  if (model.attached)
+    detach(worker);
+
+  let childOptions = makeChildOptions(model.options);
+  processes.port.emitCPOW('sdk/worker/create', [childOptions], { window });
+
+  let listener = (frame, id, url) => {
+    if (id != childOptions.id)
+      return;
+    frames.port.off('sdk/worker/connect', listener);
+    connect(worker, frame, { id, url });
+  };
+  frames.port.on('sdk/worker/connect', listener);
+});
+
+connect.define(Worker, function(worker, frame, { id, url }) {
+  let model = modelFor(worker);
+  if (model.attached)
+    detach(worker);
+
+  model.id = id;
+  model.frame = frame;
+  model.url = url;
+
+  // Messages from content -> chrome come through the process message manager
+  // since that lives longer than the frame message manager
+  processes.port.on('sdk/worker/event', worker.receive);
+
+  model.attached = true;
+  model.destroyed = false;
+  model.frozen = false;
+
+  model.earlyEvents.forEach(args => worker.send(...args));
+  model.earlyEvents = [];
+  emit(worker, 'attach');
+});
+
+// unload and release the child worker, release window reference
+detach.define(Worker, function(worker) {
+  let model = modelFor(worker);
+  if (!model.attached)
+    return;
+
+  processes.port.off('sdk/worker/event', worker.receive);
+  model.attached = false;
+  model.destroyed = true;
+  emit(worker, 'detach');
+});
+
+isPrivate.define(Worker, ({ tab }) => isPrivate(tab));
+
+// Something in the parent side has destroyed the worker, tell the child to
+// detach, the child will respond when it has detached
+destroy.define(Worker, function(worker, reason) {
+  let model = modelFor(worker);
+  model.destroyed = true;
+  if (!model.attached)
+    return;
+
+  worker.send('detach', reason);
+});
diff --git a/toolkit/jetpack/sdk/context-menu.js b/toolkit/jetpack/sdk/context-menu.js
new file mode 100644
index 000000000..004c642d4
--- /dev/null
+++ b/toolkit/jetpack/sdk/context-menu.js
@@ -0,0 +1,1188 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "stable",
+  "engines": {
+    // TODO Fennec support Bug 788334
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+const { Class, mix } = require("./core/heritage");
+const { addCollectionProperty } = require("./util/collection");
+const { ns } = require("./core/namespace");
+const { validateOptions, getTypeOf } = require("./deprecated/api-utils");
+const { URL, isValidURI } = require("./url");
+const { WindowTracker, browserWindowIterator } = require("./deprecated/window-utils");
+const { isBrowser, getInnerId } = require("./window/utils");
+const { MatchPattern } = require("./util/match-pattern");
+const { EventTarget } = require("./event/target");
+const { emit } = require('./event/core');
+const { when } = require('./system/unload');
+const { contract: loaderContract } = require('./content/loader');
+const { omit } = require('./util/object');
+const self = require('./self')
+const { remoteRequire, processes } = require('./remote/parent');
+remoteRequire('sdk/content/context-menu');
+
+// All user items we add have this class.
+const ITEM_CLASS = "addon-context-menu-item";
+
+// Items in the top-level context menu also have this class.
+const TOPLEVEL_ITEM_CLASS = "addon-context-menu-item-toplevel";
+
+// Items in the overflow submenu also have this class.
+const OVERFLOW_ITEM_CLASS = "addon-context-menu-item-overflow";
+
+// The class of the menu separator that separates standard context menu items
+// from our user items.
+const SEPARATOR_CLASS = "addon-context-menu-separator";
+
+// If more than this number of items are added to the context menu, all items
+// overflow into a "Jetpack" submenu.
+const OVERFLOW_THRESH_DEFAULT = 10;
+const OVERFLOW_THRESH_PREF =
+  "extensions.addon-sdk.context-menu.overflowThreshold";
+
+// The label of the overflow sub-xul:menu.
+//
+// TODO: Localize these.
+const OVERFLOW_MENU_LABEL = "Add-ons";
+const OVERFLOW_MENU_ACCESSKEY = "A";
+
+// The class of the overflow sub-xul:menu.
+const OVERFLOW_MENU_CLASS = "addon-content-menu-overflow-menu";
+
+// The class of the overflow submenu's xul:menupopup.
+const OVERFLOW_POPUP_CLASS = "addon-content-menu-overflow-popup";
+
+// Holds private properties for API objects
+var internal = ns();
+
+// A little hacky but this is the last process ID that last opened the context
+// menu
+var lastContextProcessId = null;
+
+var uuidModule = require('./util/uuid');
+function uuid() {
+  return uuidModule.uuid().toString();
+}
+
+function getScheme(spec) {
+  try {
+    return URL(spec).scheme;
+  }
+  catch(e) {
+    return null;
+  }
+}
+
+var Context = Class({
+  initialize: function() {
+    internal(this).id = uuid();
+  },
+
+  // Returns the node that made this context current
+  adjustPopupNode: function adjustPopupNode(popupNode) {
+    return popupNode;
+  },
+
+  // Returns whether this context is current for the current node
+  isCurrent: function isCurrent(state) {
+    return state;
+  }
+});
+
+// Matches when the context-clicked node doesn't have any of
+// NON_PAGE_CONTEXT_ELTS in its ancestors
+var PageContext = Class({
+  extends: Context,
+
+  serialize: function() {
+    return {
+      id: internal(this).id,
+      type: "PageContext",
+      args: []
+    }
+  }
+});
+exports.PageContext = PageContext;
+
+// Matches when there is an active selection in the window
+var SelectionContext = Class({
+  extends: Context,
+
+  serialize: function() {
+    return {
+      id: internal(this).id,
+      type: "SelectionContext",
+      args: []
+    }
+  }
+});
+exports.SelectionContext = SelectionContext;
+
+// Matches when the context-clicked node or any of its ancestors matches the
+// selector given
+var SelectorContext = Class({
+  extends: Context,
+
+  initialize: function initialize(selector) {
+    Context.prototype.initialize.call(this);
+    let options = validateOptions({ selector: selector }, {
+      selector: {
+        is: ["string"],
+        msg: "selector must be a string."
+      }
+    });
+    internal(this).selector = options.selector;
+  },
+
+  serialize: function() {
+    return {
+      id: internal(this).id,
+      type: "SelectorContext",
+      args: [internal(this).selector]
+    }
+  }
+});
+exports.SelectorContext = SelectorContext;
+
+// Matches when the page url matches any of the patterns given
+var URLContext = Class({
+  extends: Context,
+
+  initialize: function initialize(patterns) {
+    Context.prototype.initialize.call(this);
+    patterns = Array.isArray(patterns) ? patterns : [patterns];
+
+    try {
+      internal(this).patterns = patterns.map(p => new MatchPattern(p));
+    }
+    catch (err) {
+      throw new Error("Patterns must be a string, regexp or an array of " +
+                      "strings or regexps: " + err);
+    }
+  },
+
+  isCurrent: function isCurrent(url) {
+    return internal(this).patterns.some(p => p.test(url));
+  },
+
+  serialize: function() {
+    return {
+      id: internal(this).id,
+      type: "URLContext",
+      args: []
+    }
+  }
+});
+exports.URLContext = URLContext;
+
+// Matches when the user-supplied predicate returns true
+var PredicateContext = Class({
+  extends: Context,
+
+  initialize: function initialize(predicate) {
+    Context.prototype.initialize.call(this);
+    let options = validateOptions({ predicate: predicate }, {
+      predicate: {
+        is: ["function"],
+        msg: "predicate must be a function."
+      }
+    });
+    internal(this).predicate = options.predicate;
+  },
+
+  isCurrent: function isCurrent(state) {
+    return internal(this).predicate(state);
+  },
+
+  serialize: function() {
+    return {
+      id: internal(this).id,
+      type: "PredicateContext",
+      args: []
+    }
+  }
+});
+exports.PredicateContext = PredicateContext;
+
+function removeItemFromArray(array, item) {
+  return array.filter(i => i !== item);
+}
+
+// Converts anything that isn't false, null or undefined into a string
+function stringOrNull(val) {
+  return val ? String(val) : val;
+}
+
+// Shared option validation rules for Item, Menu, and Separator
+var baseItemRules = {
+  parentMenu: {
+    is: ["object", "undefined"],
+    ok: function (v) {
+      if (!v)
+        return true;
+      return (v instanceof ItemContainer) || (v instanceof Menu);
+    },
+    msg: "parentMenu must be a Menu or not specified."
+  },
+  context: {
+    is: ["undefined", "object", "array"],
+    ok: function (v) {
+      if (!v)
+        return true;
+      let arr = Array.isArray(v) ? v : [v];
+      return arr.every(o => o instanceof Context);
+    },
+    msg: "The 'context' option must be a Context object or an array of " +
+         "Context objects."
+  },
+  onMessage: {
+    is: ["function", "undefined"]
+  },
+  contentScript: loaderContract.rules.contentScript,
+  contentScriptFile: loaderContract.rules.contentScriptFile
+};
+
+var labelledItemRules =  mix(baseItemRules, {
+  label: {
+    map: stringOrNull,
+    is: ["string"],
+    ok: v => !!v,
+    msg: "The item must have a non-empty string label."
+  },
+  accesskey: {
+    map: stringOrNull,
+    is: ["string", "undefined", "null"],
+    ok: (v) => {
+      if (!v) {
+        return true;
+      }
+      return typeof v == "string" && v.length === 1;
+    },
+    msg: "The item must have a single character accesskey, or no accesskey."
+  },
+  image: {
+    map: stringOrNull,
+    is: ["string", "undefined", "null"],
+    ok: function (url) {
+      if (!url)
+        return true;
+      return isValidURI(url);
+    },
+    msg: "Image URL validation failed"
+  }
+});
+
+// Additional validation rules for Item
+var itemRules = mix(labelledItemRules, {
+  data: {
+    map: stringOrNull,
+    is: ["string", "undefined", "null"]
+  }
+});
+
+// Additional validation rules for Menu
+var menuRules = mix(labelledItemRules, {
+  items: {
+    is: ["array", "undefined"],
+    ok: function (v) {
+      if (!v)
+        return true;
+      return v.every(function (item) {
+        return item instanceof BaseItem;
+      });
+    },
+    msg: "items must be an array, and each element in the array must be an " +
+         "Item, Menu, or Separator."
+  }
+});
+
+// Returns true if any contexts match. If there are no contexts then a
+// PageContext is tested instead
+function hasMatchingContext(contexts, addonInfo) {
+  for (let context of contexts) {
+    if (!(internal(context).id in addonInfo.contextStates)) {
+      console.error("Missing state for context " + internal(context).id + " this is an error in the SDK modules.");
+      return false;
+    }
+    if (!context.isCurrent(addonInfo.contextStates[internal(context).id]))
+      return false;
+  }
+
+  return true;
+}
+
+// Tests whether an item should be visible or not based on its contexts and
+// content scripts
+function isItemVisible(item, addonInfo, usePageWorker) {
+  if (!item.context.length) {
+    if (!addonInfo.hasWorker)
+      return usePageWorker ? addonInfo.pageContext : true;
+  }
+
+  if (!hasMatchingContext(item.context, addonInfo))
+    return false;
+
+  let context = addonInfo.workerContext;
+  if (typeof(context) === "string" && context != "")
+    item.label = context;
+
+  return !!context;
+}
+
+// Called when an item is clicked to send out click events to the content
+// scripts
+function itemActivated(item, clickedNode) {
+  let items = [internal(item).id];
+  let data = item.data;
+
+  while (item.parentMenu) {
+    item = item.parentMenu;
+    items.push(internal(item).id);
+  }
+
+  let process = processes.getById(lastContextProcessId);
+  if (process)
+    process.port.emit('sdk/contextmenu/activateitems', items, data);
+}
+
+function serializeItem(item) {
+  return {
+    id: internal(item).id,
+    contexts: item.context.map(c => c.serialize()),
+    contentScript: item.contentScript,
+    contentScriptFile: item.contentScriptFile,
+  };
+}
+
+// All things that appear in the context menu extend this
+var BaseItem = Class({
+  initialize: function initialize() {
+    internal(this).id = uuid();
+
+    internal(this).contexts = [];
+    if ("context" in internal(this).options && internal(this).options.context) {
+      let contexts = internal(this).options.context;
+      if (Array.isArray(contexts)) {
+        for (let context of contexts)
+          internal(this).contexts.push(context);
+      }
+      else {
+        internal(this).contexts.push(contexts);
+      }
+    }
+
+    let parentMenu = internal(this).options.parentMenu;
+    if (!parentMenu)
+      parentMenu = contentContextMenu;
+
+    parentMenu.addItem(this);
+
+    Object.defineProperty(this, "contentScript", {
+      enumerable: true,
+      value: internal(this).options.contentScript
+    });
+
+    // Resolve URIs here as tests may have overriden self
+    let files = internal(this).options.contentScriptFile;
+    if (files) {
+      if (!Array.isArray(files))
+        files = [files];
+      files = files.map(self.data.url);
+    }
+    internal(this).options.contentScriptFile = files;
+    Object.defineProperty(this, "contentScriptFile", {
+      enumerable: true,
+      value: internal(this).options.contentScriptFile
+    });
+
+    // Notify all frames of this new item
+    sendItems([serializeItem(this)]);
+  },
+
+  destroy: function destroy() {
+    if (internal(this).destroyed)
+      return;
+
+    // Tell all existing frames that this item has been destroyed
+    processes.port.emit("sdk/contextmenu/destroyitems", [internal(this).id]);
+
+    if (this.parentMenu)
+      this.parentMenu.removeItem(this);
+
+    internal(this).destroyed = true;
+  },
+
+  get context() {
+    let contexts = internal(this).contexts.slice(0);
+    contexts.add = (context) => {
+      internal(this).contexts.push(context);
+      // Notify all frames that this item has changed
+      sendItems([serializeItem(this)]);
+    };
+    contexts.remove = (context) => {
+      internal(this).contexts = internal(this).contexts.filter(c => {
+        return c != context;
+      });
+      // Notify all frames that this item has changed
+      sendItems([serializeItem(this)]);
+    };
+    return contexts;
+  },
+
+  set context(val) {
+    internal(this).contexts = val.slice(0);
+    // Notify all frames that this item has changed
+    sendItems([serializeItem(this)]);
+  },
+
+  get parentMenu() {
+    return internal(this).parentMenu;
+  },
+});
+
+function workerMessageReceived(process, id, args) {
+  if (internal(this).id != id)
+    return;
+
+  emit(this, ...JSON.parse(args));
+}
+
+// All things that have a label on the context menu extend this
+var LabelledItem = Class({
+  extends: BaseItem,
+  implements: [ EventTarget ],
+
+  initialize: function initialize(options) {
+    BaseItem.prototype.initialize.call(this);
+    EventTarget.prototype.initialize.call(this, options);
+
+    internal(this).messageListener = workerMessageReceived.bind(this);
+    processes.port.on('sdk/worker/event', internal(this).messageListener);
+  },
+
+  destroy: function destroy() {
+    if (internal(this).destroyed)
+      return;
+
+    processes.port.off('sdk/worker/event', internal(this).messageListener);
+
+    BaseItem.prototype.destroy.call(this);
+  },
+
+  get label() {
+    return internal(this).options.label;
+  },
+
+  set label(val) {
+    internal(this).options.label = val;
+
+    MenuManager.updateItem(this);
+  },
+
+  get accesskey() {
+    return internal(this).options.accesskey;
+  },
+
+  set accesskey(val) {
+    internal(this).options.accesskey = val;
+
+    MenuManager.updateItem(this);
+  },
+
+  get image() {
+    return internal(this).options.image;
+  },
+
+  set image(val) {
+    internal(this).options.image = val;
+
+    MenuManager.updateItem(this);
+  },
+
+  get data() {
+    return internal(this).options.data;
+  },
+
+  set data(val) {
+    internal(this).options.data = val;
+  }
+});
+
+var Item = Class({
+  extends: LabelledItem,
+
+  initialize: function initialize(options) {
+    internal(this).options = validateOptions(options, itemRules);
+
+    LabelledItem.prototype.initialize.call(this, options);
+  },
+
+  toString: function toString() {
+    return "[object Item \"" + this.label + "\"]";
+  },
+
+  get data() {
+    return internal(this).options.data;
+  },
+
+  set data(val) {
+    internal(this).options.data = val;
+
+    MenuManager.updateItem(this);
+  },
+});
+exports.Item = Item;
+
+var ItemContainer = Class({
+  initialize: function initialize() {
+    internal(this).children = [];
+  },
+
+  destroy: function destroy() {
+    // Destroys the entire hierarchy
+    for (let item of internal(this).children)
+      item.destroy();
+  },
+
+  addItem: function addItem(item) {
+    let oldParent = item.parentMenu;
+
+    // Don't just call removeItem here as that would remove the corresponding
+    // UI element which is more costly than just moving it to the right place
+    if (oldParent)
+      internal(oldParent).children = removeItemFromArray(internal(oldParent).children, item);
+
+    let after = null;
+    let children = internal(this).children;
+    if (children.length > 0)
+      after = children[children.length - 1];
+
+    children.push(item);
+    internal(item).parentMenu = this;
+
+    // If there was an old parent then we just have to move the item, otherwise
+    // it needs to be created
+    if (oldParent)
+      MenuManager.moveItem(item, after);
+    else
+      MenuManager.createItem(item, after);
+  },
+
+  removeItem: function removeItem(item) {
+    // If the item isn't a child of this menu then ignore this call
+    if (item.parentMenu !== this)
+      return;
+
+    MenuManager.removeItem(item);
+
+    internal(this).children = removeItemFromArray(internal(this).children, item);
+    internal(item).parentMenu = null;
+  },
+
+  get items() {
+    return internal(this).children.slice(0);
+  },
+
+  set items(val) {
+    // Validate the arguments before making any changes
+    if (!Array.isArray(val))
+      throw new Error(menuOptionRules.items.msg);
+
+    for (let item of val) {
+      if (!(item instanceof BaseItem))
+        throw new Error(menuOptionRules.items.msg);
+    }
+
+    // Remove the old items and add the new ones
+    for (let item of internal(this).children)
+      this.removeItem(item);
+
+    for (let item of val)
+      this.addItem(item);
+  },
+});
+
+var Menu = Class({
+  extends: LabelledItem,
+  implements: [ItemContainer],
+
+  initialize: function initialize(options) {
+    internal(this).options = validateOptions(options, menuRules);
+
+    LabelledItem.prototype.initialize.call(this, options);
+    ItemContainer.prototype.initialize.call(this);
+
+    if (internal(this).options.items) {
+      for (let item of internal(this).options.items)
+        this.addItem(item);
+    }
+  },
+
+  destroy: function destroy() {
+    ItemContainer.prototype.destroy.call(this);
+    LabelledItem.prototype.destroy.call(this);
+  },
+
+  toString: function toString() {
+    return "[object Menu \"" + this.label + "\"]";
+  },
+});
+exports.Menu = Menu;
+
+var Separator = Class({
+  extends: BaseItem,
+
+  initialize: function initialize(options) {
+    internal(this).options = validateOptions(options, baseItemRules);
+
+    BaseItem.prototype.initialize.call(this);
+  },
+
+  toString: function toString() {
+    return "[object Separator]";
+  }
+});
+exports.Separator = Separator;
+
+// Holds items for the content area context menu
+var contentContextMenu = ItemContainer();
+exports.contentContextMenu = contentContextMenu;
+
+function getContainerItems(container) {
+  let items = [];
+  for (let item of internal(container).children) {
+    items.push(serializeItem(item));
+    if (item instanceof Menu)
+      items = items.concat(getContainerItems(item));
+  }
+  return items;
+}
+
+// Notify all frames of these new or changed items
+function sendItems(items) {
+  processes.port.emit("sdk/contextmenu/createitems", items);
+}
+
+// Called when a new process is created and needs to get the current list of items
+function remoteItemRequest(process) {
+  let items = getContainerItems(contentContextMenu);
+  if (items.length == 0)
+    return;
+
+  process.port.emit("sdk/contextmenu/createitems", items);
+}
+processes.forEvery(remoteItemRequest);
+
+when(function() {
+  contentContextMenu.destroy();
+});
+
+// App specific UI code lives here, it should handle populating the context
+// menu and passing clicks etc. through to the items.
+
+function countVisibleItems(nodes) {
+  return Array.reduce(nodes, function(sum, node) {
+    return node.hidden ? sum : sum + 1;
+  }, 0);
+}
+
+var MenuWrapper = Class({
+  initialize: function initialize(winWrapper, items, contextMenu) {
+    this.winWrapper = winWrapper;
+    this.window = winWrapper.window;
+    this.items = items;
+    this.contextMenu = contextMenu;
+    this.populated = false;
+    this.menuMap = new Map();
+
+    // updateItemVisibilities will run first, updateOverflowState will run after
+    // all other instances of this module have run updateItemVisibilities
+    this._updateItemVisibilities = this.updateItemVisibilities.bind(this);
+    this.contextMenu.addEventListener("popupshowing", this._updateItemVisibilities, true);
+    this._updateOverflowState = this.updateOverflowState.bind(this);
+    this.contextMenu.addEventListener("popupshowing", this._updateOverflowState, false);
+  },
+
+  destroy: function destroy() {
+    this.contextMenu.removeEventListener("popupshowing", this._updateOverflowState, false);
+    this.contextMenu.removeEventListener("popupshowing", this._updateItemVisibilities, true);
+
+    if (!this.populated)
+      return;
+
+    // If we're getting unloaded at runtime then we must remove all the
+    // generated XUL nodes
+    let oldParent = null;
+    for (let item of internal(this.items).children) {
+      let xulNode = this.getXULNodeForItem(item);
+      oldParent = xulNode.parentNode;
+      oldParent.removeChild(xulNode);
+    }
+
+    if (oldParent)
+      this.onXULRemoved(oldParent);
+  },
+
+  get separator() {
+    return this.contextMenu.querySelector("." + SEPARATOR_CLASS);
+  },
+
+  get overflowMenu() {
+    return this.contextMenu.querySelector("." + OVERFLOW_MENU_CLASS);
+  },
+
+  get overflowPopup() {
+    return this.contextMenu.querySelector("." + OVERFLOW_POPUP_CLASS);
+  },
+
+  get topLevelItems() {
+    return this.contextMenu.querySelectorAll("." + TOPLEVEL_ITEM_CLASS);
+  },
+
+  get overflowItems() {
+    return this.contextMenu.querySelectorAll("." + OVERFLOW_ITEM_CLASS);
+  },
+
+  getXULNodeForItem: function getXULNodeForItem(item) {
+    return this.menuMap.get(item);
+  },
+
+  // Recurses through the item hierarchy creating XUL nodes for everything
+  populate: function populate(menu) {
+    for (let i = 0; i < internal(menu).children.length; i++) {
+      let item = internal(menu).children[i];
+      let after = i === 0 ? null : internal(menu).children[i - 1];
+      this.createItem(item, after);
+
+      if (item instanceof Menu)
+        this.populate(item);
+    }
+  },
+
+  // Recurses through the menu setting the visibility of items. Returns true
+  // if any of the items in this menu were visible
+  setVisibility: function setVisibility(menu, addonInfo, usePageWorker) {
+    let anyVisible = false;
+
+    for (let item of internal(menu).children) {
+      let visible = isItemVisible(item, addonInfo[internal(item).id], usePageWorker);
+
+      // Recurse through Menus, if none of the sub-items were visible then the
+      // menu is hidden too.
+      if (visible && (item instanceof Menu))
+        visible = this.setVisibility(item, addonInfo, false);
+
+      let xulNode = this.getXULNodeForItem(item);
+      xulNode.hidden = !visible;
+
+      anyVisible = anyVisible || visible;
+    }
+
+    return anyVisible;
+  },
+
+  // Works out where to insert a XUL node for an item in a browser window
+  insertIntoXUL: function insertIntoXUL(item, node, after) {
+    let menupopup = null;
+    let before = null;
+
+    let menu = item.parentMenu;
+    if (menu === this.items) {
+      // Insert into the overflow popup if it exists, otherwise the normal
+      // context menu
+      menupopup = this.overflowPopup;
+      if (!menupopup)
+        menupopup = this.contextMenu;
+    }
+    else {
+      let xulNode = this.getXULNodeForItem(menu);
+      menupopup = xulNode.firstChild;
+    }
+
+    if (after) {
+      let afterNode = this.getXULNodeForItem(after);
+      before = afterNode.nextSibling;
+    }
+    else if (menupopup === this.contextMenu) {
+      let topLevel = this.topLevelItems;
+      if (topLevel.length > 0)
+        before = topLevel[topLevel.length - 1].nextSibling;
+      else
+        before = this.separator.nextSibling;
+    }
+
+    menupopup.insertBefore(node, before);
+  },
+
+  // Sets the right class for XUL nodes
+  updateXULClass: function updateXULClass(xulNode) {
+    if (xulNode.parentNode == this.contextMenu)
+      xulNode.classList.add(TOPLEVEL_ITEM_CLASS);
+    else
+      xulNode.classList.remove(TOPLEVEL_ITEM_CLASS);
+
+    if (xulNode.parentNode == this.overflowPopup)
+      xulNode.classList.add(OVERFLOW_ITEM_CLASS);
+    else
+      xulNode.classList.remove(OVERFLOW_ITEM_CLASS);
+  },
+
+  // Creates a XUL node for an item
+  createItem: function createItem(item, after) {
+    if (!this.populated)
+      return;
+
+    // Create the separator if it doesn't already exist
+    if (!this.separator) {
+      let separator = this.window.document.createElement("menuseparator");
+      separator.setAttribute("class", SEPARATOR_CLASS);
+
+      // Insert before the separator created by the old context-menu if it
+      // exists to avoid bug 832401
+      let oldSeparator = this.window.document.getElementById("jetpack-context-menu-separator");
+      if (oldSeparator && oldSeparator.parentNode != this.contextMenu)
+        oldSeparator = null;
+      this.contextMenu.insertBefore(separator, oldSeparator);
+    }
+
+    let type = "menuitem";
+    if (item instanceof Menu)
+      type = "menu";
+    else if (item instanceof Separator)
+      type = "menuseparator";
+
+    let xulNode = this.window.document.createElement(type);
+    xulNode.setAttribute("class", ITEM_CLASS);
+    if (item instanceof LabelledItem) {
+      xulNode.setAttribute("label", item.label);
+      if (item.accesskey)
+        xulNode.setAttribute("accesskey", item.accesskey);
+      if (item.image) {
+        xulNode.setAttribute("image", item.image);
+        if (item instanceof Menu)
+          xulNode.classList.add("menu-iconic");
+        else
+          xulNode.classList.add("menuitem-iconic");
+      }
+      if (item.data)
+        xulNode.setAttribute("value", item.data);
+
+      let self = this;
+      xulNode.addEventListener("command", function(event) {
+        // Only care about clicks directly on this item
+        if (event.target !== xulNode)
+          return;
+
+        itemActivated(item, xulNode);
+      }, false);
+    }
+
+    this.insertIntoXUL(item, xulNode, after);
+    this.updateXULClass(xulNode);
+    xulNode.data = item.data;
+
+    if (item instanceof Menu) {
+      let menupopup = this.window.document.createElement("menupopup");
+      xulNode.appendChild(menupopup);
+    }
+
+    this.menuMap.set(item, xulNode);
+  },
+
+  // Updates the XUL node for an item in this window
+  updateItem: function updateItem(item) {
+    if (!this.populated)
+      return;
+
+    let xulNode = this.getXULNodeForItem(item);
+
+    // TODO figure out why this requires setAttribute
+    xulNode.setAttribute("label", item.label);
+    xulNode.setAttribute("accesskey", item.accesskey || "");
+
+    if (item.image) {
+      xulNode.setAttribute("image", item.image);
+      if (item instanceof Menu)
+        xulNode.classList.add("menu-iconic");
+      else
+        xulNode.classList.add("menuitem-iconic");
+    }
+    else {
+      xulNode.removeAttribute("image");
+      xulNode.classList.remove("menu-iconic");
+      xulNode.classList.remove("menuitem-iconic");
+    }
+
+    if (item.data)
+      xulNode.setAttribute("value", item.data);
+    else
+      xulNode.removeAttribute("value");
+  },
+
+  // Moves the XUL node for an item in this window to its new place in the
+  // hierarchy
+  moveItem: function moveItem(item, after) {
+    if (!this.populated)
+      return;
+
+    let xulNode = this.getXULNodeForItem(item);
+    let oldParent = xulNode.parentNode;
+
+    this.insertIntoXUL(item, xulNode, after);
+    this.updateXULClass(xulNode);
+    this.onXULRemoved(oldParent);
+  },
+
+  // Removes the XUL nodes for an item in every window we've ever populated.
+  removeItem: function removeItem(item) {
+    if (!this.populated)
+      return;
+
+    let xulItem = this.getXULNodeForItem(item);
+
+    let oldParent = xulItem.parentNode;
+
+    oldParent.removeChild(xulItem);
+    this.menuMap.delete(item);
+
+    this.onXULRemoved(oldParent);
+  },
+
+  // Called when any XUL nodes have been removed from a menupopup. This handles
+  // making sure the separator and overflow are correct
+  onXULRemoved: function onXULRemoved(parent) {
+    if (parent == this.contextMenu) {
+      let toplevel = this.topLevelItems;
+
+      // If there are no more items then remove the separator
+      if (toplevel.length == 0) {
+        let separator = this.separator;
+        if (separator)
+          separator.parentNode.removeChild(separator);
+      }
+    }
+    else if (parent == this.overflowPopup) {
+      // If there are no more items then remove the overflow menu and separator
+      if (parent.childNodes.length == 0) {
+        let separator = this.separator;
+        separator.parentNode.removeChild(separator);
+        this.contextMenu.removeChild(parent.parentNode);
+      }
+    }
+  },
+
+  // Recurses through all the items owned by this module and sets their hidden
+  // state
+  updateItemVisibilities: function updateItemVisibilities(event) {
+    try {
+      if (event.type != "popupshowing")
+        return;
+      if (event.target != this.contextMenu)
+        return;
+
+      if (internal(this.items).children.length == 0)
+        return;
+
+      if (!this.populated) {
+        this.populated = true;
+        this.populate(this.items);
+      }
+
+      let mainWindow = event.target.ownerDocument.defaultView;
+      this.contextMenuContentData = mainWindow.gContextMenuContentData
+      if (!(self.id in this.contextMenuContentData.addonInfo)) {
+        console.warn("No context menu state data was provided.");
+        return;
+      }
+      let addonInfo = this.contextMenuContentData.addonInfo[self.id];
+      lastContextProcessId = addonInfo.processID;
+      this.setVisibility(this.items, addonInfo.items, true);
+    }
+    catch (e) {
+      console.exception(e);
+    }
+  },
+
+  // Counts the number of visible items across all modules and makes sure they
+  // are in the right place between the top level context menu and the overflow
+  // menu
+  updateOverflowState: function updateOverflowState(event) {
+    try {
+      if (event.type != "popupshowing")
+        return;
+      if (event.target != this.contextMenu)
+        return;
+
+      // The main items will be in either the top level context menu or the
+      // overflow menu at this point. Count the visible ones and if they are in
+      // the wrong place move them
+      let toplevel = this.topLevelItems;
+      let overflow = this.overflowItems;
+      let visibleCount = countVisibleItems(toplevel) +
+                         countVisibleItems(overflow);
+
+      if (visibleCount == 0) {
+        let separator = this.separator;
+        if (separator)
+          separator.hidden = true;
+        let overflowMenu = this.overflowMenu;
+        if (overflowMenu)
+          overflowMenu.hidden = true;
+      }
+      else if (visibleCount > MenuManager.overflowThreshold) {
+        this.separator.hidden = false;
+        let overflowPopup = this.overflowPopup;
+        if (overflowPopup)
+          overflowPopup.parentNode.hidden = false;
+
+        if (toplevel.length > 0) {
+          // The overflow menu shouldn't exist here but let's play it safe
+          if (!overflowPopup) {
+            let overflowMenu = this.window.document.createElement("menu");
+            overflowMenu.setAttribute("class", OVERFLOW_MENU_CLASS);
+            overflowMenu.setAttribute("label", OVERFLOW_MENU_LABEL);
+            overflowMenu.setAttribute("accesskey", OVERFLOW_MENU_ACCESSKEY);
+            this.contextMenu.insertBefore(overflowMenu, this.separator.nextSibling);
+
+            overflowPopup = this.window.document.createElement("menupopup");
+            overflowPopup.setAttribute("class", OVERFLOW_POPUP_CLASS);
+            overflowMenu.appendChild(overflowPopup);
+          }
+
+          for (let xulNode of toplevel) {
+            overflowPopup.appendChild(xulNode);
+            this.updateXULClass(xulNode);
+          }
+        }
+      }
+      else {
+        this.separator.hidden = false;
+
+        if (overflow.length > 0) {
+          // Move all the overflow nodes out of the overflow menu and position
+          // them immediately before it
+          for (let xulNode of overflow) {
+            this.contextMenu.insertBefore(xulNode, xulNode.parentNode.parentNode);
+            this.updateXULClass(xulNode);
+          }
+          this.contextMenu.removeChild(this.overflowMenu);
+        }
+      }
+    }
+    catch (e) {
+      console.exception(e);
+    }
+  }
+});
+
+// This wraps every window that we've seen
+var WindowWrapper = Class({
+  initialize: function initialize(window) {
+    this.window = window;
+    this.menus = [
+      new MenuWrapper(this, contentContextMenu, window.document.getElementById("contentAreaContextMenu")),
+    ];
+  },
+
+  destroy: function destroy() {
+    for (let menuWrapper of this.menus)
+      menuWrapper.destroy();
+  },
+
+  getMenuWrapperForItem: function getMenuWrapperForItem(item) {
+    let root = item.parentMenu;
+    while (root.parentMenu)
+      root = root.parentMenu;
+
+    for (let wrapper of this.menus) {
+      if (wrapper.items === root)
+        return wrapper;
+    }
+
+    return null;
+  }
+});
+
+var MenuManager = {
+  windowMap: new Map(),
+
+  get overflowThreshold() {
+    let prefs = require("./preferences/service");
+    return prefs.get(OVERFLOW_THRESH_PREF, OVERFLOW_THRESH_DEFAULT);
+  },
+
+  // When a new window is added start watching it for context menu shows
+  onTrack: function onTrack(window) {
+    if (!isBrowser(window))
+      return;
+
+    // Generally shouldn't happen, but just in case
+    if (this.windowMap.has(window)) {
+      console.warn("Already seen this window");
+      return;
+    }
+
+    let winWrapper = WindowWrapper(window);
+    this.windowMap.set(window, winWrapper);
+  },
+
+  onUntrack: function onUntrack(window) {
+    if (!isBrowser(window))
+      return;
+
+    let winWrapper = this.windowMap.get(window);
+    // This shouldn't happen but protect against it anyway
+    if (!winWrapper)
+      return;
+    winWrapper.destroy();
+
+    this.windowMap.delete(window);
+  },
+
+  // Creates a XUL node for an item in every window we've already populated
+  createItem: function createItem(item, after) {
+    for (let [window, winWrapper] of this.windowMap) {
+      let menuWrapper = winWrapper.getMenuWrapperForItem(item);
+      if (menuWrapper)
+        menuWrapper.createItem(item, after);
+    }
+  },
+
+  // Updates the XUL node for an item in every window we've already populated
+  updateItem: function updateItem(item) {
+    for (let [window, winWrapper] of this.windowMap) {
+      let menuWrapper = winWrapper.getMenuWrapperForItem(item);
+      if (menuWrapper)
+        menuWrapper.updateItem(item);
+    }
+  },
+
+  // Moves the XUL node for an item in every window we've ever populated to its
+  // new place in the hierarchy
+  moveItem: function moveItem(item, after) {
+    for (let [window, winWrapper] of this.windowMap) {
+      let menuWrapper = winWrapper.getMenuWrapperForItem(item);
+      if (menuWrapper)
+        menuWrapper.moveItem(item, after);
+    }
+  },
+
+  // Removes the XUL nodes for an item in every window we've ever populated.
+  removeItem: function removeItem(item) {
+    for (let [window, winWrapper] of this.windowMap) {
+      let menuWrapper = winWrapper.getMenuWrapperForItem(item);
+      if (menuWrapper)
+        menuWrapper.removeItem(item);
+    }
+  }
+};
+
+WindowTracker(MenuManager);
diff --git a/toolkit/jetpack/sdk/context-menu/context.js b/toolkit/jetpack/sdk/context-menu/context.js
new file mode 100644
index 000000000..fc5aea500
--- /dev/null
+++ b/toolkit/jetpack/sdk/context-menu/context.js
@@ -0,0 +1,147 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { Class } = require("../core/heritage");
+const { extend } = require("../util/object");
+const { MatchPattern } = require("../util/match-pattern");
+const readers = require("./readers");
+
+// Context class is required to implement a single `isCurrent(target)` method
+// that must return boolean value indicating weather given target matches a
+// context or not. Most context implementations below will have an associated
+// reader that way context implementation can setup a reader to extract necessary
+// information to make decision if target is matching a context.
+const Context = Class({
+  isRequired: false,
+  isCurrent(target) {
+    throw Error("Context class must implement isCurrent(target) method");
+  },
+  get required() {
+    Object.defineProperty(this, "required", {
+      value: Object.assign(Object.create(Object.getPrototypeOf(this)),
+                           this,
+                           {isRequired: true})
+    });
+    return this.required;
+  }
+});
+Context.required = function(...params) {
+  return Object.assign(new this(...params), {isRequired: true});
+};
+exports.Context = Context;
+
+
+// Next few context implementations use an associated reader to extract info
+// from the context target and story it to a private symbol associtaed with
+// a context implementation. That way name collisions are avoided while required
+// information is still carried along.
+const isPage = Symbol("context/page?")
+const PageContext = Class({
+  extends: Context,
+  read: {[isPage]: new readers.isPage()},
+  isCurrent: target => target[isPage]
+});
+exports.Page = PageContext;
+
+const isFrame = Symbol("context/frame?");
+const FrameContext = Class({
+  extends: Context,
+  read: {[isFrame]: new readers.isFrame()},
+  isCurrent: target => target[isFrame]
+});
+exports.Frame = FrameContext;
+
+const selection = Symbol("context/selection")
+const SelectionContext = Class({
+  read: {[selection]: new readers.Selection()},
+  isCurrent: target => !!target[selection]
+});
+exports.Selection = SelectionContext;
+
+const link = Symbol("context/link");
+const LinkContext = Class({
+  extends: Context,
+  read: {[link]: new readers.LinkURL()},
+  isCurrent: target => !!target[link]
+});
+exports.Link = LinkContext;
+
+const isEditable = Symbol("context/editable?")
+const EditableContext = Class({
+  extends: Context,
+  read: {[isEditable]: new readers.isEditable()},
+  isCurrent: target => target[isEditable]
+});
+exports.Editable = EditableContext;
+
+
+const mediaType = Symbol("context/mediaType")
+
+const ImageContext = Class({
+  extends: Context,
+  read: {[mediaType]: new readers.MediaType()},
+  isCurrent: target => target[mediaType] === "image"
+});
+exports.Image = ImageContext;
+
+
+const VideoContext = Class({
+  extends: Context,
+  read: {[mediaType]: new readers.MediaType()},
+  isCurrent: target => target[mediaType] === "video"
+});
+exports.Video = VideoContext;
+
+
+const AudioContext = Class({
+  extends: Context,
+  read: {[mediaType]: new readers.MediaType()},
+  isCurrent: target => target[mediaType] === "audio"
+});
+exports.Audio = AudioContext;
+
+const isSelectorMatch = Symbol("context/selector/mathches?")
+const SelectorContext = Class({
+  extends: Context,
+  initialize(selector) {
+    this.selector = selector;
+    // Each instance of selector context will need to store read
+    // data into different field, so that case with multilpe selector
+    // contexts won't cause a conflicts.
+    this[isSelectorMatch] = Symbol(selector);
+    this.read = {[this[isSelectorMatch]]: new readers.SelectorMatch(selector)};
+  },
+  isCurrent(target) {
+    return target[this[isSelectorMatch]];
+  }
+});
+exports.Selector = SelectorContext;
+
+const url = Symbol("context/url");
+const URLContext = Class({
+  extends: Context,
+  initialize(pattern) {
+    this.pattern = new MatchPattern(pattern);
+  },
+  read: {[url]: new readers.PageURL()},
+  isCurrent(target) {
+    return this.pattern.test(target[url]);
+  }
+});
+exports.URL = URLContext;
+
+var PredicateContext = Class({
+  extends: Context,
+  initialize(isMatch) {
+    if (typeof(isMatch) !== "function") {
+      throw TypeError("Predicate context mus be passed a function");
+    }
+
+    this.isMatch = isMatch
+  },
+  isCurrent(target) {
+    return this.isMatch(target);
+  }
+});
+exports.Predicate = PredicateContext;
diff --git a/toolkit/jetpack/sdk/context-menu/core.js b/toolkit/jetpack/sdk/context-menu/core.js
new file mode 100644
index 000000000..c64cddfe8
--- /dev/null
+++ b/toolkit/jetpack/sdk/context-menu/core.js
@@ -0,0 +1,384 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const Contexts = require("./context");
+const Readers = require("./readers");
+const Component = require("../ui/component");
+const { Class } = require("../core/heritage");
+const { map, filter, object, reduce, keys, symbols,
+        pairs, values, each, some, isEvery, count } = require("../util/sequence");
+const { loadModule } = require("framescript/manager");
+const { Cu, Cc, Ci } = require("chrome");
+const prefs = require("sdk/preferences/service");
+
+const globalMessageManager = Cc["@mozilla.org/globalmessagemanager;1"]
+                              .getService(Ci.nsIMessageListenerManager);
+const preferencesService = Cc["@mozilla.org/preferences-service;1"].
+                            getService(Ci.nsIPrefService).
+                            getBranch(null);
+
+
+const readTable = Symbol("context-menu/read-table");
+const nameTable = Symbol("context-menu/name-table");
+const onContext = Symbol("context-menu/on-context");
+const isMatching = Symbol("context-menu/matching-handler?");
+
+exports.onContext = onContext;
+exports.readTable = readTable;
+exports.nameTable = nameTable;
+
+
+const propagateOnContext = (item, data) =>
+  each(child => child[onContext](data), item.state.children);
+
+const isContextMatch = item => !item[isMatching] || item[isMatching]();
+
+// For whatever reason addWeakMessageListener does not seems to work as our
+// instance seems to dropped even though it's alive. This is simple workaround
+// to avoid dead object excetptions.
+const WeakMessageListener = function(receiver, handler="receiveMessage") {
+  this.receiver = receiver
+  this.handler = handler
+};
+WeakMessageListener.prototype = {
+  constructor: WeakMessageListener,
+  receiveMessage(message) {
+    if (Cu.isDeadWrapper(this.receiver)) {
+      message.target.messageManager.removeMessageListener(message.name, this);
+    }
+    else {
+      this.receiver[this.handler](message);
+    }
+  }
+};
+
+const OVERFLOW_THRESH = "extensions.addon-sdk.context-menu.overflowThreshold";
+const onMessage = Symbol("context-menu/message-listener");
+const onPreferceChange = Symbol("context-menu/preference-change");
+const ContextMenuExtension = Class({
+  extends: Component,
+  initialize: Component,
+  setup() {
+    const messageListener = new WeakMessageListener(this, onMessage);
+    loadModule(globalMessageManager, "framescript/context-menu", true, "onContentFrame");
+    globalMessageManager.addMessageListener("sdk/context-menu/read", messageListener);
+    globalMessageManager.addMessageListener("sdk/context-menu/readers?", messageListener);
+
+    preferencesService.addObserver(OVERFLOW_THRESH, this, false);
+  },
+  observe(_, __, name) {
+    if (name === OVERFLOW_THRESH) {
+      const overflowThreshold = prefs.get(OVERFLOW_THRESH, 10);
+      this[Component.patch]({overflowThreshold});
+    }
+  },
+  [onMessage]({name, data, target}) {
+    if (name === "sdk/context-menu/read")
+      this[onContext]({target, data});
+    if (name === "sdk/context-menu/readers?")
+      target.messageManager.sendAsyncMessage("sdk/context-menu/readers",
+                                             JSON.parse(JSON.stringify(this.state.readers)));
+  },
+  [Component.initial](options={}, children) {
+    const element = options.element || null;
+    const target = options.target || null;
+    const readers = Object.create(null);
+    const users = Object.create(null);
+    const registry = new WeakSet();
+    const overflowThreshold = prefs.get(OVERFLOW_THRESH, 10);
+
+    return { target, children: [], readers, users, element,
+             registry, overflowThreshold };
+  },
+  [Component.isUpdated](before, after) {
+    // Update only if target changed, since there is no point in re-rendering
+    // when children are. Also new items added won't be in sync with a latest
+    // context target so we should really just render before drawing context
+    // menu.
+    return before.target !== after.target;
+  },
+  [Component.render]({element, children, overflowThreshold}) {
+    if (!element) return null;
+
+    const items = children.filter(isContextMatch);
+    const body = items.length === 0 ? items :
+                 items.length < overflowThreshold ? [new Separator(),
+                                                     ...items] :
+                 [{tagName: "menu",
+                   className: "sdk-context-menu-overflow-menu",
+                   label: "Add-ons",
+                   accesskey: "A",
+                   children: [{tagName: "menupopup",
+                               children: items}]}];
+    return {
+      element: element,
+      tagName: "menugroup",
+      style: "-moz-box-orient: vertical;",
+      className: "sdk-context-menu-extension",
+      children: body
+    }
+  },
+  // Adds / remove child to it's own list.
+  add(item) {
+    this[Component.patch]({children: this.state.children.concat(item)});
+  },
+  remove(item) {
+    this[Component.patch]({
+      children: this.state.children.filter(x => x !== item)
+    });
+  },
+  register(item) {
+    const { users, registry } = this.state;
+    if (registry.has(item)) return;
+    registry.add(item);
+
+    // Each (ContextHandler) item has a readTable that is a
+    // map of keys to readers extracting them from the content.
+    // During the registraction we update intrnal record of unique
+    // readers and users per reader. Most context will have a reader
+    // shared across all instances there for map of users per reader
+    // is stored separately from the reader so that removing reader
+    // will occur only when no users remain.
+    const table = item[readTable];
+    // Context readers store data in private symbols so we need to
+    // collect both table keys and private symbols.
+    const names = [...keys(table), ...symbols(table)];
+    const readers = map(name => table[name], names);
+    // Create delta for registered readers that will be merged into
+    // internal readers table.
+    const added = filter(x => !users[x.id], readers);
+    const delta = object(...map(x => [x.id, x], added));
+
+    const update = reduce((update, reader) => {
+      const n = update[reader.id] || 0;
+      update[reader.id] = n + 1;
+      return update;
+    }, Object.assign({}, users), readers);
+
+    // Patch current state with a changes that registered item caused.
+    this[Component.patch]({users: update,
+                           readers: Object.assign(this.state.readers, delta)});
+
+    if (count(added)) {
+      globalMessageManager.broadcastAsyncMessage("sdk/context-menu/readers",
+                                                 JSON.parse(JSON.stringify(delta)));
+    }
+  },
+  unregister(item) {
+    const { users, registry } = this.state;
+    if (!registry.has(item)) return;
+    registry.delete(item);
+
+    const table = item[readTable];
+    const names = [...keys(table), ...symbols(table)];
+    const readers = map(name => table[name], names);
+    const update = reduce((update, reader) => {
+      update[reader.id] = update[reader.id] - 1;
+      return update;
+    }, Object.assign({}, users), readers);
+    const removed = filter(id => !update[id], keys(update));
+    const delta = object(...map(x => [x, null], removed));
+
+    this[Component.patch]({users: update,
+                           readers: Object.assign(this.state.readers, delta)});
+
+    if (count(removed)) {
+      globalMessageManager.broadcastAsyncMessage("sdk/context-menu/readers",
+                                                 JSON.parse(JSON.stringify(delta)));
+    }
+  },
+
+  [onContext]({data, target}) {
+    propagateOnContext(this, data);
+    const document = target.ownerDocument;
+    const element = document.getElementById("contentAreaContextMenu");
+
+    this[Component.patch]({target: data, element: element});
+  }
+});this,
+exports.ContextMenuExtension = ContextMenuExtension;
+
+// Takes an item options and
+const makeReadTable = ({context, read}) => {
+  // Result of this function is a tuple of all readers &
+  // name, reader id pairs.
+
+  // Filter down to contexts that have a reader associated.
+  const contexts = filter(context => context.read, context);
+  // Merge all contexts read maps to a single hash, note that there should be
+  // no name collisions as context implementations expect to use private
+  // symbols for storing it's read data.
+  return Object.assign({}, ...map(({read}) => read, contexts), read);
+}
+
+const readTarget = (nameTable, data) =>
+  object(...map(([name, id]) => [name, data[id]], nameTable))
+
+const ContextHandler = Class({
+  extends: Component,
+  initialize: Component,
+  get context() {
+    return this.state.options.context;
+  },
+  get read() {
+    return this.state.options.read;
+  },
+  [Component.initial](options) {
+    return {
+      table: makeReadTable(options),
+      requiredContext: filter(context => context.isRequired, options.context),
+      optionalContext: filter(context => !context.isRequired, options.context)
+    }
+  },
+  [isMatching]() {
+    const {target, requiredContext, optionalContext} = this.state;
+    return isEvery(context => context.isCurrent(target), requiredContext) &&
+            (count(optionalContext) === 0 ||
+             some(context => context.isCurrent(target), optionalContext));
+  },
+  setup() {
+    const table = makeReadTable(this.state.options);
+    this[readTable] = table;
+    this[nameTable] = [...map(symbol => [symbol, table[symbol].id], symbols(table)),
+                       ...map(name => [name, table[name].id], keys(table))];
+
+
+    contextMenu.register(this);
+
+    each(child => contextMenu.remove(child), this.state.children);
+    contextMenu.add(this);
+  },
+  dispose() {
+    contextMenu.remove(this);
+
+    each(child => contextMenu.unregister(child), this.state.children);
+    contextMenu.unregister(this);
+  },
+  // Internal `Symbol("onContext")` method is invoked when "contextmenu" event
+  // occurs in content process. Context handles with children delegate to each
+  // child and patch it's internal state to reflect new contextmenu target.
+  [onContext](data) {
+    propagateOnContext(this, data);
+    this[Component.patch]({target: readTarget(this[nameTable], data)});
+  }
+});
+const isContextHandler = item => item instanceof ContextHandler;
+
+exports.ContextHandler = ContextHandler;
+
+const Menu = Class({
+  extends: ContextHandler,
+  [isMatching]() {
+    return ContextHandler.prototype[isMatching].call(this) &&
+           this.state.children.filter(isContextHandler)
+                              .some(isContextMatch);
+  },
+  [Component.render]({children, options}) {
+    const items = children.filter(isContextMatch);
+    return {tagName: "menu",
+            className: "sdk-context-menu menu-iconic",
+            label: options.label,
+            accesskey: options.accesskey,
+            image: options.icon,
+            children: [{tagName: "menupopup",
+                        children: items}]};
+  }
+});
+exports.Menu = Menu;
+
+const onCommand = Symbol("context-menu/item/onCommand");
+const Item = Class({
+  extends: ContextHandler,
+  get onClick() {
+    return this.state.options.onClick;
+  },
+  [Component.render]({options}) {
+    const {label, icon, accesskey} = options;
+    return {tagName: "menuitem",
+            className: "sdk-context-menu-item menuitem-iconic",
+            label,
+            accesskey,
+            image: icon,
+            oncommand: this};
+  },
+  handleEvent(event) {
+    if (this.onClick)
+      this.onClick(this.state.target);
+  }
+});
+exports.Item = Item;
+
+var Separator = Class({
+  extends: Component,
+  initialize: Component,
+  [Component.render]() {
+    return {tagName: "menuseparator",
+            className: "sdk-context-menu-separator"}
+  },
+  [onContext]() {
+
+  }
+});
+exports.Separator = Separator;
+
+exports.Contexts = Contexts;
+exports.Readers = Readers;
+
+const createElement = (vnode, {document}) => {
+   const node = vnode.namespace ?
+              document.createElementNS(vnode.namespace, vnode.tagName) :
+              document.createElement(vnode.tagName);
+
+   node.setAttribute("data-component-path", vnode[Component.path]);
+
+   each(([key, value]) => {
+     if (key === "tagName") {
+       return;
+     }
+     if (key === "children") {
+       return;
+     }
+
+     if (key.startsWith("on")) {
+       node.addEventListener(key.substr(2), value)
+       return;
+     }
+
+     if (typeof(value) !== "object" &&
+         typeof(value) !== "function" &&
+         value !== void(0) &&
+         value !== null)
+    {
+       if (key === "className") {
+         node[key] = value;
+       }
+       else {
+         node.setAttribute(key, value);
+       }
+       return;
+     }
+   }, pairs(vnode));
+
+  each(child => node.appendChild(createElement(child, {document})), vnode.children);
+  return node;
+};
+
+const htmlWriter = tree => {
+  if (tree !== null) {
+    const root = tree.element;
+    const node = createElement(tree, {document: root.ownerDocument});
+    const before = root.querySelector("[data-component-path='/']");
+    if (before) {
+      root.replaceChild(node, before);
+    } else {
+      root.appendChild(node);
+    }
+  }
+};
+
+
+const contextMenu = ContextMenuExtension();
+exports.contextMenu = contextMenu;
+Component.mount(contextMenu, htmlWriter);
diff --git a/toolkit/jetpack/sdk/context-menu/readers.js b/toolkit/jetpack/sdk/context-menu/readers.js
new file mode 100644
index 000000000..5078f8f29
--- /dev/null
+++ b/toolkit/jetpack/sdk/context-menu/readers.js
@@ -0,0 +1,112 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+const { Class } = require("../core/heritage");
+const { extend } = require("../util/object");
+const { memoize, method, identity } = require("../lang/functional");
+
+const serializeCategory = ({type}) => ({ category: `reader/${type}()` });
+
+const Reader = Class({
+  initialize() {
+    this.id = `reader/${this.type}()`
+  },
+  toJSON() {
+    return serializeCategory(this);
+  }
+});
+
+
+const MediaTypeReader = Class({ extends: Reader, type: "MediaType" });
+exports.MediaType = MediaTypeReader;
+
+const LinkURLReader = Class({ extends: Reader, type: "LinkURL" });
+exports.LinkURL = LinkURLReader;
+
+const SelectionReader = Class({ extends: Reader, type: "Selection" });
+exports.Selection = SelectionReader;
+
+const isPageReader = Class({ extends: Reader, type: "isPage" });
+exports.isPage = isPageReader;
+
+const isFrameReader = Class({ extends: Reader, type: "isFrame" });
+exports.isFrame = isFrameReader;
+
+const isEditable = Class({ extends: Reader, type: "isEditable"});
+exports.isEditable = isEditable;
+
+
+
+const ParameterizedReader = Class({
+  extends: Reader,
+  readParameter: function(value) {
+    return value;
+  },
+  toJSON: function() {
+    var json = serializeCategory(this);
+    json[this.parameter] = this[this.parameter];
+    return json;
+  },
+  initialize(...params) {
+    if (params.length) {
+      this[this.parameter] = this.readParameter(...params);
+    }
+    this.id = `reader/${this.type}(${JSON.stringify(this[this.parameter])})`;
+  }
+});
+exports.ParameterizedReader = ParameterizedReader;
+
+
+const QueryReader = Class({
+  extends: ParameterizedReader,
+  type: "Query",
+  parameter: "path"
+});
+exports.Query = QueryReader;
+
+
+const AttributeReader = Class({
+  extends: ParameterizedReader,
+  type: "Attribute",
+  parameter: "name"
+});
+exports.Attribute = AttributeReader;
+
+const SrcURLReader = Class({
+  extends: AttributeReader,
+  name: "src",
+});
+exports.SrcURL = SrcURLReader;
+
+const PageURLReader = Class({
+  extends: QueryReader,
+  path: "ownerDocument.URL",
+});
+exports.PageURL = PageURLReader;
+
+const SelectorMatchReader = Class({
+  extends: ParameterizedReader,
+  type: "SelectorMatch",
+  parameter: "selector"
+});
+exports.SelectorMatch = SelectorMatchReader;
+
+const extractors = new WeakMap();
+extractors.id = 0;
+
+
+var Extractor = Class({
+  extends: ParameterizedReader,
+  type: "Extractor",
+  parameter: "source",
+  initialize: function(f) {
+    this[this.parameter] = String(f);
+    if (!extractors.has(f)) {
+      extractors.id = extractors.id + 1;
+      extractors.set(f, extractors.id);
+    }
+
+    this.id = `reader/${this.type}.for(${extractors.get(f)})`
+  }
+});
+exports.Extractor = Extractor;
diff --git a/toolkit/jetpack/sdk/context-menu@2.js b/toolkit/jetpack/sdk/context-menu@2.js
new file mode 100644
index 000000000..45ad804e9
--- /dev/null
+++ b/toolkit/jetpack/sdk/context-menu@2.js
@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const shared = require("toolkit/require");
+const { Item, Separator, Menu, Contexts, Readers } = shared.require("sdk/context-menu/core");
+const { setupDisposable, disposeDisposable, Disposable } = require("sdk/core/disposable")
+const { Class } = require("sdk/core/heritage")
+
+const makeDisposable = Type => Class({
+  extends: Type,
+  implements: [Disposable],
+  initialize: Type.prototype.initialize,
+  setup(...params) {
+    Type.prototype.setup.call(this, ...params);
+    setupDisposable(this);
+  },
+  dispose(...params) {
+    disposeDisposable(this);
+    Type.prototype.dispose.call(this, ...params);
+  }
+});
+
+exports.Separator = Separator;
+exports.Contexts = Contexts;
+exports.Readers = Readers;
+
+// Subclass Item & Menu shared classes so their items
+// will be unloaded when add-on is unloaded.
+exports.Item = makeDisposable(Item);
+exports.Menu = makeDisposable(Menu);
diff --git a/toolkit/jetpack/sdk/core/disposable.js b/toolkit/jetpack/sdk/core/disposable.js
new file mode 100644
index 000000000..19f7eaa9f
--- /dev/null
+++ b/toolkit/jetpack/sdk/core/disposable.js
@@ -0,0 +1,186 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Class } = require("./heritage");
+const { Observer, subscribe, unsubscribe, observe } = require("./observer");
+const { isWeak } = require("./reference");
+const SDKWeakSet = require("../lang/weak-set");
+
+const method = require("../../method/core");
+
+const unloadSubject = require('@loader/unload');
+const addonUnloadTopic = "sdk:loader:destroy";
+
+const uninstall = method("disposable/uninstall");
+exports.uninstall = uninstall;
+
+const shutdown = method("disposable/shutdown");
+exports.shutdown = shutdown;
+
+const disable = method("disposable/disable");
+exports.disable = disable;
+
+const upgrade = method("disposable/upgrade");
+exports.upgrade = upgrade;
+
+const downgrade = method("disposable/downgrade");
+exports.downgrade = downgrade;
+
+const unload = method("disposable/unload");
+exports.unload = unload;
+
+const dispose = method("disposable/dispose");
+exports.dispose = dispose;
+dispose.define(Object, object => object.dispose());
+
+const setup = method("disposable/setup");
+exports.setup = setup;
+setup.define(Object, (object, ...args) => object.setup(...args));
+
+// DisposablesUnloadObserver is the class which subscribe the
+// Observer Service to be notified when the add-on loader is
+// unloading to be able to dispose all the existent disposables.
+const DisposablesUnloadObserver = Class({
+  implements: [Observer],
+  initialize: function(...args) {
+    // Set of the non-weak disposables registered to be disposed.
+    this.disposables = new Set();
+    // Target of the weak disposables registered to be disposed
+    // (and tracked on this target using the SDK weak-set module).
+    this.weakDisposables = {};
+  },
+  subscribe(disposable) {
+    if (isWeak(disposable)) {
+      SDKWeakSet.add(this.weakDisposables, disposable);
+    } else {
+      this.disposables.add(disposable);
+    }
+  },
+  unsubscribe(disposable) {
+    if (isWeak(disposable)) {
+      SDKWeakSet.remove(this.weakDisposables, disposable);
+    } else {
+      this.disposables.delete(disposable);
+    }
+  },
+  tryUnloadDisposable(disposable) {
+    try {
+      if (disposable) {
+        unload(disposable);
+      }
+    } catch(e) {
+      console.error("Error unloading a",
+                    isWeak(disposable) ? "weak disposable" : "disposable",
+                    disposable, e);
+    }
+  },
+  unloadAll() {
+    // Remove all the subscribed disposables.
+    for (let disposable of this.disposables) {
+      this.tryUnloadDisposable(disposable);
+    }
+
+    this.disposables.clear();
+
+    // Remove all the subscribed weak disposables.
+    for (let disposable of SDKWeakSet.iterator(this.weakDisposables)) {
+      this.tryUnloadDisposable(disposable);
+    }
+
+    SDKWeakSet.clear(this.weakDisposables);
+  }
+});
+const disposablesUnloadObserver = new DisposablesUnloadObserver();
+
+// The DisposablesUnloadObserver instance is the only object which subscribes
+// the Observer Service directly, it observes add-on unload notifications in
+// order to trigger `unload` on all its subscribed disposables.
+observe.define(DisposablesUnloadObserver, (obj, subject, topic, data) => {
+  const isUnloadTopic = topic === addonUnloadTopic;
+  const isUnloadSubject = subject.wrappedJSObject === unloadSubject;
+  if (isUnloadTopic && isUnloadSubject) {
+    unsubscribe(disposablesUnloadObserver, addonUnloadTopic);
+    disposablesUnloadObserver.unloadAll();
+  }
+});
+
+subscribe(disposablesUnloadObserver, addonUnloadTopic, false);
+
+// Set's up disposable instance.
+const setupDisposable = disposable => {
+  disposablesUnloadObserver.subscribe(disposable);
+};
+exports.setupDisposable = setupDisposable;
+
+// Tears down disposable instance.
+const disposeDisposable = disposable => {
+  disposablesUnloadObserver.unsubscribe(disposable);
+};
+exports.disposeDisposable = disposeDisposable;
+
+// Base type that takes care of disposing it's instances on add-on unload.
+// Also makes sure to remove unload listener if it's already being disposed.
+const Disposable = Class({
+  initialize: function(...args) {
+    // First setup instance before initializing it's disposal. If instance
+    // fails to initialize then there is no instance to be disposed at the
+    // unload.
+    setup(this, ...args);
+    setupDisposable(this);
+  },
+  destroy: function(reason) {
+    // Destroying disposable removes unload handler so that attempt to dispose
+    // won't be made at unload & delegates to dispose.
+    disposeDisposable(this);
+    unload(this, reason);
+  },
+  setup: function() {
+    // Implement your initialize logic here.
+  },
+  dispose: function() {
+    // Implement your cleanup logic here.
+  }
+});
+exports.Disposable = Disposable;
+
+const unloaders = {
+  destroy: dispose,
+  uninstall: uninstall,
+  shutdown: shutdown,
+  disable: disable,
+  upgrade: upgrade,
+  downgrade: downgrade
+};
+
+const unloaded = new WeakMap();
+unload.define(Disposable, (disposable, reason) => {
+  if (!unloaded.get(disposable)) {
+    unloaded.set(disposable, true);
+    // Pick an unload handler associated with an unload
+    // reason (falling back to destroy if not found) and
+    // delegate unloading to it.
+    const unload = unloaders[reason] || unloaders.destroy;
+    unload(disposable);
+  }
+});
+
+// If add-on is disabled manually, it's being upgraded, downgraded
+// or uninstalled `dispose` is invoked to undo any changes that
+// has being done by it in this session.
+disable.define(Disposable, dispose);
+downgrade.define(Disposable, dispose);
+upgrade.define(Disposable, dispose);
+uninstall.define(Disposable, dispose);
+
+// If application is shut down no dispose is invoked as undo-ing
+// changes made by instance is likely to just waste of resources &
+// increase shutdown time. Although specefic components may choose
+// to implement shutdown handler that does something better.
+shutdown.define(Disposable, disposable => {});
diff --git a/toolkit/jetpack/sdk/core/heritage.js b/toolkit/jetpack/sdk/core/heritage.js
new file mode 100644
index 000000000..fc87ba1f5
--- /dev/null
+++ b/toolkit/jetpack/sdk/core/heritage.js
@@ -0,0 +1,184 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+var getPrototypeOf = Object.getPrototypeOf;
+var getNames = x => [...Object.getOwnPropertyNames(x),
+                     ...Object.getOwnPropertySymbols(x)];
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var create = Object.create;
+var freeze = Object.freeze;
+var unbind = Function.call.bind(Function.bind, Function.call);
+
+// This shortcut makes sure that we do perform desired operations, even if
+// associated methods have being overridden on the used object.
+var owns = unbind(Object.prototype.hasOwnProperty);
+var apply = unbind(Function.prototype.apply);
+var slice = Array.slice || unbind(Array.prototype.slice);
+var reduce = Array.reduce || unbind(Array.prototype.reduce);
+var map = Array.map || unbind(Array.prototype.map);
+var concat = Array.concat || unbind(Array.prototype.concat);
+
+// Utility function to get own properties descriptor map.
+function getOwnPropertyDescriptors(object) {
+  return reduce(getNames(object), function(descriptor, name) {
+    descriptor[name] = getOwnPropertyDescriptor(object, name);
+    return descriptor;
+  }, {});
+}
+
+function isDataProperty(property) {
+  var value = property.value;
+  var type = typeof(property.value);
+  return "value" in property &&
+         (type !== "object" || value === null) &&
+         type !== "function";
+}
+
+function getDataProperties(object) {
+  var properties = getOwnPropertyDescriptors(object);
+  return getNames(properties).reduce(function(result, name) {
+    var property = properties[name];
+    if (isDataProperty(property)) {
+      result[name] = {
+        value: property.value,
+        writable: true,
+        configurable: true,
+        enumerable: false
+      };
+    }
+    return result;
+  }, {})
+}
+
+/**
+ * Takes `source` object as an argument and returns identical object
+ * with the difference that all own properties will be non-enumerable
+ */
+function obscure(source) {
+  var descriptor = reduce(getNames(source), function(descriptor, name) {
+    var property = getOwnPropertyDescriptor(source, name);
+    property.enumerable = false;
+    descriptor[name] = property;
+    return descriptor;
+  }, {});
+  return create(getPrototypeOf(source), descriptor);
+}
+exports.obscure = obscure;
+
+/**
+ * Takes arbitrary number of source objects and returns fresh one, that
+ * inherits from the same prototype as a first argument and implements all
+ * own properties of all argument objects. If two or more argument objects
+ * have own properties with the same name, the property is overridden, with
+ * precedence from right to left, implying, that properties of the object on
+ * the left are overridden by a same named property of the object on the right.
+ */
+var mix = function(source) {
+  var descriptor = reduce(slice(arguments), function(descriptor, source) {
+    return reduce(getNames(source), function(descriptor, name) {
+      descriptor[name] = getOwnPropertyDescriptor(source, name);
+      return descriptor;
+    }, descriptor);
+  }, {});
+
+  return create(getPrototypeOf(source), descriptor);
+};
+exports.mix = mix;
+
+/**
+ * Returns a frozen object with that inherits from the given `prototype` and
+ * implements all own properties of the given `properties` object.
+ */
+function extend(prototype, properties) {
+  return create(prototype, getOwnPropertyDescriptors(properties));
+}
+exports.extend = extend;
+
+/**
+ * Returns a constructor function with a proper `prototype` setup. Returned
+ * constructor's `prototype` inherits from a given `options.extends` or
+ * `Class.prototype` if omitted and implements all the properties of the
+ * given `option`. If `options.implemens` array is passed, it's elements
+ * will be mixed into prototype as well. Also, `options.extends` can be
+ * a function or a prototype. If function than it's prototype is used as
+ * an ancestor of the prototype, if it's an object that it's used directly.
+ * Also `options.implements` may contain functions or objects, in case of
+ * functions their prototypes are used for mixing.
+ */
+var Class = new function() {
+  function prototypeOf(input) {
+    return typeof(input) === 'function' ? input.prototype : input;
+  }
+  var none = freeze([]);
+
+  return function Class(options) {
+    // Create descriptor with normalized `options.extends` and
+    // `options.implements`.
+    var descriptor = {
+      // Normalize extends property of `options.extends` to a prototype object
+      // in case it's constructor. If property is missing that fallback to
+      // `Type.prototype`.
+      extends: owns(options, 'extends') ?
+               prototypeOf(options.extends) : Class.prototype,
+      // Normalize `options.implements` to make sure that it's array of
+      // prototype objects instead of constructor functions.
+      implements: owns(options, 'implements') ?
+                  freeze(map(options.implements, prototypeOf)) : none
+    };
+
+    // Create array of property descriptors who's properties will be defined
+    // on the resulting prototype. Note: Using reflection `concat` instead of
+    // method as it may be overridden.
+    var descriptors = concat(descriptor.implements, options, descriptor, {
+      constructor: constructor
+    });
+
+    // Note: we use reflection `apply` in the constructor instead of method
+    // call since later may be overridden.
+    function constructor() {
+      var instance = create(prototype, attributes);
+      if (initialize) apply(initialize, instance, arguments);
+      return instance;
+    }
+    // Create `prototype` that inherits from given ancestor passed as
+    // `options.extends`, falling back to `Type.prototype`, implementing all
+    // properties of given `options.implements` and `options` itself.
+    var prototype = extend(descriptor.extends, mix.apply(mix, descriptors));
+    var initialize = prototype.initialize;
+
+    // Combine ancestor attributes with prototype's attributes so that
+    // ancestors attributes also become initializeable.
+    var attributes = mix(descriptor.extends.constructor.attributes || {},
+                         getDataProperties(prototype));
+
+    constructor.attributes = attributes;
+    Object.defineProperty(constructor, 'prototype', {
+      configurable: false,
+      writable: false,
+      value: prototype
+    });
+    return constructor;
+  };
+}
+Class.prototype = extend(null, obscure({
+  constructor: function constructor() {
+    this.initialize.apply(this, arguments);
+    return this;
+  },
+  initialize: function initialize() {
+    // Do your initialization logic here
+  },
+  // Copy useful properties from `Object.prototype`.
+  toString: Object.prototype.toString,
+  toLocaleString: Object.prototype.toLocaleString,
+  toSource: Object.prototype.toSource,
+  valueOf: Object.prototype.valueOf,
+  isPrototypeOf: Object.prototype.isPrototypeOf
+}));
+exports.Class = freeze(Class);
diff --git a/toolkit/jetpack/sdk/core/namespace.js b/toolkit/jetpack/sdk/core/namespace.js
new file mode 100644
index 000000000..3ceb73b72
--- /dev/null
+++ b/toolkit/jetpack/sdk/core/namespace.js
@@ -0,0 +1,43 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const create = Object.create;
+const prototypeOf = Object.getPrototypeOf;
+
+/**
+ * Returns a new namespace, function that may can be used to access an
+ * namespaced object of the argument argument. Namespaced object are associated
+ * with owner objects via weak references. Namespaced objects inherit from the
+ * owners ancestor namespaced object. If owner's ancestor is `null` then
+ * namespaced object inherits from given `prototype`. Namespaces can be used
+ * to define internal APIs that can be shared via enclosing `namespace`
+ * function.
+ * @examples
+ *    const internals = ns();
+ *    internals(object).secret = secret;
+ */
+function ns() {
+  const map = new WeakMap();
+  return function namespace(target) {
+    if (!target)        // If `target` is not an object return `target` itself.
+      return target;
+    // If target has no namespaced object yet, create one that inherits from
+    // the target prototype's namespaced object.
+    if (!map.has(target))
+      map.set(target, create(namespace(prototypeOf(target) || null)));
+
+    return map.get(target);
+  };
+};
+
+// `Namespace` is a e4x function in the scope, so we export the function also as
+// `ns` as alias to avoid clashing.
+exports.ns = ns;
+exports.Namespace = ns;
diff --git a/toolkit/jetpack/sdk/core/observer.js b/toolkit/jetpack/sdk/core/observer.js
new file mode 100644
index 000000000..7e11bf8f9
--- /dev/null
+++ b/toolkit/jetpack/sdk/core/observer.js
@@ -0,0 +1,89 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+
+const { Cc, Ci, Cr, Cu } = require("chrome");
+const { Class } = require("./heritage");
+const { isWeak } = require("./reference");
+const method = require("../../method/core");
+
+const observerService = Cc['@mozilla.org/observer-service;1'].
+                          getService(Ci.nsIObserverService);
+
+const { ShimWaiver } = Cu.import("resource://gre/modules/ShimWaiver.jsm");
+const addObserver = ShimWaiver.getProperty(observerService, "addObserver");
+const removeObserver = ShimWaiver.getProperty(observerService, "removeObserver");
+
+// This is a method that will be invoked when notification observer
+// subscribed to occurs.
+const observe = method("observer/observe");
+exports.observe = observe;
+
+// Method to subscribe to the observer notification.
+const subscribe = method("observe/subscribe");
+exports.subscribe = subscribe;
+
+
+// Method to unsubscribe from the observer notifications.
+const unsubscribe = method("observer/unsubscribe");
+exports.unsubscribe = unsubscribe;
+
+
+// This is wrapper class that takes a `delegate` and produces
+// instance of `nsIObserver` which will delegate to a given
+// object when observer notification occurs.
+const ObserverDelegee = Class({
+  initialize: function(delegate) {
+    this.delegate = delegate;
+  },
+  QueryInterface: function(iid) {
+    if (!iid.equals(Ci.nsIObserver) &&
+        !iid.equals(Ci.nsISupportsWeakReference) &&
+        !iid.equals(Ci.nsISupports))
+      throw Cr.NS_ERROR_NO_INTERFACE;
+
+    return this;
+  },
+  observe: function(subject, topic, data) {
+    observe(this.delegate, subject, topic, data);
+  }
+});
+
+
+// Class that can be either mixed in or inherited from in
+// order to subscribe / unsubscribe for observer notifications.
+const Observer = Class({});
+exports.Observer = Observer;
+
+// Weak maps that associates instance of `ObserverDelegee` with
+// an actual observer. It ensures that `ObserverDelegee` instance
+// won't be GC-ed until given `observer` is.
+const subscribers = new WeakMap();
+
+// Implementation of `subscribe` for `Observer` type just registers
+// observer for an observer service. If `isWeak(observer)` is `true`
+// observer service won't hold strong reference to a given `observer`.
+subscribe.define(Observer, (observer, topic) => {
+  if (!subscribers.has(observer)) {
+    const delegee = new ObserverDelegee(observer);
+    subscribers.set(observer, delegee);
+    addObserver(delegee, topic, isWeak(observer));
+  }
+});
+
+// Unsubscribes `observer` from observer notifications for the
+// given `topic`.
+unsubscribe.define(Observer, (observer, topic) => {
+  const delegee = subscribers.get(observer);
+  if (delegee) {
+    subscribers.delete(observer);
+    removeObserver(delegee, topic);
+  }
+});
diff --git a/toolkit/jetpack/sdk/core/promise.js b/toolkit/jetpack/sdk/core/promise.js
new file mode 100644
index 000000000..f4bd7b0f5
--- /dev/null
+++ b/toolkit/jetpack/sdk/core/promise.js
@@ -0,0 +1,118 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+/*
+ * Uses `Promise.jsm` as a core implementation, with additional sugar
+ * from previous implementation, with inspiration from `Q` and `when`
+ *
+ * https://developer.mozilla.org/en-US/docs/Mozilla/JavaScript_code_modules/Promise.jsm
+ * https://github.com/cujojs/when
+ * https://github.com/kriskowal/q
+ */
+const PROMISE_URI = 'resource://gre/modules/Promise.jsm';
+
+getEnvironment.call(this, function ({ require, exports, module, Cu }) {
+
+const Promise = Cu.import(PROMISE_URI, {}).Promise;
+const { Debugging, defer, resolve, all, reject, race } = Promise;
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+var promised = (function() {
+  // Note: Define shortcuts and utility functions here in order to avoid
+  // slower property accesses and unnecessary closure creations on each
+  // call of this popular function.
+
+  var call = Function.call;
+  var concat = Array.prototype.concat;
+
+  // Utility function that does following:
+  // execute([ f, self, args...]) => f.apply(self, args)
+  function execute (args) {
+    return call.apply(call, args);
+  }
+
+  // Utility function that takes promise of `a` array and maybe promise `b`
+  // as arguments and returns promise for `a.concat(b)`.
+  function promisedConcat(promises, unknown) {
+    return promises.then(function (values) {
+      return resolve(unknown)
+        .then(value => values.concat([value]));
+    });
+  }
+
+  return function promised(f, prototype) {
+    /**
+    Returns a wrapped `f`, which when called returns a promise that resolves to
+    `f(...)` passing all the given arguments to it, which by the way may be
+    promises. Optionally second `prototype` argument may be provided to be used
+    a prototype for a returned promise.
+
+    ## Example
+
+    var promise = promised(Array)(1, promise(2), promise(3))
+    promise.then(console.log) // => [ 1, 2, 3 ]
+    **/
+
+    return function promised(...args) {
+      // create array of [ f, this, args... ]
+      return [f, this, ...args].
+        // reduce it via `promisedConcat` to get promised array of fulfillments
+        reduce(promisedConcat, resolve([], prototype)).
+        // finally map that to promise of `f.apply(this, args...)`
+        then(execute);
+    };
+  };
+})();
+
+exports.promised = promised;
+exports.all = all;
+exports.defer = defer;
+exports.resolve = resolve;
+exports.reject = reject;
+exports.race = race;
+exports.Promise = Promise;
+exports.Debugging = Debugging;
+});
+
+function getEnvironment (callback) {
+  let Cu, _exports, _module, _require;
+
+  // CommonJS / SDK
+  if (typeof(require) === 'function') {
+    Cu = require('chrome').Cu;
+    _exports = exports;
+    _module = module;
+    _require = require;
+  }
+  // JSM
+  else if (String(this).indexOf('BackstagePass') >= 0) {
+    Cu = this['Components'].utils;
+    _exports = this.Promise = {};
+    _module = { uri: __URI__, id: 'promise/core' };
+    _require = uri => {
+      let imports = {};
+      Cu.import(uri, imports);
+      return imports;
+    };
+    this.EXPORTED_SYMBOLS = ['Promise'];
+  // mozIJSSubScriptLoader.loadSubscript
+  } else if (~String(this).indexOf('Sandbox')) {
+    Cu = this['Components'].utils;
+    _exports = this;
+    _module = { id: 'promise/core' };
+    _require = uri => {};
+  }
+
+  callback({
+    Cu: Cu,
+    exports: _exports,
+    module: _module,
+    require: _require
+  });
+}
+
diff --git a/toolkit/jetpack/sdk/core/reference.js b/toolkit/jetpack/sdk/core/reference.js
new file mode 100644
index 000000000..04549cd0f
--- /dev/null
+++ b/toolkit/jetpack/sdk/core/reference.js
@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const method = require("../../method/core");
+const { Class } = require("./heritage");
+
+// Object that inherit or mix WeakRefence inn will register
+// weak observes for system notifications.
+const WeakReference = Class({});
+exports.WeakReference = WeakReference;
+
+
+// If `isWeak(object)` is `true` observer installed
+// for such `object` will be weak, meaning that it will
+// be GC-ed if nothing else but observer is observing it.
+// By default everything except `WeakReference` will return
+// `false`.
+const isWeak = method("reference/weak?");
+exports.isWeak = isWeak;
+
+isWeak.define(Object, _ => false);
+isWeak.define(WeakReference, _ => true);
diff --git a/toolkit/jetpack/sdk/deprecated/api-utils.js b/toolkit/jetpack/sdk/deprecated/api-utils.js
new file mode 100644
index 000000000..856fc50cb
--- /dev/null
+++ b/toolkit/jetpack/sdk/deprecated/api-utils.js
@@ -0,0 +1,197 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "deprecated"
+};
+
+const { merge } = require("../util/object");
+const { union } = require("../util/array");
+const { isNil, isRegExp } = require("../lang/type");
+
+// The possible return values of getTypeOf.
+const VALID_TYPES = [
+  "array",
+  "boolean",
+  "function",
+  "null",
+  "number",
+  "object",
+  "string",
+  "undefined",
+  "regexp"
+];
+
+const { isArray } = Array;
+
+/**
+ * Returns a validated options dictionary given some requirements.  If any of
+ * the requirements are not met, an exception is thrown.
+ *
+ * @param  options
+ *         An object, the options dictionary to validate.  It's not modified.
+ *         If it's null or otherwise falsey, an empty object is assumed.
+ * @param  requirements
+ *         An object whose keys are the expected keys in options.  Any key in
+ *         options that is not present in requirements is ignored.  Each value
+ *         in requirements is itself an object describing the requirements of
+ *         its key.  There are four optional keys in this object:
+ *           map: A function that's passed the value of the key in options.
+ *                map's return value is taken as the key's value in the final
+ *                validated options, is, and ok.  If map throws an exception
+ *                it's caught and discarded, and the key's value is its value in
+ *                options.
+ *           is:  An array containing any number of the typeof type names.  If
+ *                the key's value is none of these types, it fails validation.
+ *                Arrays, null and regexps are identified by the special type names
+ *                "array", "null", "regexp"; "object" will not match either.  No type
+ *                coercion is done.
+ *           ok:  A function that's passed the key's value.  If it returns
+ *                false, the value fails validation.
+ *           msg: If the key's value fails validation, an exception is thrown.
+ *                This string will be used as its message.  If undefined, a
+ *                generic message is used, unless is is defined, in which case
+ *                the message will state that the value needs to be one of the
+ *                given types.
+ * @return An object whose keys are those keys in requirements that are also in
+ *         options and whose values are the corresponding return values of map
+ *         or the corresponding values in options.  Note that any keys not
+ *         shared by both requirements and options are not in the returned
+ *         object.
+ */
+exports.validateOptions = function validateOptions(options, requirements) {
+  options = options || {};
+  let validatedOptions = {};
+
+  for (let key in requirements) {
+    let isOptional = false;
+    let mapThrew = false;
+    let req = requirements[key];
+    let [optsVal, keyInOpts] = (key in options) ?
+                               [options[key], true] :
+                               [undefined, false];
+    if (req.map) {
+      try {
+        optsVal = req.map(optsVal);
+      }
+      catch (err) {
+        if (err instanceof RequirementError)
+          throw err;
+
+        mapThrew = true;
+      }
+    }
+    if (req.is) {
+      let types = req.is;
+
+      if (!isArray(types) && isArray(types.is))
+        types = types.is;
+
+      if (isArray(types)) {
+        isOptional = ['undefined', 'null'].every(v => ~types.indexOf(v));
+
+        // Sanity check the caller's type names.
+        types.forEach(function (typ) {
+          if (VALID_TYPES.indexOf(typ) < 0) {
+            let msg = 'Internal error: invalid requirement type "' + typ + '".';
+            throw new Error(msg);
+          }
+        });
+        if (types.indexOf(getTypeOf(optsVal)) < 0)
+          throw new RequirementError(key, req);
+      }
+    }
+
+    if (req.ok && ((!isOptional || !isNil(optsVal)) && !req.ok(optsVal)))
+      throw new RequirementError(key, req);
+
+    if (keyInOpts || (req.map && !mapThrew && optsVal !== undefined))
+      validatedOptions[key] = optsVal;
+  }
+
+  return validatedOptions;
+};
+
+exports.addIterator = function addIterator(obj, keysValsGenerator) {
+  obj.__iterator__ = function(keysOnly, keysVals) {
+    let keysValsIterator = keysValsGenerator.call(this);
+
+    // "for (.. in ..)" gets only keys, "for each (.. in ..)" gets values,
+    // and "for (.. in Iterator(..))" gets [key, value] pairs.
+    let index = keysOnly ? 0 : 1;
+    while (true)
+      yield keysVals ? keysValsIterator.next() : keysValsIterator.next()[index];
+  };
+};
+
+// Similar to typeof, except arrays, null and regexps are identified by "array" and
+// "null" and "regexp", not "object".
+var getTypeOf = exports.getTypeOf = function getTypeOf(val) {
+  let typ = typeof(val);
+  if (typ === "object") {
+    if (!val)
+      return "null";
+    if (isArray(val))
+      return "array";
+    if (isRegExp(val))
+      return "regexp";
+  }
+  return typ;
+}
+
+function RequirementError(key, requirement) {
+  Error.call(this);
+
+  this.name = "RequirementError";
+
+  let msg = requirement.msg;
+  if (!msg) {
+    msg = 'The option "' + key + '" ';
+    msg += requirement.is ?
+           "must be one of the following types: " + requirement.is.join(", ") :
+           "is invalid.";
+  }
+
+  this.message = msg;
+}
+RequirementError.prototype = Object.create(Error.prototype);
+
+var string = { is: ['string', 'undefined', 'null'] };
+exports.string = string;
+
+var number = { is: ['number', 'undefined', 'null'] };
+exports.number = number;
+
+var boolean = { is: ['boolean', 'undefined', 'null'] };
+exports.boolean = boolean;
+
+var object = { is: ['object', 'undefined', 'null'] };
+exports.object = object;
+
+var array = { is: ['array', 'undefined', 'null'] };
+exports.array = array;
+
+var isTruthyType = type => !(type === 'undefined' || type === 'null');
+var findTypes = v => { while (!isArray(v) && v.is) v = v.is; return v };
+
+function required(req) {
+  let types = (findTypes(req) || VALID_TYPES).filter(isTruthyType);
+
+  return merge({}, req, {is: types});
+}
+exports.required = required;
+
+function optional(req) {
+  req = merge({is: []}, req);
+  req.is = findTypes(req).filter(isTruthyType).concat('undefined', 'null');
+
+  return req;
+}
+exports.optional = optional;
+
+function either(...types) {
+  return union.apply(null, types.map(findTypes));
+}
+exports.either = either;
diff --git a/toolkit/jetpack/sdk/deprecated/events/assembler.js b/toolkit/jetpack/sdk/deprecated/events/assembler.js
new file mode 100644
index 000000000..bb297c24f
--- /dev/null
+++ b/toolkit/jetpack/sdk/deprecated/events/assembler.js
@@ -0,0 +1,54 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Class } = require("../../core/heritage");
+const { removeListener, on } = require("../../dom/events");
+
+/**
+ * Event targets
+ * can be added / removed by calling `observe / ignore` methods. Composer should
+ * provide array of event types it wishes to handle as property
+ * `supportedEventsTypes` and function for handling all those events as
+ * `handleEvent` property.
+ */
+exports.DOMEventAssembler = Class({
+  /**
+   * Function that is supposed to handle all the supported events (that are
+   * present in the `supportedEventsTypes`) from all the observed
+   * `eventTargets`.
+   * @param {Event} event
+   *    Event being dispatched.
+   */
+  handleEvent() {
+    throw new TypeError("Instance of DOMEventAssembler must implement `handleEvent` method");
+  },
+  /**
+   * Array of supported event names.
+   * @type {String[]}
+   */
+  get supportedEventsTypes() {
+    throw new TypeError("Instance of DOMEventAssembler must implement `handleEvent` field");
+  },
+  /**
+   * Adds `eventTarget` to the list of observed `eventTarget`s. Listeners for
+   * supported events will be registered on the given `eventTarget`.
+   * @param {EventTarget} eventTarget
+   */
+  observe: function observe(eventTarget) {
+    this.supportedEventsTypes.forEach(function(eventType) {
+      on(eventTarget, eventType, this);
+    }, this);
+  },
+  /**
+   * Removes `eventTarget` from the list of observed `eventTarget`s. Listeners
+   * for all supported events will be unregistered from the given `eventTarget`.
+   * @param {EventTarget} eventTarget
+   */
+  ignore: function ignore(eventTarget) {
+    this.supportedEventsTypes.forEach(function(eventType) {
+      removeListener(eventTarget, eventType, this);
+    }, this);
+  }
+});
diff --git a/toolkit/jetpack/sdk/deprecated/sync-worker.js b/toolkit/jetpack/sdk/deprecated/sync-worker.js
new file mode 100644
index 000000000..71cadac36
--- /dev/null
+++ b/toolkit/jetpack/sdk/deprecated/sync-worker.js
@@ -0,0 +1,288 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ *
+ * `deprecated/sync-worker` was previously `content/worker`, that was
+ * incompatible with e10s. we are in the process of switching to the new
+ * asynchronous `Worker`, which behaves slightly differently in some edge
+ * cases, so we are keeping this one around for a short period.
+ * try to switch to the new one as soon as possible..
+ *
+ */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Class } = require('../core/heritage');
+const { EventTarget } = require('../event/target');
+const { on, off, emit, setListeners } = require('../event/core');
+const {
+  attach, detach, destroy
+} = require('../content/utils');
+const { method } = require('../lang/functional');
+const { Ci, Cu, Cc } = require('chrome');
+const unload = require('../system/unload');
+const events = require('../system/events');
+const { getInnerId } = require("../window/utils");
+const { WorkerSandbox } = require('../content/sandbox');
+const { isPrivate } = require('../private-browsing/utils');
+
+// A weak map of workers to hold private attributes that
+// should not be exposed
+const workers = new WeakMap();
+
+var modelFor = (worker) => workers.get(worker);
+
+const ERR_DESTROYED =
+  "Couldn't find the worker to receive this message. " +
+  "The script may not be initialized yet, or may already have been unloaded.";
+
+const ERR_FROZEN = "The page is currently hidden and can no longer be used " +
+                   "until it is visible again.";
+
+/**
+ * Message-passing facility for communication between code running
+ * in the content and add-on process.
+ * @see https://developer.mozilla.org/en-US/Add-ons/SDK/Low-Level_APIs/content_worker
+ */
+const Worker = Class({
+  implements: [EventTarget],
+  initialize: function WorkerConstructor (options) {
+    // Save model in weak map to not expose properties
+    let model = createModel();
+    workers.set(this, model);
+
+    options = options || {};
+
+    if ('contentScriptFile' in options)
+      this.contentScriptFile = options.contentScriptFile;
+    if ('contentScriptOptions' in options)
+      this.contentScriptOptions = options.contentScriptOptions;
+    if ('contentScript' in options)
+      this.contentScript = options.contentScript;
+    if ('injectInDocument' in options)
+      this.injectInDocument = !!options.injectInDocument;
+
+    setListeners(this, options);
+
+    unload.ensure(this, "destroy");
+
+    // Ensure that worker.port is initialized for contentWorker to be able
+    // to send events during worker initialization.
+    this.port = createPort(this);
+
+    model.documentUnload = documentUnload.bind(this);
+    model.pageShow = pageShow.bind(this);
+    model.pageHide = pageHide.bind(this);
+
+    if ('window' in options)
+      attach(this, options.window);
+  },
+
+  /**
+   * Sends a message to the worker's global scope. Method takes single
+   * argument, which represents data to be sent to the worker. The data may
+   * be any primitive type value or `JSON`. Call of this method asynchronously
+   * emits `message` event with data value in the global scope of this
+   * worker.
+   *
+   * `message` event listeners can be set either by calling
+   * `self.on` with a first argument string `"message"` or by
+   * implementing `onMessage` function in the global scope of this worker.
+   * @param {Number|String|JSON} data
+   */
+  postMessage: function (...data) {
+    let model = modelFor(this);
+    let args = ['message'].concat(data);
+    if (!model.inited) {
+      model.earlyEvents.push(args);
+      return;
+    }
+    processMessage.apply(null, [this].concat(args));
+  },
+
+  get url () {
+    let model = modelFor(this);
+    // model.window will be null after detach
+    return model.window ? model.window.document.location.href : null;
+  },
+
+  get contentURL () {
+    let model = modelFor(this);
+    return model.window ? model.window.document.URL : null;
+  },
+
+  // Implemented to provide some of the previous features of exposing sandbox
+  // so that Worker can be extended
+  getSandbox: function () {
+    return modelFor(this).contentWorker;
+  },
+
+  toString: function () { return '[object Worker]'; },
+  attach: method(attach),
+  detach: method(detach),
+  destroy: method(destroy)
+});
+exports.Worker = Worker;
+
+attach.define(Worker, function (worker, window) {
+  let model = modelFor(worker);
+  model.window = window;
+  // Track document unload to destroy this worker.
+  // We can't watch for unload event on page's window object as it
+  // prevents bfcache from working:
+  // https://developer.mozilla.org/En/Working_with_BFCache
+  model.windowID = getInnerId(model.window);
+  events.on("inner-window-destroyed", model.documentUnload);
+
+  // will set model.contentWorker pointing to the private API:
+  model.contentWorker = WorkerSandbox(worker, model.window);
+
+  // Listen to pagehide event in order to freeze the content script
+  // while the document is frozen in bfcache:
+  model.window.addEventListener("pageshow", model.pageShow, true);
+  model.window.addEventListener("pagehide", model.pageHide, true);
+
+  // Mainly enable worker.port.emit to send event to the content worker
+  model.inited = true;
+  model.frozen = false;
+
+  // Fire off `attach` event
+  emit(worker, 'attach', window);
+
+  // Process all events and messages that were fired before the
+  // worker was initialized.
+  model.earlyEvents.forEach(args => processMessage.apply(null, [worker].concat(args)));
+});
+
+/**
+ * Remove all internal references to the attached document
+ * Tells _port to unload itself and removes all the references from itself.
+ */
+detach.define(Worker, function (worker, reason) {
+  let model = modelFor(worker);
+
+  // maybe unloaded before content side is created
+  if (model.contentWorker) {
+    model.contentWorker.destroy(reason);
+  }
+
+  model.contentWorker = null;
+  if (model.window) {
+    model.window.removeEventListener("pageshow", model.pageShow, true);
+    model.window.removeEventListener("pagehide", model.pageHide, true);
+  }
+  model.window = null;
+  // This method may be called multiple times,
+  // avoid dispatching `detach` event more than once
+  if (model.windowID) {
+    model.windowID = null;
+    events.off("inner-window-destroyed", model.documentUnload);
+    model.earlyEvents.length = 0;
+    emit(worker, 'detach');
+  }
+  model.inited = false;
+});
+
+isPrivate.define(Worker, ({ tab }) => isPrivate(tab));
+
+/**
+ * Tells content worker to unload itself and
+ * removes all the references from itself.
+ */
+destroy.define(Worker, function (worker, reason) {
+  detach(worker, reason);
+  modelFor(worker).inited = true;
+  // Specifying no type or listener removes all listeners
+  // from target
+  off(worker);
+  off(worker.port);
+});
+
+/**
+ * Events fired by workers
+ */
+function documentUnload ({ subject, data }) {
+  let model = modelFor(this);
+  let innerWinID = subject.QueryInterface(Ci.nsISupportsPRUint64).data;
+  if (innerWinID != model.windowID) return false;
+  detach(this);
+  return true;
+}
+
+function pageShow () {
+  let model = modelFor(this);
+  model.contentWorker.emitSync('pageshow');
+  emit(this, 'pageshow');
+  model.frozen = false;
+}
+
+function pageHide () {
+  let model = modelFor(this);
+  model.contentWorker.emitSync('pagehide');
+  emit(this, 'pagehide');
+  model.frozen = true;
+}
+
+/**
+ * Fired from postMessage and emitEventToContent, or from the earlyMessage
+ * queue when fired before the content is loaded. Sends arguments to
+ * contentWorker if able
+ */
+
+function processMessage (worker, ...args) {
+  let model = modelFor(worker) || {};
+  if (!model.contentWorker)
+    throw new Error(ERR_DESTROYED);
+  if (model.frozen)
+    throw new Error(ERR_FROZEN);
+  model.contentWorker.emit.apply(null, args);
+}
+
+function createModel () {
+  return {
+    // List of messages fired before worker is initialized
+    earlyEvents: [],
+    // Is worker connected to the content worker sandbox ?
+    inited: false,
+    // Is worker being frozen? i.e related document is frozen in bfcache.
+    // Content script should not be reachable if frozen.
+    frozen: true,
+    /**
+     * Reference to the content side of the worker.
+     * @type {WorkerGlobalScope}
+     */
+    contentWorker: null,
+    /**
+     * Reference to the window that is accessible from
+     * the content scripts.
+     * @type {Object}
+     */
+    window: null
+  };
+}
+
+function createPort (worker) {
+  let port = EventTarget();
+  port.emit = emitEventToContent.bind(null, worker);
+  return port;
+}
+
+/**
+ * Emit a custom event to the content script,
+ * i.e. emit this event on `self.port`
+ */
+function emitEventToContent (worker, ...eventArgs) {
+  let model = modelFor(worker);
+  let args = ['event'].concat(eventArgs);
+  if (!model.inited) {
+    model.earlyEvents.push(args);
+    return;
+  }
+  processMessage.apply(null, [worker].concat(args));
+}
diff --git a/toolkit/jetpack/sdk/deprecated/unit-test-finder.js b/toolkit/jetpack/sdk/deprecated/unit-test-finder.js
new file mode 100644
index 000000000..e38629f45
--- /dev/null
+++ b/toolkit/jetpack/sdk/deprecated/unit-test-finder.js
@@ -0,0 +1,199 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "deprecated"
+};
+
+const file = require("../io/file");
+const { Loader } = require("../test/loader");
+
+const { isNative } = require('@loader/options');
+
+const cuddlefish = isNative ? require("toolkit/loader") : require("../loader/cuddlefish");
+
+const { defer, resolve } = require("../core/promise");
+const { getAddon } = require("../addon/installer");
+const { id } = require("sdk/self");
+const { newURI } = require('sdk/url/utils');
+const { getZipReader } = require("../zip/utils");
+
+const { Cc, Ci, Cu } = require("chrome");
+const { AddonManager } = Cu.import("resource://gre/modules/AddonManager.jsm", {});
+var ios = Cc['@mozilla.org/network/io-service;1']
+          .getService(Ci.nsIIOService);
+
+const CFX_TEST_REGEX = /(([^\/]+\/)(?:lib\/)?)?(tests?\/test-[^\.\/]+)\.js$/;
+const JPM_TEST_REGEX = /^()(tests?\/test-[^\.\/]+)\.js$/;
+
+const { mapcat, map, filter, fromEnumerator } = require("sdk/util/sequence");
+
+const toFile = x => x.QueryInterface(Ci.nsIFile);
+const isTestFile = ({leafName}) => leafName.substr(0, 5) == "test-" && leafName.substr(-3, 3) == ".js";
+const getFileURI = x => ios.newFileURI(x).spec;
+
+const getDirectoryEntries = file => map(toFile, fromEnumerator(_ => file.directoryEntries));
+const getTestFiles = directory => filter(isTestFile, getDirectoryEntries(directory));
+const getTestURIs = directory => map(getFileURI, getTestFiles(directory));
+
+const isDirectory = x => x.isDirectory();
+const getTestEntries = directory => mapcat(entry =>
+  /^tests?$/.test(entry.leafName) ? getTestURIs(entry) : getTestEntries(entry),
+  filter(isDirectory, getDirectoryEntries(directory)));
+
+const removeDups = (array) => array.reduce((result, value) => {
+  if (value != result[result.length - 1]) {
+    result.push(value);
+  }
+  return result;
+}, []);
+
+const getSuites = function getSuites({ id, filter }) {
+  const TEST_REGEX = isNative ? JPM_TEST_REGEX : CFX_TEST_REGEX;
+
+  return getAddon(id).then(addon => {
+    let fileURI = addon.getResourceURI("tests/");
+    let isPacked = fileURI.scheme == "jar";
+    let xpiURI = addon.getResourceURI();
+    let file = xpiURI.QueryInterface(Ci.nsIFileURL).file;
+    let suites = [];
+    let addEntry = (entry) => {
+      if (filter(entry) && TEST_REGEX.test(entry)) {
+        let suite = (isNative ? "./" : "") + (RegExp.$2 || "") + RegExp.$3;
+        suites.push(suite);
+      }
+    }
+
+    if (isPacked) {
+      return getZipReader(file).then(zip => {
+        let entries = zip.findEntries(null);
+        while (entries.hasMore()) {
+          let entry = entries.getNext();
+          addEntry(entry);
+        }
+        zip.close();
+
+        // sort and remove dups
+        suites = removeDups(suites.sort());
+        return suites;
+      })
+    }
+    else {
+      let tests = [...getTestEntries(file)];
+      let rootURI = addon.getResourceURI("/");
+      tests.forEach((entry) => {
+        addEntry(entry.replace(rootURI.spec, ""));
+      });
+    }
+
+    // sort and remove dups
+    suites = removeDups(suites.sort());
+    return suites;
+  });
+}
+exports.getSuites = getSuites;
+
+const makeFilters = function makeFilters(options) {
+  options = options || {};
+
+  // A filter string is {fileNameRegex}[:{testNameRegex}] - ie, a colon
+  // optionally separates a regex for the test fileName from a regex for the
+  // testName.
+  if (options.filter) {
+    let colonPos = options.filter.indexOf(':');
+    let filterFileRegex, filterNameRegex;
+
+    if (colonPos === -1) {
+      filterFileRegex = new RegExp(options.filter);
+      filterNameRegex = { test: () => true }
+    }
+    else {
+      filterFileRegex = new RegExp(options.filter.substr(0, colonPos));
+      filterNameRegex = new RegExp(options.filter.substr(colonPos + 1));
+    }
+
+    return {
+      fileFilter: (name) => filterFileRegex.test(name),
+      testFilter: (name) => filterNameRegex.test(name)
+    }
+  }
+
+  return {
+    fileFilter: () => true,
+    testFilter: () => true
+  };
+}
+exports.makeFilters = makeFilters;
+
+var loader = Loader(module);
+const NOT_TESTS = ['setup', 'teardown'];
+
+var TestFinder = exports.TestFinder = function TestFinder(options) {
+  this.filter = options.filter;
+  this.testInProcess = options.testInProcess === false ? false : true;
+  this.testOutOfProcess = options.testOutOfProcess === true ? true : false;
+};
+
+TestFinder.prototype = {
+  findTests: function findTests() {
+    let { fileFilter, testFilter } = makeFilters({ filter: this.filter });
+
+    return getSuites({ id: id, filter: fileFilter }).then(suites => {
+      let testsRemaining = [];
+
+      let getNextTest = () => {
+        if (testsRemaining.length) {
+          return testsRemaining.shift();
+        }
+
+        if (!suites.length) {
+          return null;
+        }
+
+        let suite = suites.shift();
+
+        // Load each test file as a main module in its own loader instance
+        // `suite` is defined by cuddlefish/manifest.py:ManifestBuilder.build
+        let suiteModule;
+
+        try {
+          suiteModule = cuddlefish.main(loader, suite);
+        }
+        catch (e) {
+          if (/Unsupported Application/i.test(e.message)) {
+            // If `Unsupported Application` error thrown during test,
+            // skip the test suite
+            suiteModule = {
+              'test suite skipped': assert => assert.pass(e.message)
+            };
+          }
+          else {
+            console.exception(e);
+            throw e;
+          }
+        }
+
+        if (this.testInProcess) {
+          for (let name of Object.keys(suiteModule).sort()) {
+            if (NOT_TESTS.indexOf(name) === -1 && testFilter(name)) {
+              testsRemaining.push({
+                setup: suiteModule.setup,
+                teardown: suiteModule.teardown,
+                testFunction: suiteModule[name],
+                name: suite + "." + name
+              });
+            }
+          }
+        }
+
+        return getNextTest();
+      };
+
+      return {
+        getNext: () => resolve(getNextTest())
+      };
+    });
+  }
+};
diff --git a/toolkit/jetpack/sdk/deprecated/unit-test.js b/toolkit/jetpack/sdk/deprecated/unit-test.js
new file mode 100644
index 000000000..32bba8f6b
--- /dev/null
+++ b/toolkit/jetpack/sdk/deprecated/unit-test.js
@@ -0,0 +1,584 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "deprecated"
+};
+
+const timer = require("../timers");
+const cfxArgs = require("../test/options");
+const { getTabs, closeTab, getURI, getTabId, getSelectedTab } = require("../tabs/utils");
+const { windows, isBrowser, getMostRecentBrowserWindow } = require("../window/utils");
+const { defer, all, Debugging: PromiseDebugging, resolve } = require("../core/promise");
+const { getInnerId } = require("../window/utils");
+const { cleanUI } = require("../test/utils");
+
+const findAndRunTests = function findAndRunTests(options) {
+  var TestFinder = require("./unit-test-finder").TestFinder;
+  var finder = new TestFinder({
+    filter: options.filter,
+    testInProcess: options.testInProcess,
+    testOutOfProcess: options.testOutOfProcess
+  });
+  var runner = new TestRunner({fs: options.fs});
+  finder.findTests().then(tests => {
+    runner.startMany({
+      tests: tests,
+      stopOnError: options.stopOnError,
+      onDone: options.onDone
+    });
+  });
+};
+exports.findAndRunTests = findAndRunTests;
+
+var runnerWindows = new WeakMap();
+var runnerTabs = new WeakMap();
+
+const TestRunner = function TestRunner(options) {
+  options = options || {};
+
+  // remember the id's for the open window and tab
+  let window = getMostRecentBrowserWindow();
+  runnerWindows.set(this, getInnerId(window));
+  runnerTabs.set(this, getTabId(getSelectedTab(window)));
+
+  this.fs = options.fs;
+  this.console = options.console || console;
+  this.passed = 0;
+  this.failed = 0;
+  this.testRunSummary = [];
+  this.expectFailNesting = 0;
+  this.done = TestRunner.prototype.done.bind(this);
+};
+
+TestRunner.prototype = {
+  toString: function toString() {
+    return "[object TestRunner]";
+  },
+
+  DEFAULT_PAUSE_TIMEOUT: (cfxArgs.parseable ? 300000 : 15000), //Five minutes (5*60*1000ms)
+  PAUSE_DELAY: 500,
+
+  _logTestFailed: function _logTestFailed(why) {
+    if (!(why in this.test.errors))
+      this.test.errors[why] = 0;
+    this.test.errors[why]++;
+  },
+
+  _uncaughtErrorObserver: function({message, date, fileName, stack, lineNumber}) {
+    this.fail("There was an uncaught Promise rejection: " + message + " @ " +
+              fileName + ":" + lineNumber + "\n" + stack);
+  },
+
+  pass: function pass(message) {
+    if(!this.expectFailure) {
+      if ("testMessage" in this.console)
+        this.console.testMessage(true, true, this.test.name, message);
+      else
+        this.console.info("pass:", message);
+      this.passed++;
+      this.test.passed++;
+      this.test.last = message;
+    }
+    else {
+      this.expectFailure = false;
+      this._logTestFailed("failure");
+      if ("testMessage" in this.console) {
+        this.console.testMessage(true, false, this.test.name, message);
+      }
+      else {
+        this.console.error("fail:", 'Failure Expected: ' + message)
+        this.console.trace();
+      }
+      this.failed++;
+      this.test.failed++;
+    }
+  },
+
+  fail: function fail(message) {
+    if(!this.expectFailure) {
+      this._logTestFailed("failure");
+      if ("testMessage" in this.console) {
+        this.console.testMessage(false, false, this.test.name, message);
+      }
+      else {
+        this.console.error("fail:", message)
+        this.console.trace();
+      }
+      this.failed++;
+      this.test.failed++;
+    }
+    else {
+      this.expectFailure = false;
+      if ("testMessage" in this.console)
+        this.console.testMessage(false, true, this.test.name, message);
+      else
+        this.console.info("pass:", message);
+      this.passed++;
+      this.test.passed++;
+      this.test.last = message;
+    }
+  },
+
+  expectFail: function(callback) {
+    this.expectFailure = true;
+    callback();
+    this.expectFailure = false;
+  },
+
+  exception: function exception(e) {
+    this._logTestFailed("exception");
+    if (cfxArgs.parseable)
+      this.console.print("TEST-UNEXPECTED-FAIL | " + this.test.name + " | " + e + "\n");
+    this.console.exception(e);
+    this.failed++;
+    this.test.failed++;
+  },
+
+  assertMatches: function assertMatches(string, regexp, message) {
+    if (regexp.test(string)) {
+      if (!message)
+        message = uneval(string) + " matches " + uneval(regexp);
+      this.pass(message);
+    } else {
+      var no = uneval(string) + " doesn't match " + uneval(regexp);
+      if (!message)
+        message = no;
+      else
+        message = message + " (" + no + ")";
+      this.fail(message);
+    }
+  },
+
+  assertRaises: function assertRaises(func, predicate, message) {
+    try {
+      func();
+      if (message)
+        this.fail(message + " (no exception thrown)");
+      else
+        this.fail("function failed to throw exception");
+    } catch (e) {
+      var errorMessage;
+      if (typeof(e) == "string")
+        errorMessage = e;
+      else
+        errorMessage = e.message;
+      if (typeof(predicate) == "string")
+        this.assertEqual(errorMessage, predicate, message);
+      else
+        this.assertMatches(errorMessage, predicate, message);
+    }
+  },
+
+  assert: function assert(a, message) {
+    if (!a) {
+      if (!message)
+        message = "assertion failed, value is " + a;
+      this.fail(message);
+    } else
+      this.pass(message || "assertion successful");
+  },
+
+  assertNotEqual: function assertNotEqual(a, b, message) {
+    if (a != b) {
+      if (!message)
+        message = "a != b != " + uneval(a);
+      this.pass(message);
+    } else {
+      var equality = uneval(a) + " == " + uneval(b);
+      if (!message)
+        message = equality;
+      else
+        message += " (" + equality + ")";
+      this.fail(message);
+    }
+  },
+
+  assertEqual: function assertEqual(a, b, message) {
+    if (a == b) {
+      if (!message)
+        message = "a == b == " + uneval(a);
+      this.pass(message);
+    } else {
+      var inequality = uneval(a) + " != " + uneval(b);
+      if (!message)
+        message = inequality;
+      else
+        message += " (" + inequality + ")";
+      this.fail(message);
+    }
+  },
+
+  assertNotStrictEqual: function assertNotStrictEqual(a, b, message) {
+    if (a !== b) {
+      if (!message)
+        message = "a !== b !== " + uneval(a);
+      this.pass(message);
+    } else {
+      var equality = uneval(a) + " === " + uneval(b);
+      if (!message)
+        message = equality;
+      else
+        message += " (" + equality + ")";
+      this.fail(message);
+    }
+  },
+
+  assertStrictEqual: function assertStrictEqual(a, b, message) {
+    if (a === b) {
+      if (!message)
+        message = "a === b === " + uneval(a);
+      this.pass(message);
+    } else {
+      var inequality = uneval(a) + " !== " + uneval(b);
+      if (!message)
+        message = inequality;
+      else
+        message += " (" + inequality + ")";
+      this.fail(message);
+    }
+  },
+
+  assertFunction: function assertFunction(a, message) {
+    this.assertStrictEqual('function', typeof a, message);
+  },
+
+  assertUndefined: function(a, message) {
+    this.assertStrictEqual('undefined', typeof a, message);
+  },
+
+  assertNotUndefined: function(a, message) {
+    this.assertNotStrictEqual('undefined', typeof a, message);
+  },
+
+  assertNull: function(a, message) {
+    this.assertStrictEqual(null, a, message);
+  },
+
+  assertNotNull: function(a, message) {
+    this.assertNotStrictEqual(null, a, message);
+  },
+
+  assertObject: function(a, message) {
+    this.assertStrictEqual('[object Object]', Object.prototype.toString.apply(a), message);
+  },
+
+  assertString: function(a, message) {
+    this.assertStrictEqual('[object String]', Object.prototype.toString.apply(a), message);
+  },
+
+  assertArray: function(a, message) {
+    this.assertStrictEqual('[object Array]', Object.prototype.toString.apply(a), message);
+  },
+
+  assertNumber: function(a, message) {
+    this.assertStrictEqual('[object Number]', Object.prototype.toString.apply(a), message);
+  },
+
+  done: function done() {
+    if (this.isDone) {
+      return resolve();
+    }
+
+    this.isDone = true;
+    this.pass("This test is done.");
+
+    if (this.test.teardown) {
+      this.test.teardown(this);
+    }
+
+    if (this.waitTimeout !== null) {
+      timer.clearTimeout(this.waitTimeout);
+      this.waitTimeout = null;
+    }
+
+    // Do not leave any callback set when calling to `waitUntil`
+    this.waitUntilCallback = null;
+    if (this.test.passed == 0 && this.test.failed == 0) {
+      this._logTestFailed("empty test");
+
+      if ("testMessage" in this.console) {
+        this.console.testMessage(false, false, this.test.name, "Empty test");
+      }
+      else {
+        this.console.error("fail:", "Empty test")
+      }
+
+      this.failed++;
+      this.test.failed++;
+    }
+
+    let wins = windows(null, { includePrivate: true });
+    let winPromises = wins.map(win => {
+      return new Promise(resolve => {
+        if (["interactive", "complete"].indexOf(win.document.readyState) >= 0) {
+          resolve()
+        }
+        else {
+          win.addEventListener("DOMContentLoaded", function onLoad() {
+            win.removeEventListener("DOMContentLoaded", onLoad, false);
+            resolve();
+          }, false);
+        }
+      });
+    });
+
+    PromiseDebugging.flushUncaughtErrors();
+    PromiseDebugging.removeUncaughtErrorObserver(this._uncaughtErrorObserver);
+
+
+    return all(winPromises).then(() => {
+      let browserWins = wins.filter(isBrowser);
+      let tabs = browserWins.reduce((tabs, window) => tabs.concat(getTabs(window)), []);
+      let newTabID = getTabId(getSelectedTab(wins[0]));
+      let oldTabID = runnerTabs.get(this);
+      let hasMoreTabsOpen = browserWins.length && tabs.length != 1;
+      let failure = false;
+
+      if (wins.length != 1 || getInnerId(wins[0]) !== runnerWindows.get(this)) {
+        failure = true;
+        this.fail("Should not be any unexpected windows open");
+      }
+      else if (hasMoreTabsOpen) {
+        failure = true;
+        this.fail("Should not be any unexpected tabs open");
+      }
+      else if (oldTabID != newTabID) {
+        failure = true;
+        runnerTabs.set(this, newTabID);
+        this.fail("Should not be any new tabs left open, old id: " + oldTabID + " new id: " + newTabID);
+      }
+
+      if (failure) {
+        console.log("Windows open:");
+        for (let win of wins) {
+          if (isBrowser(win)) {
+            tabs = getTabs(win);
+            console.log(win.location + " - " + tabs.map(getURI).join(", "));
+          }
+          else {
+            console.log(win.location);
+          }
+        }
+      }
+
+      return failure;
+    }).
+    then(failure => {
+      if (!failure) {
+        this.pass("There was a clean UI.");
+        return null;
+      }
+      return cleanUI().then(() => {
+        this.pass("There is a clean UI.");
+      });
+    }).
+    then(() => {
+      this.testRunSummary.push({
+        name: this.test.name,
+        passed: this.test.passed,
+        failed: this.test.failed,
+        errors: Object.keys(this.test.errors).join(", ")
+      });
+
+      if (this.onDone !== null) {
+        let onDone = this.onDone;
+        this.onDone = null;
+        timer.setTimeout(_ => onDone(this));
+      }
+    }).
+    catch(console.exception);
+  },
+
+  // Set of assertion functions to wait for an assertion to become true
+  // These functions take the same arguments as the TestRunner.assert* methods.
+  waitUntil: function waitUntil() {
+    return this._waitUntil(this.assert, arguments);
+  },
+
+  waitUntilNotEqual: function waitUntilNotEqual() {
+    return this._waitUntil(this.assertNotEqual, arguments);
+  },
+
+  waitUntilEqual: function waitUntilEqual() {
+    return this._waitUntil(this.assertEqual, arguments);
+  },
+
+  waitUntilMatches: function waitUntilMatches() {
+    return this._waitUntil(this.assertMatches, arguments);
+  },
+
+  /**
+   * Internal function that waits for an assertion to become true.
+   * @param {Function} assertionMethod
+   *    Reference to a TestRunner assertion method like test.assert,
+   *    test.assertEqual, ...
+   * @param {Array} args
+   *    List of arguments to give to the previous assertion method.
+   *    All functions in this list are going to be called to retrieve current
+   *    assertion values.
+   */
+  _waitUntil: function waitUntil(assertionMethod, args) {
+    let { promise, resolve } = defer();
+    let count = 0;
+    let maxCount = this.DEFAULT_PAUSE_TIMEOUT / this.PAUSE_DELAY;
+
+    // We need to ensure that test is asynchronous
+    if (!this.waitTimeout)
+      this.waitUntilDone(this.DEFAULT_PAUSE_TIMEOUT);
+
+    let finished = false;
+    let test = this;
+
+    // capture a traceback before we go async.
+    let traceback = require("../console/traceback");
+    let stack = traceback.get();
+    stack.splice(-2, 2);
+    let currentWaitStack = traceback.format(stack);
+    let timeout = null;
+
+    function loop(stopIt) {
+      timeout = null;
+
+      // Build a mockup object to fake TestRunner API and intercept calls to
+      // pass and fail methods, in order to retrieve nice error messages
+      // and assertion result
+      let mock = {
+        pass: function (msg) {
+          test.pass(msg);
+          test.waitUntilCallback = null;
+          if (!stopIt)
+            resolve();
+        },
+        fail: function (msg) {
+          // If we are called on test timeout, we stop the loop
+          // and print which test keeps failing:
+          if (stopIt) {
+            test.console.error("test assertion never became true:\n",
+                               msg + "\n",
+                               currentWaitStack);
+            if (timeout)
+              timer.clearTimeout(timeout);
+            return;
+          }
+          timeout = timer.setTimeout(loop, test.PAUSE_DELAY);
+        }
+      };
+
+      // Automatically call args closures in order to build arguments for
+      // assertion function
+      let appliedArgs = [];
+      for (let i = 0, l = args.length; i < l; i++) {
+        let a = args[i];
+        if (typeof a == "function") {
+          try {
+            a = a();
+          }
+          catch(e) {
+            test.fail("Exception when calling asynchronous assertion: " + e +
+                      "\n" + e.stack);
+            return resolve();
+          }
+        }
+        appliedArgs.push(a);
+      }
+
+      // Finally call assertion function with current assertion values
+      assertionMethod.apply(mock, appliedArgs);
+    }
+    loop();
+    this.waitUntilCallback = loop;
+
+    return promise;
+  },
+
+  waitUntilDone: function waitUntilDone(ms) {
+    if (ms === undefined)
+      ms = this.DEFAULT_PAUSE_TIMEOUT;
+
+    var self = this;
+
+    function tiredOfWaiting() {
+      self._logTestFailed("timed out");
+      if ("testMessage" in self.console) {
+        self.console.testMessage(false, false, self.test.name,
+          `Test timed out (after: ${self.test.last})`);
+      }
+      else {
+        self.console.error("fail:", `Timed out (after: ${self.test.last})`)
+      }
+      if (self.waitUntilCallback) {
+        self.waitUntilCallback(true);
+        self.waitUntilCallback = null;
+      }
+      self.failed++;
+      self.test.failed++;
+      self.done();
+    }
+
+    // We may already have registered a timeout callback
+    if (this.waitTimeout)
+      timer.clearTimeout(this.waitTimeout);
+
+    this.waitTimeout = timer.setTimeout(tiredOfWaiting, ms);
+  },
+
+  startMany: function startMany(options) {
+    function runNextTest(self) {
+      let { tests, onDone } = options;
+
+      return tests.getNext().then((test) => {
+        if (options.stopOnError && self.test && self.test.failed) {
+          self.console.error("aborted: test failed and --stop-on-error was specified");
+          onDone(self);
+        }
+        else if (test) {
+          self.start({test: test, onDone: runNextTest});
+        }
+        else {
+          onDone(self);
+        }
+      });
+    }
+
+    return runNextTest(this).catch(console.exception);
+  },
+
+  start: function start(options) {
+    this.test = options.test;
+    this.test.passed = 0;
+    this.test.failed = 0;
+    this.test.errors = {};
+    this.test.last = 'START';
+    PromiseDebugging.clearUncaughtErrorObservers();
+    this._uncaughtErrorObserver = this._uncaughtErrorObserver.bind(this);
+    PromiseDebugging.addUncaughtErrorObserver(this._uncaughtErrorObserver);
+
+    this.isDone = false;
+    this.onDone = function(self) {
+      if (cfxArgs.parseable)
+        self.console.print("TEST-END | " + self.test.name + "\n");
+      options.onDone(self);
+    }
+    this.waitTimeout = null;
+
+    try {
+      if (cfxArgs.parseable)
+        this.console.print("TEST-START | " + this.test.name + "\n");
+      else
+        this.console.info("executing '" + this.test.name + "'");
+
+      if(this.test.setup) {
+        this.test.setup(this);
+      }
+      this.test.testFunction(this);
+    } catch (e) {
+      this.exception(e);
+    }
+    if (this.waitTimeout === null)
+      this.done();
+  }
+};
+exports.TestRunner = TestRunner;
diff --git a/toolkit/jetpack/sdk/deprecated/window-utils.js b/toolkit/jetpack/sdk/deprecated/window-utils.js
new file mode 100644
index 000000000..93c0ab7b8
--- /dev/null
+++ b/toolkit/jetpack/sdk/deprecated/window-utils.js
@@ -0,0 +1,193 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'deprecated'
+};
+
+const { Cc, Ci } = require('chrome');
+const events = require('../system/events');
+const { getInnerId, getOuterId, windows, isDocumentLoaded, isBrowser,
+        getMostRecentBrowserWindow, getToplevelWindow, getMostRecentWindow } = require('../window/utils');
+const { deprecateFunction } = require('../util/deprecate');
+const { ignoreWindow } = require('sdk/private-browsing/utils');
+const { isPrivateBrowsingSupported } = require('../self');
+
+const windowWatcher = Cc['@mozilla.org/embedcomp/window-watcher;1'].
+                       getService(Ci.nsIWindowWatcher);
+const appShellService = Cc['@mozilla.org/appshell/appShellService;1'].
+                        getService(Ci.nsIAppShellService);
+
+// Bug 834961: ignore private windows when they are not supported
+function getWindows() {
+  return windows(null, { includePrivate: isPrivateBrowsingSupported });
+}
+
+/**
+ * An iterator for XUL windows currently in the application.
+ *
+ * @return A generator that yields XUL windows exposing the
+ *         nsIDOMWindow interface.
+ */
+function windowIterator() {
+  // Bug 752631: We only pass already loaded window in order to avoid
+  // breaking XUL windows DOM. DOM is broken when some JS code try
+  // to access DOM during "uninitialized" state of the related document.
+  let list = getWindows().filter(isDocumentLoaded);
+  for (let i = 0, l = list.length; i < l; i++) {
+    yield list[i];
+  }
+};
+exports.windowIterator = windowIterator;
+
+/**
+ * An iterator for browser windows currently open in the application.
+ * @returns {Function}
+ *    A generator that yields browser windows exposing the `nsIDOMWindow`
+ *    interface.
+ */
+function browserWindowIterator() {
+  for (let window of windowIterator()) {
+    if (isBrowser(window))
+      yield window;
+  }
+}
+exports.browserWindowIterator = browserWindowIterator;
+
+function WindowTracker(delegate) {
+   if (!(this instanceof WindowTracker)) {
+     return new WindowTracker(delegate);
+   }
+
+  this._delegate = delegate;
+
+  for (let window of getWindows())
+    this._regWindow(window);
+  windowWatcher.registerNotification(this);
+  this._onToplevelWindowReady = this._onToplevelWindowReady.bind(this);
+  events.on('toplevel-window-ready', this._onToplevelWindowReady);
+
+  require('../system/unload').ensure(this);
+
+  return this;
+};
+
+WindowTracker.prototype = {
+  _regLoadingWindow: function _regLoadingWindow(window) {
+    // Bug 834961: ignore private windows when they are not supported
+    if (ignoreWindow(window))
+      return;
+
+    window.addEventListener('load', this, true);
+  },
+
+  _unregLoadingWindow: function _unregLoadingWindow(window) {
+    // This may have no effect if we ignored the window in _regLoadingWindow().
+    window.removeEventListener('load', this, true);
+  },
+
+  _regWindow: function _regWindow(window) {
+    // Bug 834961: ignore private windows when they are not supported
+    if (ignoreWindow(window))
+      return;
+
+    if (window.document.readyState == 'complete') {
+      this._unregLoadingWindow(window);
+      this._delegate.onTrack(window);
+    } else
+      this._regLoadingWindow(window);
+  },
+
+  _unregWindow: function _unregWindow(window) {
+    if (window.document.readyState == 'complete') {
+      if (this._delegate.onUntrack)
+        this._delegate.onUntrack(window);
+    } else {
+      this._unregLoadingWindow(window);
+    }
+  },
+
+  unload: function unload() {
+    windowWatcher.unregisterNotification(this);
+    events.off('toplevel-window-ready', this._onToplevelWindowReady);
+    for (let window of getWindows())
+      this._unregWindow(window);
+  },
+
+  handleEvent: function handleEvent(event) {
+    try {
+      if (event.type == 'load' && event.target) {
+        var window = event.target.defaultView;
+        if (window)
+          this._regWindow(getToplevelWindow(window));
+      }
+    }
+    catch(e) {
+      console.exception(e);
+    }
+  },
+
+  _onToplevelWindowReady: function _onToplevelWindowReady({subject}) {
+    let window = getToplevelWindow(subject);
+    // ignore private windows if they are not supported
+    if (ignoreWindow(window))
+      return;
+    this._regWindow(window);
+  },
+
+  observe: function observe(subject, topic, data) {
+    try {
+      var window = subject.QueryInterface(Ci.nsIDOMWindow);
+      // ignore private windows if they are not supported
+      if (ignoreWindow(window))
+        return;
+      if (topic == 'domwindowclosed')
+      this._unregWindow(window);
+    }
+    catch(e) {
+      console.exception(e);
+    }
+  }
+};
+exports.WindowTracker = WindowTracker;
+
+Object.defineProperties(exports, {
+  activeWindow: {
+    enumerable: true,
+    get: function() {
+      return getMostRecentWindow(null);
+    },
+    set: function(window) {
+      try {
+        window.focus();
+      } catch (e) {}
+    }
+  },
+  activeBrowserWindow: {
+    enumerable: true,
+    get: getMostRecentBrowserWindow
+  }
+});
+
+
+/**
+ * Returns the ID of the window's current inner window.
+ */
+exports.getInnerId = deprecateFunction(getInnerId,
+  'require("window-utils").getInnerId is deprecated, ' +
+  'please use require("sdk/window/utils").getInnerId instead'
+);
+
+exports.getOuterId = deprecateFunction(getOuterId,
+  'require("window-utils").getOuterId is deprecated, ' +
+  'please use require("sdk/window/utils").getOuterId instead'
+);
+
+exports.isBrowser = deprecateFunction(isBrowser,
+  'require("window-utils").isBrowser is deprecated, ' +
+  'please use require("sdk/window/utils").isBrowser instead'
+);
+
+exports.hiddenWindow = appShellService.hiddenDOMWindow;
diff --git a/toolkit/jetpack/sdk/dom/events-shimmed.js b/toolkit/jetpack/sdk/dom/events-shimmed.js
new file mode 100644
index 000000000..7a1727681
--- /dev/null
+++ b/toolkit/jetpack/sdk/dom/events-shimmed.js
@@ -0,0 +1,18 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+const events = require('./events.js');
+
+exports.emit = (element, type, obj) => events.emit(element, type, obj, true);
+exports.on = (element, type, listener, capture) => events.on(element, type, listener, capture, true);
+exports.once = (element, type, listener, capture) => events.once(element, type, listener, capture, true);
+exports.removeListener = (element, type, listener, capture) => events.removeListener(element, type, listener, capture, true);
+exports.removed = events.removed;
+exports.when = (element, eventName, capture) => events.when(element, eventName, capture ? capture : false, true);
diff --git a/toolkit/jetpack/sdk/dom/events.js b/toolkit/jetpack/sdk/dom/events.js
new file mode 100644
index 000000000..502d2350f
--- /dev/null
+++ b/toolkit/jetpack/sdk/dom/events.js
@@ -0,0 +1,192 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cu } = require("chrome");
+const { ShimWaiver } = Cu.import("resource://gre/modules/ShimWaiver.jsm");
+
+// Utility function that returns copy of the given `text` with last character
+// removed if it is `"s"`.
+function singularify(text) {
+  return text[text.length - 1] === "s" ? text.substr(0, text.length - 1) : text;
+}
+
+// Utility function that takes event type, argument is passed to
+// `document.createEvent` and returns name of the initializer method of the
+// given event. Please note that there are some event types whose initializer
+// methods can't be guessed by this function. For more details see following
+// link: https://developer.mozilla.org/En/DOM/Document.createEvent
+function getInitializerName(category) {
+  return "init" + singularify(category);
+}
+
+/**
+ * Registers an event `listener` on a given `element`, that will be called
+ * when events of specified `type` is dispatched on the `element`.
+ * @param {Element} element
+ *    Dom element to register listener on.
+ * @param {String} type
+ *    A string representing the
+ *    [event type](https://developer.mozilla.org/en/DOM/event.type) to
+ *    listen for.
+ * @param {Function} listener
+ *    Function that is called whenever an event of the specified `type`
+ *    occurs.
+ * @param {Boolean} capture
+ *    If true, indicates that the user wishes to initiate capture. After
+ *    initiating capture, all events of the specified type will be dispatched
+ *    to the registered listener before being dispatched to any `EventTarget`s
+ *    beneath it in the DOM tree. Events which are bubbling upward through
+ *    the tree will not trigger a listener designated to use capture.
+ *    See [DOM Level 3 Events](http://www.w3.org/TR/DOM-Level-3-Events/#event-flow)
+ *    for a detailed explanation.
+ */
+function on(element, type, listener, capture, shimmed = false) {
+  // `capture` defaults to `false`.
+  capture = capture || false;
+  if (shimmed) {
+    element.addEventListener(type, listener, capture);
+  } else {
+    ShimWaiver.getProperty(element, "addEventListener")(type, listener, capture);
+  }
+}
+exports.on = on;
+
+/**
+ * Registers an event `listener` on a given `element`, that will be called
+ * only once, next time event of specified `type` is dispatched on the
+ * `element`.
+ * @param {Element} element
+ *    Dom element to register listener on.
+ * @param {String} type
+ *    A string representing the
+ *    [event type](https://developer.mozilla.org/en/DOM/event.type) to
+ *    listen for.
+ * @param {Function} listener
+ *    Function that is called whenever an event of the specified `type`
+ *    occurs.
+ * @param {Boolean} capture
+ *    If true, indicates that the user wishes to initiate capture. After
+ *    initiating capture, all events of the specified type will be dispatched
+ *    to the registered listener before being dispatched to any `EventTarget`s
+ *    beneath it in the DOM tree. Events which are bubbling upward through
+ *    the tree will not trigger a listener designated to use capture.
+ *    See [DOM Level 3 Events](http://www.w3.org/TR/DOM-Level-3-Events/#event-flow)
+ *    for a detailed explanation.
+ */
+function once(element, type, listener, capture, shimmed = false) {
+  on(element, type, function selfRemovableListener(event) {
+    removeListener(element, type, selfRemovableListener, capture, shimmed);
+    listener.apply(this, arguments);
+  }, capture, shimmed);
+}
+exports.once = once;
+
+/**
+ * Unregisters an event `listener` on a given `element` for the events of the
+ * specified `type`.
+ *
+ * @param {Element} element
+ *    Dom element to unregister listener from.
+ * @param {String} type
+ *    A string representing the
+ *    [event type](https://developer.mozilla.org/en/DOM/event.type) to
+ *    listen for.
+ * @param {Function} listener
+ *    Function that is called whenever an event of the specified `type`
+ *    occurs.
+ * @param {Boolean} capture
+ *    If true, indicates that the user wishes to initiate capture. After
+ *    initiating capture, all events of the specified type will be dispatched
+ *    to the registered listener before being dispatched to any `EventTarget`s
+ *    beneath it in the DOM tree. Events which are bubbling upward through
+ *    the tree will not trigger a listener designated to use capture.
+ *    See [DOM Level 3 Events](http://www.w3.org/TR/DOM-Level-3-Events/#event-flow)
+ *    for a detailed explanation.
+ */
+function removeListener(element, type, listener, capture, shimmed = false) {
+  if (shimmed) {
+    element.removeEventListener(type, listener, capture);
+  } else {
+    ShimWaiver.getProperty(element, "removeEventListener")(type, listener, capture);
+  }
+}
+exports.removeListener = removeListener;
+
+/**
+ * Emits event of the specified `type` and `category` on the given `element`.
+ * Specified `settings` are used to initialize event before dispatching it.
+ * @param {Element} element
+ *    Dom element to dispatch event on.
+ * @param {String} type
+ *    A string representing the
+ *    [event type](https://developer.mozilla.org/en/DOM/event.type).
+ * @param {Object} options
+ *    Options object containing following properties:
+ *    - `category`: String passed to the `document.createEvent`. Option is
+ *      optional and defaults to "UIEvents".
+ *    - `initializer`: If passed it will be used as name of the method used
+ *      to initialize event. If omitted name will be generated from the
+ *      `category` field by prefixing it with `"init"` and removing last
+ *      character if it matches `"s"`.
+ *    - `settings`: Array of settings that are forwarded to the event
+ *      initializer after firs `type` argument.
+ * @see https://developer.mozilla.org/En/DOM/Document.createEvent
+ */
+function emit(element, type, { category, initializer, settings }, shimmed = false) {
+  category = category || "UIEvents";
+  initializer = initializer || getInitializerName(category);
+  let document = element.ownerDocument;
+  let event = document.createEvent(category);
+  event[initializer].apply(event, [type].concat(settings));
+  if (shimmed) {
+    element.dispatchEvent(event);
+  } else {
+    ShimWaiver.getProperty(element, "dispatchEvent")(event);
+  }
+};
+exports.emit = emit;
+
+// Takes DOM `element` and returns promise which is resolved
+// when given element is removed from it's parent node.
+const removed = element => {
+  return new Promise(resolve => {
+    const { MutationObserver } = element.ownerDocument.defaultView;
+    const observer = new MutationObserver(mutations => {
+      for (let mutation of mutations) {
+        for (let node of mutation.removedNodes || []) {
+          if (node === element) {
+            observer.disconnect();
+            resolve(element);
+          }
+        }
+      }
+    });
+    observer.observe(element.parentNode, {childList: true});
+  });
+};
+exports.removed = removed;
+
+const when = (element, eventName, capture=false, shimmed=false) => new Promise(resolve => {
+  const listener = event => {
+    if (shimmed) {
+      element.removeEventListener(eventName, listener, capture);
+    } else {
+      ShimWaiver.getProperty(element, "removeEventListener")(eventName, listener, capture);
+    }
+    resolve(event);
+  };
+
+  if (shimmed) {
+    element.addEventListener(eventName, listener, capture);
+  } else {
+    ShimWaiver.getProperty(element, "addEventListener")(eventName, listener, capture);
+  }
+});
+exports.when = when;
diff --git a/toolkit/jetpack/sdk/dom/events/keys.js b/toolkit/jetpack/sdk/dom/events/keys.js
new file mode 100644
index 000000000..e6f1483a2
--- /dev/null
+++ b/toolkit/jetpack/sdk/dom/events/keys.js
@@ -0,0 +1,63 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { emit } = require("../events");
+const { getCodeForKey, toJSON } = require("../../keyboard/utils");
+const { has } = require("../../util/array");
+const { isString } = require("../../lang/type");
+
+const INITIALIZER = "initKeyEvent";
+const CATEGORY = "KeyboardEvent";
+
+function Options(options) {
+  if (!isString(options))
+    return options;
+
+  var { key, modifiers } = toJSON(options);
+  return {
+    key: key,
+    control: has(modifiers, "control"),
+    alt: has(modifiers, "alt"),
+    shift: has(modifiers, "shift"),
+    meta: has(modifiers, "meta")
+  };
+}
+
+var keyEvent = exports.keyEvent = function keyEvent(element, type, options) {
+
+  emit(element, type, {
+    initializer: INITIALIZER,
+    category: CATEGORY,
+    settings: [
+      !("bubbles" in options) || options.bubbles !== false,
+      !("cancelable" in options) || options.cancelable !== false,
+      "window" in options && options.window ? options.window : null,
+      "control" in options && !!options.control,
+      "alt" in options && !!options.alt,
+      "shift" in options && !!options.shift,
+      "meta" in options && !!options.meta,
+      getCodeForKey(options.key) || 0,
+      options.key.length === 1 ? options.key.charCodeAt(0) : 0
+    ]
+  });
+}
+
+exports.keyDown = function keyDown(element, options) {
+  keyEvent(element, "keydown", Options(options));
+};
+
+exports.keyUp = function keyUp(element, options) {
+  keyEvent(element, "keyup", Options(options));
+};
+
+exports.keyPress = function keyPress(element, options) {
+  keyEvent(element, "keypress", Options(options));
+};
+
diff --git a/toolkit/jetpack/sdk/event/chrome.js b/toolkit/jetpack/sdk/event/chrome.js
new file mode 100644
index 000000000..9044fef99
--- /dev/null
+++ b/toolkit/jetpack/sdk/event/chrome.js
@@ -0,0 +1,65 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci, Cr, Cu } = require("chrome");
+const { emit, on, off } = require("./core");
+var observerService = Cc["@mozilla.org/observer-service;1"]
+                      .getService(Ci.nsIObserverService);
+
+const { ShimWaiver } = Cu.import("resource://gre/modules/ShimWaiver.jsm");
+const addObserver = ShimWaiver.getProperty(observerService, "addObserver");
+const removeObserver = ShimWaiver.getProperty(observerService, "removeObserver");
+
+const { when: unload } = require("../system/unload");
+
+// Simple class that can be used to instantiate event channel that
+// implements `nsIObserver` interface. It's will is used by `observe`
+// function as observer + event target. It basically proxies observer
+// notifications as to it's registered listeners.
+function ObserverChannel() {}
+Object.freeze(Object.defineProperties(ObserverChannel.prototype, {
+  QueryInterface: {
+    value: function(iid) {
+      if (!iid.equals(Ci.nsIObserver) &&
+          !iid.equals(Ci.nsISupportsWeakReference) &&
+          !iid.equals(Ci.nsISupports))
+        throw Cr.NS_ERROR_NO_INTERFACE;
+      return this;
+    }
+  },
+  observe: {
+    value: function(subject, topic, data) {
+      emit(this, "data", {
+        type: topic,
+        target: subject,
+        data: data
+      });
+    }
+  }
+}));
+
+function observe(topic) {
+  let observerChannel = new ObserverChannel();
+
+  // Note: `nsIObserverService` will not hold a weak reference to a
+  // observerChannel (since third argument is `true`). There for if it
+  // will be GC-ed with all it's event listeners once no other references
+  // will be held.
+  addObserver(observerChannel, topic, true);
+
+  // We need to remove any observer added once the add-on is unloaded;
+  // otherwise we'll get a "dead object" exception.
+  // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1001833
+  unload(() => removeObserver(observerChannel, topic));
+
+  return observerChannel;
+}
+
+exports.observe = observe;
diff --git a/toolkit/jetpack/sdk/event/core.js b/toolkit/jetpack/sdk/event/core.js
new file mode 100644
index 000000000..c16dd2df5
--- /dev/null
+++ b/toolkit/jetpack/sdk/event/core.js
@@ -0,0 +1,193 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const UNCAUGHT_ERROR = 'An error event was emitted for which there was no listener.';
+const BAD_LISTENER = 'The event listener must be a function.';
+
+const { ns } = require('../core/namespace');
+
+const event = ns();
+
+const EVENT_TYPE_PATTERN = /^on([A-Z]\w+$)/;
+exports.EVENT_TYPE_PATTERN = EVENT_TYPE_PATTERN;
+
+// Utility function to access given event `target` object's event listeners for
+// the specific event `type`. If listeners for this type does not exists they
+// will be created.
+const observers = function observers(target, type) {
+  if (!target) throw TypeError("Event target must be an object");
+  let listeners = event(target);
+  return type in listeners ? listeners[type] : listeners[type] = [];
+};
+
+/**
+ * Registers an event `listener` that is called every time events of
+ * specified `type` is emitted on the given event `target`.
+ * @param {Object} target
+ *    Event target object.
+ * @param {String} type
+ *    The type of event.
+ * @param {Function} listener
+ *    The listener function that processes the event.
+ */
+function on(target, type, listener) {
+  if (typeof(listener) !== 'function')
+    throw new Error(BAD_LISTENER);
+
+  let listeners = observers(target, type);
+  if (!~listeners.indexOf(listener))
+    listeners.push(listener);
+}
+exports.on = on;
+
+
+var onceWeakMap = new WeakMap();
+
+
+/**
+ * Registers an event `listener` that is called only the next time an event
+ * of the specified `type` is emitted on the given event `target`.
+ * @param {Object} target
+ *    Event target object.
+ * @param {String} type
+ *    The type of the event.
+ * @param {Function} listener
+ *    The listener function that processes the event.
+ */
+function once(target, type, listener) {
+  let replacement = function observer(...args) {
+    off(target, type, observer);
+    onceWeakMap.delete(listener);
+    listener.apply(target, args);
+  };
+  onceWeakMap.set(listener, replacement);
+  on(target, type, replacement);
+}
+exports.once = once;
+
+/**
+ * Execute each of the listeners in order with the supplied arguments.
+ * All the exceptions that are thrown by listeners during the emit
+ * are caught and can be handled by listeners of 'error' event. Thrown
+ * exceptions are passed as an argument to an 'error' event listener.
+ * If no 'error' listener is registered exception will be logged into an
+ * error console.
+ * @param {Object} target
+ *    Event target object.
+ * @param {String} type
+ *    The type of event.
+ * @params {Object|Number|String|Boolean} args
+ *    Arguments that will be passed to listeners.
+ */
+function emit (target, type, ...args) {
+  emitOnObject(target, type, target, ...args);
+}
+exports.emit = emit;
+
+/**
+ * A variant of emit that allows setting the this property for event listeners
+ */
+function emitOnObject(target, type, thisArg, ...args) {
+  let all = observers(target, '*').length;
+  let state = observers(target, type);
+  let listeners = state.slice();
+  let count = listeners.length;
+  let index = 0;
+
+  // If error event and there are no handlers (explicit or catch-all)
+  // then print error message to the console.
+  if (count === 0 && type === 'error' && all === 0)
+    console.exception(args[0]);
+  while (index < count) {
+    try {
+      let listener = listeners[index];
+      // Dispatch only if listener is still registered.
+      if (~state.indexOf(listener))
+        listener.apply(thisArg, args);
+    }
+    catch (error) {
+      // If exception is not thrown by a error listener and error listener is
+      // registered emit `error` event. Otherwise dump exception to the console.
+      if (type !== 'error') emit(target, 'error', error);
+      else console.exception(error);
+    }
+    index++;
+  }
+   // Also emit on `"*"` so that one could listen for all events.
+  if (type !== '*') emit(target, '*', type, ...args);
+}
+exports.emitOnObject = emitOnObject;
+
+/**
+ * Removes an event `listener` for the given event `type` on the given event
+ * `target`. If no `listener` is passed removes all listeners of the given
+ * `type`. If `type` is not passed removes all the listeners of the given
+ * event `target`.
+ * @param {Object} target
+ *    The event target object.
+ * @param {String} type
+ *    The type of event.
+ * @param {Function} listener
+ *    The listener function that processes the event.
+ */
+function off(target, type, listener) {
+  let length = arguments.length;
+  if (length === 3) {
+    if (onceWeakMap.has(listener)) {
+      listener = onceWeakMap.get(listener);
+      onceWeakMap.delete(listener);
+    }
+
+    let listeners = observers(target, type);
+    let index = listeners.indexOf(listener);
+    if (~index)
+      listeners.splice(index, 1);
+  }
+  else if (length === 2) {
+    observers(target, type).splice(0);
+  }
+  else if (length === 1) {
+    let listeners = event(target);
+    Object.keys(listeners).forEach(type => delete listeners[type]);
+  }
+}
+exports.off = off;
+
+/**
+ * Returns a number of event listeners registered for the given event `type`
+ * on the given event `target`.
+ */
+function count(target, type) {
+  return observers(target, type).length;
+}
+exports.count = count;
+
+/**
+ * Registers listeners on the given event `target` from the given `listeners`
+ * dictionary. Iterates over the listeners and if property name matches name
+ * pattern `onEventType` and property is a function, then registers it as
+ * an `eventType` listener on `target`.
+ *
+ * @param {Object} target
+ *    The type of event.
+ * @param {Object} listeners
+ *    Dictionary of listeners.
+ */
+function setListeners(target, listeners) {
+  Object.keys(listeners || {}).forEach(key => {
+    let match = EVENT_TYPE_PATTERN.exec(key);
+    let type = match && match[1].toLowerCase();
+    if (!type) return;
+
+    let listener = listeners[key];
+    if (typeof(listener) === 'function')
+      on(target, type, listener);
+  });
+}
+exports.setListeners = setListeners;
diff --git a/toolkit/jetpack/sdk/event/dom.js b/toolkit/jetpack/sdk/event/dom.js
new file mode 100644
index 000000000..da99dec7a
--- /dev/null
+++ b/toolkit/jetpack/sdk/event/dom.js
@@ -0,0 +1,78 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Ci } = require("chrome");
+
+var { emit } = require("./core");
+var { when: unload } = require("../system/unload");
+var listeners = new WeakMap();
+
+const { Cu } = require("chrome");
+const { ShimWaiver } = Cu.import("resource://gre/modules/ShimWaiver.jsm");
+const { ThreadSafeChromeUtils } = Cu.import("resource://gre/modules/Services.jsm", {});
+
+var getWindowFrom = x =>
+                    x instanceof Ci.nsIDOMWindow ? x :
+                    x instanceof Ci.nsIDOMDocument ? x.defaultView :
+                    x instanceof Ci.nsIDOMNode ? x.ownerDocument.defaultView :
+                    null;
+
+function removeFromListeners() {
+  ShimWaiver.getProperty(this, "removeEventListener")("DOMWindowClose", removeFromListeners);
+  for (let cleaner of listeners.get(this))
+    cleaner();
+
+  listeners.delete(this);
+}
+
+// Simple utility function takes event target, event type and optional
+// `options.capture` and returns node style event stream that emits "data"
+// events every time event of that type occurs on the given `target`.
+function open(target, type, options) {
+  let output = {};
+  let capture = options && options.capture ? true : false;
+  let listener = (event) => emit(output, "data", event);
+
+  // `open` is currently used only on DOM Window objects, however it was made
+  // to be used to any kind of `target` that supports `addEventListener`,
+  // therefore is safer get the `window` from the `target` instead assuming
+  // that `target` is the `window`.
+  let window = getWindowFrom(target);
+
+  // If we're not able to get a `window` from `target`, there is something
+  // wrong. We cannot add listeners that can leak later, or results in
+  // "dead object" exception.
+  // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1001833
+  if (!window)
+    throw new Error("Unable to obtain the owner window from the target given.");
+
+  let cleaners = listeners.get(window);
+  if (!cleaners) {
+    cleaners = [];
+    listeners.set(window, cleaners);
+
+    // We need to remove from our map the `window` once is closed, to prevent
+    // memory leak
+    ShimWaiver.getProperty(window, "addEventListener")("DOMWindowClose", removeFromListeners);
+  }
+
+  cleaners.push(() => ShimWaiver.getProperty(target, "removeEventListener")(type, listener, capture));
+  ShimWaiver.getProperty(target, "addEventListener")(type, listener, capture);
+
+  return output;
+}
+
+unload(() => {
+  let keys = ThreadSafeChromeUtils.nondeterministicGetWeakMapKeys(listeners)
+  for (let window of keys)
+    removeFromListeners.call(window);
+});
+
+exports.open = open;
diff --git a/toolkit/jetpack/sdk/event/target.js b/toolkit/jetpack/sdk/event/target.js
new file mode 100644
index 000000000..3a1f5e5f0
--- /dev/null
+++ b/toolkit/jetpack/sdk/event/target.js
@@ -0,0 +1,74 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { on, once, off, setListeners } = require('./core');
+const { method, chainable } = require('../lang/functional/core');
+const { Class } = require('../core/heritage');
+
+/**
+ * `EventTarget` is an exemplar for creating an objects that can be used to
+ * add / remove event listeners on them. Events on these objects may be emitted
+ * via `emit` function exported by 'event/core' module.
+ */
+const EventTarget = Class({
+  /**
+   * Method initializes `this` event source. It goes through properties of a
+   * given `options` and registers listeners for the ones that look like an
+   * event listeners.
+   */
+  /**
+   * Method initializes `this` event source. It goes through properties of a
+   * given `options` and registers listeners for the ones that look like an
+   * event listeners.
+   */
+  initialize: function initialize(options) {
+    setListeners(this, options);
+  },
+  /**
+   * Registers an event `listener` that is called every time events of
+   * specified `type` are emitted.
+   * @param {String} type
+   *    The type of event.
+   * @param {Function} listener
+   *    The listener function that processes the event.
+   * @example
+   *      worker.on('message', function (data) {
+   *        console.log('data received: ' + data)
+   *      })
+   */
+  on: chainable(method(on)),
+  /**
+   * Registers an event `listener` that is called once the next time an event
+   * of the specified `type` is emitted.
+   * @param {String} type
+   *    The type of the event.
+   * @param {Function} listener
+   *    The listener function that processes the event.
+   */
+  once: chainable(method(once)),
+  /**
+   * Removes an event `listener` for the given event `type`.
+   * @param {String} type
+   *    The type of event.
+   * @param {Function} listener
+   *    The listener function that processes the event.
+   */
+  removeListener: function removeListener(type, listener) {
+    // Note: We can't just wrap `off` in `method` as we do it for other methods
+    // cause skipping a second or third argument will behave very differently
+    // than intended. This way we make sure all arguments are passed and only
+    // one listener is removed at most.
+    off(this, type, listener);
+    return this;
+  },
+  // but we can wrap `off` here, as the semantics are the same
+  off: chainable(method(off))
+
+});
+exports.EventTarget = EventTarget;
diff --git a/toolkit/jetpack/sdk/event/utils.js b/toolkit/jetpack/sdk/event/utils.js
new file mode 100644
index 000000000..f193b6785
--- /dev/null
+++ b/toolkit/jetpack/sdk/event/utils.js
@@ -0,0 +1,328 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+var { emit, on, once, off, EVENT_TYPE_PATTERN } = require("./core");
+const { Cu } = require("chrome");
+
+// This module provides set of high order function for working with event
+// streams (streams in a NodeJS style that dispatch data, end and error
+// events).
+
+// Function takes a `target` object and returns set of implicit references
+// (non property references) it keeps. This basically allows defining
+// references between objects without storing the explicitly. See transform for
+// more details.
+var refs = (function() {
+  let refSets = new WeakMap();
+  return function refs(target) {
+    if (!refSets.has(target)) refSets.set(target, new Set());
+    return refSets.get(target);
+  };
+})();
+
+function transform(input, f) {
+  let output = new Output();
+
+  // Since event listeners don't prevent `input` to be GC-ed we wanna presrve
+  // it until `output` can be GC-ed. There for we add implicit reference which
+  // is removed once `input` ends.
+  refs(output).add(input);
+
+  const next = data => receive(output, data);
+  once(output, "start", () => start(input));
+  on(input, "error", error => emit(output, "error", error));
+  on(input, "end", function() {
+    refs(output).delete(input);
+    end(output);
+  });
+  on(input, "data", data => f(data, next));
+  return output;
+}
+
+// High order event transformation function that takes `input` event channel
+// and returns transformation containing only events on which `p` predicate
+// returns `true`.
+function filter(input, predicate) {
+  return transform(input, function(data, next) {
+    if (predicate(data))
+      next(data);
+  });
+}
+exports.filter = filter;
+
+// High order function that takes `input` and returns input of it's values
+// mapped via given `f` function.
+const map = (input, f) => transform(input, (data, next) => next(f(data)));
+exports.map = map;
+
+// High order function that takes `input` stream of streams and merges them
+// into single event stream. Like flatten but time based rather than order
+// based.
+function merge(inputs) {
+  let output = new Output();
+  let open = 1;
+  let state = [];
+  output.state = state;
+  refs(output).add(inputs);
+
+  function end(input) {
+    open = open - 1;
+    refs(output).delete(input);
+    if (open === 0) emit(output, "end");
+  }
+  const error = e => emit(output, "error", e);
+  function forward(input) {
+    state.push(input);
+    open = open + 1;
+    on(input, "end", () => end(input));
+    on(input, "error", error);
+    on(input, "data", data => emit(output, "data", data));
+  }
+
+  // If `inputs` is an array treat it as a stream.
+  if (Array.isArray(inputs)) {
+    inputs.forEach(forward);
+    end(inputs);
+  }
+  else {
+    on(inputs, "end", () => end(inputs));
+    on(inputs, "error", error);
+    on(inputs, "data", forward);
+  }
+
+  return output;
+}
+exports.merge = merge;
+
+const expand = (inputs, f) => merge(map(inputs, f));
+exports.expand = expand;
+
+const pipe = (from, to) => on(from, "*", emit.bind(emit, to));
+exports.pipe = pipe;
+
+
+// Shim signal APIs so other modules can be used as is.
+const receive = (input, message) => {
+  if (input[receive])
+    input[receive](input, message);
+  else
+    emit(input, "data", message);
+
+  // Ideally our input will extend Input and already provide a weak value
+  // getter.  If not, opportunistically shim the weak value getter on
+  // other types passed as the input.
+  if (!("value" in input)) {
+    Object.defineProperty(input, "value", WeakValueGetterSetter);
+  }
+  input.value = message;
+};
+receive.toString = () => "@@receive";
+exports.receive = receive;
+exports.send = receive;
+
+const end = input => {
+  if (input[end])
+    input[end](input);
+  else
+    emit(input, "end", input);
+};
+end.toString = () => "@@end";
+exports.end = end;
+
+const stop = input => {
+  if (input[stop])
+    input[stop](input);
+  else
+    emit(input, "stop", input);
+};
+stop.toString = () => "@@stop";
+exports.stop = stop;
+
+const start = input => {
+  if (input[start])
+    input[start](input);
+  else
+    emit(input, "start", input);
+};
+start.toString = () => "@@start";
+exports.start = start;
+
+const lift = (step, ...inputs) => {
+  let args = null;
+  let opened = inputs.length;
+  let started = false;
+  const output = new Output();
+  const init = () => {
+    args = [...inputs.map(input => input.value)];
+    output.value = step(...args);
+  };
+
+  inputs.forEach((input, index) => {
+    on(input, "data", data => {
+      args[index] = data;
+      receive(output, step(...args));
+    });
+    on(input, "end", () => {
+      opened = opened - 1;
+      if (opened <= 0)
+        end(output);
+    });
+  });
+
+  once(output, "start", () => {
+    inputs.forEach(start);
+    init();
+  });
+
+  init();
+
+  return output;
+};
+exports.lift = lift;
+
+const merges = inputs => {
+  let opened = inputs.length;
+  let output = new Output();
+  output.value = inputs[0].value;
+  inputs.forEach((input, index) => {
+    on(input, "data", data => receive(output, data));
+    on(input, "end", () => {
+      opened = opened - 1;
+      if (opened <= 0)
+        end(output);
+    });
+  });
+
+  once(output, "start", () => {
+    inputs.forEach(start);
+    output.value = inputs[0].value;
+  });
+
+  return output;
+};
+exports.merges = merges;
+
+const foldp = (step, initial, input) => {
+  let output = map(input, x => step(output.value, x));
+  output.value = initial;
+  return output;
+};
+exports.foldp = foldp;
+
+const keepIf = (p, base, input) => {
+  let output = filter(input, p);
+  output.value = base;
+  return output;
+};
+exports.keepIf = keepIf;
+
+function Input() {}
+Input.start = input => emit(input, "start", input);
+Input.prototype.start = Input.start;
+
+Input.end = input => {
+  emit(input, "end", input);
+  stop(input);
+};
+Input.prototype[end] = Input.end;
+
+// The event channel system caches the last event seen as input.value.
+// Unfortunately, if the last event is a DOM object this is a great way
+// leak windows.  Mitigate this by storing input.value using a weak
+// reference.  This allows the system to work for normal event processing
+// while also allowing the objects to be reclaimed.  It means, however,
+// input.value cannot be accessed long after the event was dispatched.
+const WeakValueGetterSetter = {
+  get: function() {
+    return this._weakValue ? this._weakValue.get() : this._simpleValue
+  },
+  set: function(v) {
+    if (v && typeof v === "object") {
+      try {
+        // Try to set a weak reference.  This can throw for some values.
+        // For example, if the value is a native object that does not
+        // implement nsISupportsWeakReference.
+        this._weakValue = Cu.getWeakReference(v)
+        this._simpleValue = undefined;
+        return;
+      } catch (e) {
+        // Do nothing.  Fall through to setting _simpleValue below.
+      }
+    }
+    this._simpleValue = v;
+    this._weakValue = undefined;
+  },
+}
+Object.defineProperty(Input.prototype, "value", WeakValueGetterSetter);
+
+exports.Input = Input;
+
+// Define an Output type with a weak value getter for the transformation
+// functions that produce new channels.
+function Output() { }
+Object.defineProperty(Output.prototype, "value", WeakValueGetterSetter);
+exports.Output = Output;
+
+const $source = "@@source";
+const $outputs = "@@outputs";
+exports.outputs = $outputs;
+
+// NOTE: Passing DOM objects through a Reactor can cause them to leak
+// when they get cached in this.value.  We cannot use a weak reference
+// in this case because the Reactor design expects to always have both the
+// past and present value.  If we allow past values to be collected the
+// system breaks.
+
+function Reactor(options={}) {
+  const {onStep, onStart, onEnd} = options;
+  if (onStep)
+    this.onStep = onStep;
+  if (onStart)
+    this.onStart = onStart;
+  if (onEnd)
+    this.onEnd = onEnd;
+}
+Reactor.prototype.onStep = _ => void(0);
+Reactor.prototype.onStart = _ => void(0);
+Reactor.prototype.onEnd = _ => void(0);
+Reactor.prototype.onNext = function(present, past) {
+  this.value = present;
+  this.onStep(present, past);
+};
+Reactor.prototype.run = function(input) {
+  on(input, "data", message => this.onNext(message, input.value));
+  on(input, "end", () => this.onEnd(input.value));
+  start(input);
+  this.value = input.value;
+  this.onStart(input.value);
+};
+exports.Reactor = Reactor;
+
+/**
+ * Takes an object used as options with potential keys like 'onMessage',
+ * used to be called `require('sdk/event/core').setListeners` on.
+ * This strips all keys that would trigger a listener to be set.
+ *
+ * @params {Object} object
+ * @return {Object}
+ */
+
+function stripListeners (object) {
+  return Object.keys(object || {}).reduce((agg, key) => {
+    if (!EVENT_TYPE_PATTERN.test(key))
+      agg[key] = object[key];
+    return agg;
+  }, {});
+}
+exports.stripListeners = stripListeners;
+
+const when = (target, type) => new Promise(resolve => {
+  once(target, type, resolve);
+});
+exports.when = when;
diff --git a/toolkit/jetpack/sdk/frame/hidden-frame.js b/toolkit/jetpack/sdk/frame/hidden-frame.js
new file mode 100644
index 000000000..97e0b7974
--- /dev/null
+++ b/toolkit/jetpack/sdk/frame/hidden-frame.js
@@ -0,0 +1,115 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci } = require("chrome");
+const { Class } = require("../core/heritage");
+const { List, addListItem, removeListItem } = require("../util/list");
+const { EventTarget } = require("../event/target");
+const { emit } = require("../event/core");
+const { create: makeFrame } = require("./utils");
+const { defer } = require("../core/promise");
+const { when: unload } = require("../system/unload");
+const { validateOptions, getTypeOf } = require("../deprecated/api-utils");
+const { window } = require("../addon/window");
+const { fromIterator } = require("../util/array");
+
+// This cache is used to access friend properties between functions
+// without exposing them on the public API.
+var cache = new Set();
+var elements = new WeakMap();
+
+function contentLoaded(target) {
+  var deferred = defer();
+  target.addEventListener("DOMContentLoaded", function DOMContentLoaded(event) {
+    // "DOMContentLoaded" events from nested frames propagate up to target,
+    // ignore events unless it's DOMContentLoaded for the given target.
+    if (event.target === target || event.target === target.contentDocument) {
+      target.removeEventListener("DOMContentLoaded", DOMContentLoaded, false);
+      deferred.resolve(target);
+    }
+  }, false);
+  return deferred.promise;
+}
+
+function FrameOptions(options) {
+  options = options || {}
+  return validateOptions(options, FrameOptions.validator);
+}
+FrameOptions.validator = {
+  onReady: {
+    is: ["undefined", "function", "array"],
+    ok: function(v) {
+      if (getTypeOf(v) === "array") {
+        // make sure every item is a function
+        return v.every(item => typeof(item) === "function")
+      }
+      return true;
+    }
+  },
+  onUnload: {
+    is: ["undefined", "function"]
+  }
+};
+
+var HiddenFrame = Class({
+  extends: EventTarget,
+  initialize: function initialize(options) {
+    options = FrameOptions(options);
+    EventTarget.prototype.initialize.call(this, options);
+  },
+  get element() {
+    return elements.get(this);
+  },
+  toString: function toString() {
+    return "[object Frame]"
+  }
+});
+exports.HiddenFrame = HiddenFrame
+
+function addHidenFrame(frame) {
+  if (!(frame instanceof HiddenFrame))
+    throw Error("The object to be added must be a HiddenFrame.");
+
+  // This instance was already added.
+  if (cache.has(frame)) return frame;
+  else cache.add(frame);
+
+  let element = makeFrame(window.document, {
+    nodeName: "iframe",
+    type: "content",
+    allowJavascript: true,
+    allowPlugins: true,
+    allowAuth: true,
+  });
+  elements.set(frame, element);
+
+  contentLoaded(element).then(function onFrameReady(element) {
+    emit(frame, "ready");
+  }, console.exception);
+
+  return frame;
+}
+exports.add = addHidenFrame
+
+function removeHiddenFrame(frame) {
+  if (!(frame instanceof HiddenFrame))
+    throw Error("The object to be removed must be a HiddenFrame.");
+
+  if (!cache.has(frame)) return;
+
+  // Remove from cache before calling in order to avoid loop
+  cache.delete(frame);
+  emit(frame, "unload")
+  let element = frame.element
+  if (element) element.parentNode.removeChild(element)
+}
+exports.remove = removeHiddenFrame;
+
+unload(() => fromIterator(cache).forEach(removeHiddenFrame));
diff --git a/toolkit/jetpack/sdk/frame/utils.js b/toolkit/jetpack/sdk/frame/utils.js
new file mode 100644
index 000000000..d9fccec4d
--- /dev/null
+++ b/toolkit/jetpack/sdk/frame/utils.js
@@ -0,0 +1,94 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Ci } = require("chrome");
+const XUL = 'http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul';
+
+function eventTarget(frame) {
+  return getDocShell(frame).chromeEventHandler;
+}
+exports.eventTarget = eventTarget;
+
+function getDocShell(frame) {
+  let { frameLoader } = frame.QueryInterface(Ci.nsIFrameLoaderOwner);
+  return frameLoader && frameLoader.docShell;
+}
+exports.getDocShell = getDocShell;
+
+/**
+ * Creates a XUL `browser` element in a privileged document.
+ * @params {nsIDOMDocument} document
+ * @params {String} options.type
+ *    By default is 'content' for possible values see:
+ *    https://developer.mozilla.org/en/XUL/iframe#a-browser.type
+ * @params {String} options.uri
+ *    URI of the document to be loaded into created frame.
+ * @params {Boolean} options.remote
+ *    If `true` separate process will be used for this frame, also in such
+ *    case all the following options are ignored.
+ * @params {Boolean} options.allowAuth
+ *    Whether to allow auth dialogs. Defaults to `false`.
+ * @params {Boolean} options.allowJavascript
+ *    Whether to allow Javascript execution. Defaults to `false`.
+ * @params {Boolean} options.allowPlugins
+ *    Whether to allow plugin execution. Defaults to `false`.
+ */
+function create(target, options) {
+  target = target instanceof Ci.nsIDOMDocument ? target.documentElement :
+           target instanceof Ci.nsIDOMWindow ? target.document.documentElement :
+           target;
+  options = options || {};
+  let remote = options.remote || false;
+  let namespaceURI = options.namespaceURI || XUL;
+  let isXUL = namespaceURI === XUL;
+  let nodeName = isXUL && options.browser ? 'browser' : 'iframe';
+  let document = target.ownerDocument;
+
+  let frame = document.createElementNS(namespaceURI, nodeName);
+  // Type="content" is mandatory to enable stuff here:
+  // http://mxr.mozilla.org/mozilla-central/source/content/base/src/nsFrameLoader.cpp#1776
+  frame.setAttribute('type', options.type || 'content');
+  frame.setAttribute('src', options.uri || 'about:blank');
+
+  // Must set the remote attribute before attaching the frame to the document
+  if (remote && isXUL) {
+    // We remove XBL binding to avoid execution of code that is not going to
+    // work because browser has no docShell attribute in remote mode
+    // (for example)
+    frame.setAttribute('style', '-moz-binding: none;');
+    frame.setAttribute('remote', 'true');
+  }
+
+  target.appendChild(frame);
+
+  // Load in separate process if `options.remote` is `true`.
+  // http://mxr.mozilla.org/mozilla-central/source/content/base/src/nsFrameLoader.cpp#1347
+  if (remote && !isXUL) {
+    frame.QueryInterface(Ci.nsIMozBrowserFrame);
+    frame.createRemoteFrameLoader(null);
+  }
+
+  // If browser is remote it won't have a `docShell`.
+  if (!remote) {
+    let docShell = getDocShell(frame);
+    docShell.allowAuth = options.allowAuth || false;
+    docShell.allowJavascript = options.allowJavascript || false;
+    docShell.allowPlugins = options.allowPlugins || false;
+    docShell.allowWindowControl = options.allowWindowControl || false;
+  }
+
+  return frame;
+}
+exports.create = create;
+
+function swapFrameLoaders(from, to) {
+  return from.QueryInterface(Ci.nsIFrameLoaderOwner).swapFrameLoaders(to);
+}
+exports.swapFrameLoaders = swapFrameLoaders;
diff --git a/toolkit/jetpack/sdk/fs/path.js b/toolkit/jetpack/sdk/fs/path.js
new file mode 100644
index 000000000..4474b2b4a
--- /dev/null
+++ b/toolkit/jetpack/sdk/fs/path.js
@@ -0,0 +1,500 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// Adapted version of:
+// https://github.com/joyent/node/blob/v0.11.3/lib/path.js
+
+// Shim process global from node.
+var process = Object.create(require('../system'));
+process.cwd = process.pathFor.bind(process, 'CurProcD');
+
+// Update original check in node `process.platform === 'win32'` since in SDK it's `winnt`.
+var isWindows = process.platform.indexOf('win') === 0;
+
+
+
+// resolves . and .. elements in a path array with directory names there
+// must be no slashes, empty elements, or device names (c:\) in the array
+// (so also no leading and trailing slashes - it does not distinguish
+// relative and absolute paths)
+function normalizeArray(parts, allowAboveRoot) {
+  // if the path tries to go above the root, `up` ends up > 0
+  var up = 0;
+  for (var i = parts.length - 1; i >= 0; i--) {
+    var last = parts[i];
+    if (last === '.') {
+      parts.splice(i, 1);
+    } else if (last === '..') {
+      parts.splice(i, 1);
+      up++;
+    } else if (up) {
+      parts.splice(i, 1);
+      up--;
+    }
+  }
+
+  // if the path is allowed to go above the root, restore leading ..s
+  if (allowAboveRoot) {
+    for (; up--; up) {
+      parts.unshift('..');
+    }
+  }
+
+  return parts;
+}
+
+
+if (isWindows) {
+  // Regex to split a windows path into three parts: [*, device, slash,
+  // tail] windows-only
+  var splitDeviceRe =
+      /^([a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/]+[^\\\/]+)?([\\\/])?([\s\S]*?)$/;
+
+  // Regex to split the tail part of the above into [*, dir, basename, ext]
+  var splitTailRe =
+      /^([\s\S]*?)((?:\.{1,2}|[^\\\/]+?|)(\.[^.\/\\]*|))(?:[\\\/]*)$/;
+
+  // Function to split a filename into [root, dir, basename, ext]
+  // windows version
+  var splitPath = function(filename) {
+    // Separate device+slash from tail
+    var result = splitDeviceRe.exec(filename),
+        device = (result[1] || '') + (result[2] || ''),
+        tail = result[3] || '';
+    // Split the tail into dir, basename and extension
+    var result2 = splitTailRe.exec(tail),
+        dir = result2[1],
+        basename = result2[2],
+        ext = result2[3];
+    return [device, dir, basename, ext];
+  };
+
+  var normalizeUNCRoot = function(device) {
+    return '\\\\' + device.replace(/^[\\\/]+/, '').replace(/[\\\/]+/g, '\\');
+  };
+
+  // path.resolve([from ...], to)
+  // windows version
+  exports.resolve = function() {
+    var resolvedDevice = '',
+        resolvedTail = '',
+        resolvedAbsolute = false;
+
+    for (var i = arguments.length - 1; i >= -1; i--) {
+      var path;
+      if (i >= 0) {
+        path = arguments[i];
+      } else if (!resolvedDevice) {
+        path = process.cwd();
+      } else {
+        // Windows has the concept of drive-specific current working
+        // directories. If we've resolved a drive letter but not yet an
+        // absolute path, get cwd for that drive. We're sure the device is not
+        // an unc path at this points, because unc paths are always absolute.
+        path = process.env['=' + resolvedDevice];
+        // Verify that a drive-local cwd was found and that it actually points
+        // to our drive. If not, default to the drive's root.
+        if (!path || path.substr(0, 3).toLowerCase() !==
+            resolvedDevice.toLowerCase() + '\\') {
+          path = resolvedDevice + '\\';
+        }
+      }
+
+      // Skip empty and invalid entries
+      if (typeof path !== 'string') {
+        throw new TypeError('Arguments to path.resolve must be strings');
+      } else if (!path) {
+        continue;
+      }
+
+      var result = splitDeviceRe.exec(path),
+          device = result[1] || '',
+          isUnc = device && device.charAt(1) !== ':',
+          isAbsolute = exports.isAbsolute(path),
+          tail = result[3];
+
+      if (device &&
+          resolvedDevice &&
+          device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+        // This path points to another device so it is not applicable
+        continue;
+      }
+
+      if (!resolvedDevice) {
+        resolvedDevice = device;
+      }
+      if (!resolvedAbsolute) {
+        resolvedTail = tail + '\\' + resolvedTail;
+        resolvedAbsolute = isAbsolute;
+      }
+
+      if (resolvedDevice && resolvedAbsolute) {
+        break;
+      }
+    }
+
+    // Convert slashes to backslashes when `resolvedDevice` points to an UNC
+    // root. Also squash multiple slashes into a single one where appropriate.
+    if (isUnc) {
+      resolvedDevice = normalizeUNCRoot(resolvedDevice);
+    }
+
+    // At this point the path should be resolved to a full absolute path,
+    // but handle relative paths to be safe (might happen when process.cwd()
+    // fails)
+
+    // Normalize the tail path
+
+    function f(p) {
+      return !!p;
+    }
+
+    resolvedTail = normalizeArray(resolvedTail.split(/[\\\/]+/).filter(f),
+                                  !resolvedAbsolute).join('\\');
+
+    return (resolvedDevice + (resolvedAbsolute ? '\\' : '') + resolvedTail) ||
+           '.';
+  };
+
+  // windows version
+  exports.normalize = function(path) {
+    var result = splitDeviceRe.exec(path),
+        device = result[1] || '',
+        isUnc = device && device.charAt(1) !== ':',
+        isAbsolute = exports.isAbsolute(path),
+        tail = result[3],
+        trailingSlash = /[\\\/]$/.test(tail);
+
+    // If device is a drive letter, we'll normalize to lower case.
+    if (device && device.charAt(1) === ':') {
+      device = device[0].toLowerCase() + device.substr(1);
+    }
+
+    // Normalize the tail path
+    tail = normalizeArray(tail.split(/[\\\/]+/).filter(function(p) {
+      return !!p;
+    }), !isAbsolute).join('\\');
+
+    if (!tail && !isAbsolute) {
+      tail = '.';
+    }
+    if (tail && trailingSlash) {
+      tail += '\\';
+    }
+
+    // Convert slashes to backslashes when `device` points to an UNC root.
+    // Also squash multiple slashes into a single one where appropriate.
+    if (isUnc) {
+      device = normalizeUNCRoot(device);
+    }
+
+    return device + (isAbsolute ? '\\' : '') + tail;
+  };
+
+  // windows version
+  exports.isAbsolute = function(path) {
+    var result = splitDeviceRe.exec(path),
+        device = result[1] || '',
+        isUnc = device && device.charAt(1) !== ':';
+    // UNC paths are always absolute
+    return !!result[2] || isUnc;
+  };
+
+  // windows version
+  exports.join = function() {
+    function f(p) {
+      if (typeof p !== 'string') {
+        throw new TypeError('Arguments to path.join must be strings');
+      }
+      return p;
+    }
+
+    var paths = Array.prototype.filter.call(arguments, f);
+    var joined = paths.join('\\');
+
+    // Make sure that the joined path doesn't start with two slashes, because
+    // normalize() will mistake it for an UNC path then.
+    //
+    // This step is skipped when it is very clear that the user actually
+    // intended to point at an UNC path. This is assumed when the first
+    // non-empty string arguments starts with exactly two slashes followed by
+    // at least one more non-slash character.
+    //
+    // Note that for normalize() to treat a path as an UNC path it needs to
+    // have at least 2 components, so we don't filter for that here.
+    // This means that the user can use join to construct UNC paths from
+    // a server name and a share name; for example:
+    //   path.join('//server', 'share') -> '\\\\server\\share\')
+    if (!/^[\\\/]{2}[^\\\/]/.test(paths[0])) {
+      joined = joined.replace(/^[\\\/]{2,}/, '\\');
+    }
+
+    return exports.normalize(joined);
+  };
+
+  // path.relative(from, to)
+  // it will solve the relative path from 'from' to 'to', for instance:
+  // from = 'C:\\orandea\\test\\aaa'
+  // to = 'C:\\orandea\\impl\\bbb'
+  // The output of the function should be: '..\\..\\impl\\bbb'
+  // windows version
+  exports.relative = function(from, to) {
+    from = exports.resolve(from);
+    to = exports.resolve(to);
+
+    // windows is not case sensitive
+    var lowerFrom = from.toLowerCase();
+    var lowerTo = to.toLowerCase();
+
+    function trim(arr) {
+      var start = 0;
+      for (; start < arr.length; start++) {
+        if (arr[start] !== '') break;
+      }
+
+      var end = arr.length - 1;
+      for (; end >= 0; end--) {
+        if (arr[end] !== '') break;
+      }
+
+      if (start > end) return [];
+      return arr.slice(start, end - start + 1);
+    }
+
+    var toParts = trim(to.split('\\'));
+
+    var lowerFromParts = trim(lowerFrom.split('\\'));
+    var lowerToParts = trim(lowerTo.split('\\'));
+
+    var length = Math.min(lowerFromParts.length, lowerToParts.length);
+    var samePartsLength = length;
+    for (var i = 0; i < length; i++) {
+      if (lowerFromParts[i] !== lowerToParts[i]) {
+        samePartsLength = i;
+        break;
+      }
+    }
+
+    if (samePartsLength == 0) {
+      return to;
+    }
+
+    var outputParts = [];
+    for (var i = samePartsLength; i < lowerFromParts.length; i++) {
+      outputParts.push('..');
+    }
+
+    outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+    return outputParts.join('\\');
+  };
+
+  exports.sep = '\\';
+  exports.delimiter = ';';
+
+} else /* posix */ {
+
+  // Split a filename into [root, dir, basename, ext], unix version
+  // 'root' is just a slash, or nothing.
+  var splitPathRe =
+      /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+  var splitPath = function(filename) {
+    return splitPathRe.exec(filename).slice(1);
+  };
+
+  // path.resolve([from ...], to)
+  // posix version
+  exports.resolve = function() {
+    var resolvedPath = '',
+        resolvedAbsolute = false;
+
+    for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+      var path = (i >= 0) ? arguments[i] : process.cwd();
+
+      // Skip empty and invalid entries
+      if (typeof path !== 'string') {
+        throw new TypeError('Arguments to path.resolve must be strings');
+      } else if (!path) {
+        continue;
+      }
+
+      resolvedPath = path + '/' + resolvedPath;
+      resolvedAbsolute = path.charAt(0) === '/';
+    }
+
+    // At this point the path should be resolved to a full absolute path, but
+    // handle relative paths to be safe (might happen when process.cwd() fails)
+
+    // Normalize the path
+    resolvedPath = normalizeArray(resolvedPath.split('/').filter(function(p) {
+      return !!p;
+    }), !resolvedAbsolute).join('/');
+
+    return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
+  };
+
+  // path.normalize(path)
+  // posix version
+  exports.normalize = function(path) {
+    var isAbsolute = exports.isAbsolute(path),
+        trailingSlash = path.substr(-1) === '/';
+
+    // Normalize the path
+    path = normalizeArray(path.split('/').filter(function(p) {
+      return !!p;
+    }), !isAbsolute).join('/');
+
+    if (!path && !isAbsolute) {
+      path = '.';
+    }
+    if (path && trailingSlash) {
+      path += '/';
+    }
+
+    return (isAbsolute ? '/' : '') + path;
+  };
+
+  // posix version
+  exports.isAbsolute = function(path) {
+    return path.charAt(0) === '/';
+  };
+
+  // posix version
+  exports.join = function() {
+    var paths = Array.prototype.slice.call(arguments, 0);
+    return exports.normalize(paths.filter(function(p, index) {
+      if (typeof p !== 'string') {
+        throw new TypeError('Arguments to path.join must be strings');
+      }
+      return p;
+    }).join('/'));
+  };
+
+
+  // path.relative(from, to)
+  // posix version
+  exports.relative = function(from, to) {
+    from = exports.resolve(from).substr(1);
+    to = exports.resolve(to).substr(1);
+
+    function trim(arr) {
+      var start = 0;
+      for (; start < arr.length; start++) {
+        if (arr[start] !== '') break;
+      }
+
+      var end = arr.length - 1;
+      for (; end >= 0; end--) {
+        if (arr[end] !== '') break;
+      }
+
+      if (start > end) return [];
+      return arr.slice(start, end - start + 1);
+    }
+
+    var fromParts = trim(from.split('/'));
+    var toParts = trim(to.split('/'));
+
+    var length = Math.min(fromParts.length, toParts.length);
+    var samePartsLength = length;
+    for (var i = 0; i < length; i++) {
+      if (fromParts[i] !== toParts[i]) {
+        samePartsLength = i;
+        break;
+      }
+    }
+
+    var outputParts = [];
+    for (var i = samePartsLength; i < fromParts.length; i++) {
+      outputParts.push('..');
+    }
+
+    outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+    return outputParts.join('/');
+  };
+
+  exports.sep = '/';
+  exports.delimiter = ':';
+}
+
+exports.dirname = function(path) {
+  var result = splitPath(path),
+      root = result[0],
+      dir = result[1];
+
+  if (!root && !dir) {
+    // No dirname whatsoever
+    return '.';
+  }
+
+  if (dir) {
+    // It has a dirname, strip trailing slash
+    dir = dir.substr(0, dir.length - 1);
+  }
+
+  return root + dir;
+};
+
+
+exports.basename = function(path, ext) {
+  var f = splitPath(path)[2];
+  // TODO: make this comparison case-insensitive on windows?
+  if (ext && f.substr(-1 * ext.length) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+};
+
+
+exports.extname = function(path) {
+  return splitPath(path)[3];
+};
+
+if (isWindows) {
+  exports._makeLong = function(path) {
+    // Note: this will *probably* throw somewhere.
+    if (typeof path !== 'string')
+      return path;
+
+    if (!path) {
+      return '';
+    }
+
+    var resolvedPath = exports.resolve(path);
+
+    if (/^[a-zA-Z]\:\\/.test(resolvedPath)) {
+      // path is local filesystem path, which needs to be converted
+      // to long UNC path.
+      return '\\\\?\\' + resolvedPath;
+    } else if (/^\\\\[^?.]/.test(resolvedPath)) {
+      // path is network UNC path, which needs to be converted
+      // to long UNC path.
+      return '\\\\?\\UNC\\' + resolvedPath.substring(2);
+    }
+
+    return path;
+  };
+} else {
+  exports._makeLong = function(path) {
+    return path;
+  };
+}
\ No newline at end of file
diff --git a/toolkit/jetpack/sdk/hotkeys.js b/toolkit/jetpack/sdk/hotkeys.js
new file mode 100644
index 000000000..00081455e
--- /dev/null
+++ b/toolkit/jetpack/sdk/hotkeys.js
@@ -0,0 +1,40 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const INVALID_HOTKEY = "Hotkey must have at least one modifier.";
+
+const { toJSON: jsonify, toString: stringify,
+        isFunctionKey } = require("./keyboard/utils");
+const { register, unregister } = require("./keyboard/hotkeys");
+
+const Hotkey = exports.Hotkey = function Hotkey(options) {
+  if (!(this instanceof Hotkey))
+    return new Hotkey(options);
+
+  // Parsing key combination string.
+  let hotkey = jsonify(options.combo);
+  if (!isFunctionKey(hotkey.key) && !hotkey.modifiers.length) {
+    throw new TypeError(INVALID_HOTKEY);
+  }
+
+  this.onPress = options.onPress && options.onPress.bind(this);
+  this.toString = stringify.bind(null, hotkey);
+  // Registering listener on keyboard combination enclosed by this hotkey.
+  // Please note that `this.toString()` is a normalized version of
+  // `options.combination` where order of modifiers is sorted and `accel` is
+  // replaced with platform specific key.
+  register(this.toString(), this.onPress);
+  // We freeze instance before returning it in order to make it's properties
+  // read-only.
+  return Object.freeze(this);
+};
+Hotkey.prototype.destroy = function destroy() {
+  unregister(this.toString(), this.onPress);
+};
diff --git a/toolkit/jetpack/sdk/indexed-db.js b/toolkit/jetpack/sdk/indexed-db.js
new file mode 100644
index 000000000..d4d166c02
--- /dev/null
+++ b/toolkit/jetpack/sdk/indexed-db.js
@@ -0,0 +1,79 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci } = require("chrome");
+const { id } = require("./self");
+
+// placeholder, copied from bootstrap.js
+var sanitizeId = function(id){
+  let uuidRe =
+    /^\{([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\}$/;
+
+  let domain = id.
+    toLowerCase().
+    replace(/@/g, "-at-").
+    replace(/\./g, "-dot-").
+    replace(uuidRe, "$1");
+
+  return domain
+};
+
+const PSEUDOURI = "indexeddb://" + sanitizeId(id) // https://bugzilla.mozilla.org/show_bug.cgi?id=779197
+
+// Use XPCOM because `require("./url").URL` doesn't expose the raw uri object.
+var principaluri = Cc["@mozilla.org/network/io-service;1"].
+              getService(Ci.nsIIOService).
+              newURI(PSEUDOURI, null, null);
+
+var ssm = Cc["@mozilla.org/scriptsecuritymanager;1"]
+            .getService(Ci.nsIScriptSecurityManager);
+var principal = ssm.createCodebasePrincipal(principaluri, {});
+
+function toArray(args) {
+  return Array.prototype.slice.call(args);
+}
+
+function openInternal(args, forPrincipal, deleting) {
+  if (forPrincipal) {
+    args = toArray(args);
+  } else {
+    args = [principal].concat(toArray(args));
+  }
+  if (args.length == 2) {
+    args.push({ storage: "persistent" });
+  } else if (!deleting && args.length >= 3 && typeof args[2] === "number") {
+    args[2] = { version: args[2], storage: "persistent" };
+  }
+
+  if (deleting) {
+    return indexedDB.deleteForPrincipal.apply(indexedDB, args);
+  }
+
+  return indexedDB.openForPrincipal.apply(indexedDB, args);
+}
+
+exports.indexedDB = Object.freeze({
+  open: function () {
+    return openInternal(arguments, false, false);
+  },
+  deleteDatabase: function () {
+    return openInternal(arguments, false, true);
+  },
+  openForPrincipal: function () {
+    return openInternal(arguments, true, false);
+  },
+  deleteForPrincipal: function () {
+    return openInternal(arguments, true, true);
+  },
+  cmp: indexedDB.cmp.bind(indexedDB)
+});
+
+exports.IDBKeyRange = IDBKeyRange;
+exports.DOMException = Ci.nsIDOMDOMException;
diff --git a/toolkit/jetpack/sdk/input/browser.js b/toolkit/jetpack/sdk/input/browser.js
new file mode 100644
index 000000000..daea875bf
--- /dev/null
+++ b/toolkit/jetpack/sdk/input/browser.js
@@ -0,0 +1,73 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { windows, isBrowser, isInteractive, isDocumentLoaded,
+        getOuterId } = require("../window/utils");
+const { InputPort } = require("./system");
+const { lift, merges, foldp, keepIf, start, Input } = require("../event/utils");
+const { patch } = require("diffpatcher/index");
+const { Sequence, seq, filter, object, pairs } = require("../util/sequence");
+
+
+// Create lazy iterators from the regular arrays, although
+// once https://github.com/mozilla/addon-sdk/pull/1314 lands
+// `windows` will be transforme to lazy iterators.
+// When iterated over belowe sequences items will represent
+// state of windows at the time of iteration.
+const opened = seq(function*() {
+  const items = windows("navigator:browser", {includePrivate: true});
+  for (let item of items) {
+      yield [getOuterId(item), item];
+  }
+});
+const interactive = filter(([_, window]) => isInteractive(window), opened);
+const loaded = filter(([_, window]) => isDocumentLoaded(window), opened);
+
+// Helper function that converts given argument to a delta.
+const Update = window => window && object([getOuterId(window), window]);
+const Delete = window => window && object([getOuterId(window), null]);
+
+
+// Signal represents delta for last top level window close.
+const LastClosed = lift(Delete,
+                        keepIf(isBrowser, null,
+                               new InputPort({topic: "domwindowclosed"})));
+exports.LastClosed = LastClosed;
+
+const windowFor = document => document && document.defaultView;
+
+// Signal represent delta for last top level window document becoming interactive.
+const InteractiveDoc = new InputPort({topic: "chrome-document-interactive"});
+const InteractiveWin = lift(windowFor, InteractiveDoc);
+const LastInteractive = lift(Update, keepIf(isBrowser, null, InteractiveWin));
+exports.LastInteractive = LastInteractive;
+
+// Signal represent delta for last top level window loaded.
+const LoadedDoc = new InputPort({topic: "chrome-document-loaded"});
+const LoadedWin = lift(windowFor, LoadedDoc);
+const LastLoaded = lift(Update, keepIf(isBrowser, null, LoadedWin));
+exports.LastLoaded = LastLoaded;
+
+
+const initialize = input => {
+  if (!input.initialized) {
+    input.value = object(...input.value);
+    Input.start(input);
+    input.initialized = true;
+  }
+};
+
+// Signal represents set of top level interactive windows, updated any
+// time new window becomes interactive or one get's closed.
+const Interactive = foldp(patch, interactive, merges([LastInteractive,
+                                                      LastClosed]));
+Interactive[start] = initialize;
+exports.Interactive = Interactive;
+
+// Signal represents set of top level loaded window, updated any time
+// new window becomes interactive or one get's closed.
+const Loaded = foldp(patch, loaded, merges([LastLoaded, LastClosed]));
+Loaded[start] = initialize;
+exports.Loaded = Loaded;
diff --git a/toolkit/jetpack/sdk/input/customizable-ui.js b/toolkit/jetpack/sdk/input/customizable-ui.js
new file mode 100644
index 000000000..a41d0971a
--- /dev/null
+++ b/toolkit/jetpack/sdk/input/customizable-ui.js
@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Cu } = require("chrome");
+const { CustomizableUI } = Cu.import('resource:///modules/CustomizableUI.jsm', {});
+const { receive } = require("../event/utils");
+const { InputPort } = require("./system");
+const { object} = require("../util/sequence");
+const { getOuterId } = require("../window/utils");
+
+const Input = function() {};
+Input.prototype = Object.create(InputPort.prototype);
+
+Input.prototype.onCustomizeStart = function (window) {
+  receive(this, object([getOuterId(window), true]));
+}
+
+Input.prototype.onCustomizeEnd = function (window) {
+  receive(this, object([getOuterId(window), null]));
+}
+
+Input.prototype.addListener = input => CustomizableUI.addListener(input);
+
+Input.prototype.removeListener = input => CustomizableUI.removeListener(input);
+
+exports.CustomizationInput = Input;
diff --git a/toolkit/jetpack/sdk/input/frame.js b/toolkit/jetpack/sdk/input/frame.js
new file mode 100644
index 000000000..50efaa745
--- /dev/null
+++ b/toolkit/jetpack/sdk/input/frame.js
@@ -0,0 +1,85 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Ci } = require("chrome");
+const { InputPort } = require("./system");
+const { getFrameElement, getOuterId,
+        getOwnerBrowserWindow } = require("../window/utils");
+const { isnt } = require("../lang/functional");
+const { foldp, lift, merges, keepIf } = require("../event/utils");
+const { object } = require("../util/sequence");
+const { compose } = require("../lang/functional");
+const { LastClosed } = require("./browser");
+const { patch } = require("diffpatcher/index");
+
+const Document = Ci.nsIDOMDocument;
+
+const isntNull = isnt(null);
+
+const frameID = frame => frame.id;
+const browserID = compose(getOuterId, getOwnerBrowserWindow);
+
+const isInnerFrame = frame =>
+  frame && frame.hasAttribute("data-is-sdk-inner-frame");
+
+// Utility function that given content window loaded in our frame views returns
+// an actual frame. This basically takes care of fact that actual frame document
+// is loaded in the nested iframe. If content window is not loaded in the nested
+// frame of the frame view it returs null.
+const getFrame = document =>
+  document && document.defaultView && getFrameElement(document.defaultView);
+
+const FrameInput = function(options) {
+  const input = keepIf(isInnerFrame, null,
+                       lift(getFrame, new InputPort(options)));
+  return lift(frame => {
+    if (!frame) return frame;
+    const [id, owner] = [frameID(frame), browserID(frame)];
+    return object([id, {owners: object([owner, options.update])}]);
+  }, input);
+};
+
+const LastLoading = new FrameInput({topic: "document-element-inserted",
+                                    update: {readyState: "loading"}});
+exports.LastLoading = LastLoading;
+
+const LastInteractive = new FrameInput({topic: "content-document-interactive",
+                                        update: {readyState: "interactive"}});
+exports.LastInteractive = LastInteractive;
+
+const LastLoaded = new FrameInput({topic: "content-document-loaded",
+                                   update: {readyState: "complete"}});
+exports.LastLoaded = LastLoaded;
+
+const LastUnloaded = new FrameInput({topic: "content-page-hidden",
+                                    update: null});
+exports.LastUnloaded = LastUnloaded;
+
+// Represents state of SDK frames in form of data structure:
+// {"frame#1": {"id": "frame#1",
+//              "inbox": {"data": "ping",
+//                        "target": {"id": "frame#1", "owner": "outerWindowID#2"},
+//                        "source": {"id": "frame#1"}}
+//              "url": "resource://addon-1/data/index.html",
+//              "owners": {"outerWindowID#1": {"readyState": "loading"},
+//                         "outerWindowID#2": {"readyState": "complete"}}
+//
+//
+//  frame#2: {"id": "frame#2",
+//            "url": "resource://addon-1/data/main.html",
+//            "outbox": {"data": "pong",
+//                       "source": {"id": "frame#2", "owner": "outerWindowID#1"}
+//                       "target": {"id": "frame#2"}}
+//            "owners": {outerWindowID#1: {readyState: "interacitve"}}}}
+const Frames = foldp(patch, {}, merges([
+  LastLoading,
+  LastInteractive,
+  LastLoaded,
+  LastUnloaded,
+  new InputPort({ id: "frame-mailbox" }),
+  new InputPort({ id: "frame-change" }),
+  new InputPort({ id: "frame-changed" })
+]));
+exports.Frames = Frames;
diff --git a/toolkit/jetpack/sdk/input/system.js b/toolkit/jetpack/sdk/input/system.js
new file mode 100644
index 000000000..66bc6daec
--- /dev/null
+++ b/toolkit/jetpack/sdk/input/system.js
@@ -0,0 +1,113 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Cc, Ci, Cr, Cu } = require("chrome");
+const { Input, start, stop, end, receive, outputs } = require("../event/utils");
+const { once, off } = require("../event/core");
+const { id: addonID } = require("../self");
+
+const unloadMessage = require("@loader/unload");
+const observerService = Cc['@mozilla.org/observer-service;1'].
+                          getService(Ci.nsIObserverService);
+const { ShimWaiver } = Cu.import("resource://gre/modules/ShimWaiver.jsm");
+const addObserver = ShimWaiver.getProperty(observerService, "addObserver");
+const removeObserver = ShimWaiver.getProperty(observerService, "removeObserver");
+
+
+const addonUnloadTopic = "sdk:loader:destroy";
+
+const isXrayWrapper = Cu.isXrayWrapper;
+// In the past SDK used to double-wrap notifications dispatched, which
+// made them awkward to use outside of SDK. At present they no longer
+// do that, although we still supported for legacy reasons.
+const isLegacyWrapper = x =>
+    x && x.wrappedJSObject &&
+    "observersModuleSubjectWrapper" in x.wrappedJSObject;
+
+const unwrapLegacy = x => x.wrappedJSObject.object;
+
+// `InputPort` provides a way to create a signal out of the observer
+// notification subject's for the given `topic`. If `options.initial`
+// is provided it is used as initial value otherwise `null` is used.
+// Constructor can be given `options.id` that will be used to create
+// a `topic` which is namespaced to an add-on (this avoids conflicts
+// when multiple add-on are used, although in a future host probably
+// should just be shared across add-ons). It is also possible to
+// specify a specific `topic` via `options.topic` which is used as
+// without namespacing. Created signal ends whenever add-on is
+// unloaded.
+const InputPort = function InputPort({id, topic, initial}) {
+  this.id = id || topic;
+  this.topic = topic || "sdk:" + addonID + ":" + id;
+  this.value = initial === void(0) ? null : initial;
+  this.observing = false;
+  this[outputs] = [];
+};
+
+// InputPort type implements `Input` signal interface.
+InputPort.prototype = new Input();
+InputPort.prototype.constructor = InputPort;
+
+// When port is started (which is when it's subgraph get's
+// first subscriber) actual observer is registered.
+InputPort.start = input => {
+  input.addListener(input);
+  // Also register add-on unload observer to end this signal
+  // when that happens.
+  addObserver(input, addonUnloadTopic, false);
+};
+InputPort.prototype[start] = InputPort.start;
+
+InputPort.addListener = input => addObserver(input, input.topic, false);
+InputPort.prototype.addListener = InputPort.addListener;
+
+// When port is stopped (which is when it's subgraph has no
+// no subcribers left) an actual observer unregistered.
+// Note that port stopped once it ends as well (which is when
+// add-on is unloaded).
+InputPort.stop = input => {
+  input.removeListener(input);
+  removeObserver(input, addonUnloadTopic);
+};
+InputPort.prototype[stop] = InputPort.stop;
+
+InputPort.removeListener = input => removeObserver(input, input.topic);
+InputPort.prototype.removeListener = InputPort.removeListener;
+
+// `InputPort` also implements `nsIObserver` interface and
+// `nsISupportsWeakReference` interfaces as it's going to be used as such.
+InputPort.prototype.QueryInterface = function(iid) {
+  if (!iid.equals(Ci.nsIObserver) && !iid.equals(Ci.nsISupportsWeakReference))
+    throw Cr.NS_ERROR_NO_INTERFACE;
+
+  return this;
+};
+
+// `InputPort` instances implement `observe` method, which is invoked when
+// observer notifications are dispatched. The `subject` of that notification
+// are received on this signal.
+InputPort.prototype.observe = function(subject, topic, data) {
+  // Unwrap message from the subject. SDK used to have it's own version of
+  // wrappedJSObjects which take precedence, if subject has `wrappedJSObject`
+  // and it's not an XrayWrapper use it as message. Otherwise use subject as
+  // is.
+  const message = subject === null ? null :
+        isLegacyWrapper(subject) ? unwrapLegacy(subject) :
+        isXrayWrapper(subject) ? subject :
+        subject.wrappedJSObject ? subject.wrappedJSObject :
+        subject;
+
+  // If observer topic matches topic of the input port receive a message.
+  if (topic === this.topic) {
+    receive(this, message);
+  }
+
+  // If observe topic is add-on unload topic we create an end message.
+  if (topic === addonUnloadTopic && message === unloadMessage) {
+    end(this);
+  }
+};
+
+exports.InputPort = InputPort;
diff --git a/toolkit/jetpack/sdk/io/buffer.js b/toolkit/jetpack/sdk/io/buffer.js
new file mode 100644
index 000000000..5ea169402
--- /dev/null
+++ b/toolkit/jetpack/sdk/io/buffer.js
@@ -0,0 +1,351 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental'
+};
+
+/*
+ * Encodings supported by TextEncoder/Decoder:
+ * utf-8, utf-16le, utf-16be
+ * http://encoding.spec.whatwg.org/#interface-textencoder
+ *
+ * Node however supports the following encodings:
+ * ascii, utf-8, utf-16le, usc2, base64, hex
+ */
+
+const { Cu } = require('chrome');
+const { isNumber } = require('sdk/lang/type');
+const { TextEncoder, TextDecoder } = Cu.import('resource://gre/modules/commonjs/toolkit/loader.js', {});
+
+exports.TextEncoder = TextEncoder;
+exports.TextDecoder = TextDecoder;
+
+/**
+ * Use WeakMaps to work around Bug 929146, which prevents us from adding
+ * getters or values to typed arrays
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=929146
+ */
+const parents = new WeakMap();
+const views = new WeakMap();
+
+function Buffer(subject, encoding /*, bufferLength */) {
+
+  // Allow invocation without `new` constructor
+  if (!(this instanceof Buffer))
+    return new Buffer(subject, encoding, arguments[2]);
+
+  var type = typeof(subject);
+
+  switch (type) {
+    case 'number':
+      // Create typed array of the given size if number.
+      try {
+        let buffer = new Uint8Array(subject > 0 ? Math.floor(subject) : 0);
+        return buffer;
+      } catch (e) {
+        if (/size and count too large/.test(e.message) ||
+            /invalid arguments/.test(e.message))
+          throw new RangeError('Could not instantiate buffer: size of buffer may be too large');
+        else
+          throw new Error('Could not instantiate buffer');
+      }
+      break;
+    case 'string':
+      // If string encode it and use buffer for the returned Uint8Array
+      // to create a local patched version that acts like node buffer.
+      encoding = encoding || 'utf8';
+      return new Uint8Array(new TextEncoder(encoding).encode(subject).buffer);
+    case 'object':
+      // This form of the constructor uses the form of
+      // new Uint8Array(buffer, offset, length);
+      // So we can instantiate a typed array within the constructor
+      // to inherit the appropriate properties, where both the
+      // `subject` and newly instantiated buffer share the same underlying
+      // data structure.
+      if (arguments.length === 3)
+        return new Uint8Array(subject, encoding, arguments[2]);
+      // If array or alike just make a copy with a local patched prototype.
+      else
+        return new Uint8Array(subject);
+    default:
+      throw new TypeError('must start with number, buffer, array or string');
+  }
+}
+exports.Buffer = Buffer;
+
+// Tests if `value` is a Buffer.
+Buffer.isBuffer = value => value instanceof Buffer
+
+// Returns true if the encoding is a valid encoding argument & false otherwise
+Buffer.isEncoding = function (encoding) {
+  if (!encoding) return false;
+  try {
+    new TextDecoder(encoding);
+  } catch(e) {
+    return false;
+  }
+  return true;
+}
+
+// Gives the actual byte length of a string. encoding defaults to 'utf8'.
+// This is not the same as String.prototype.length since that returns the
+// number of characters in a string.
+Buffer.byteLength = (value, encoding = 'utf8') =>
+  new TextEncoder(encoding).encode(value).byteLength
+
+// Direct copy of the nodejs's buffer implementation:
+// https://github.com/joyent/node/blob/b255f4c10a80343f9ce1cee56d0288361429e214/lib/buffer.js#L146-L177
+Buffer.concat = function(list, length) {
+  if (!Array.isArray(list))
+    throw new TypeError('Usage: Buffer.concat(list[, length])');
+
+  if (typeof length === 'undefined') {
+    length = 0;
+    for (var i = 0; i < list.length; i++)
+      length += list[i].length;
+  } else {
+    length = ~~length;
+  }
+
+  if (length < 0)
+    length = 0;
+
+  if (list.length === 0)
+    return new Buffer(0);
+  else if (list.length === 1)
+    return list[0];
+
+  if (length < 0)
+    throw new RangeError('length is not a positive number');
+
+  var buffer = new Buffer(length);
+  var pos = 0;
+  for (var i = 0; i < list.length; i++) {
+    var buf = list[i];
+    buf.copy(buffer, pos);
+    pos += buf.length;
+  }
+
+  return buffer;
+};
+
+// Node buffer is very much like Uint8Array although it has bunch of methods
+// that typically can be used in combination with `DataView` while preserving
+// access by index. Since in SDK each module has it's own set of bult-ins it
+// ok to patch ours to make it nodejs Buffer compatible.
+const Uint8ArraySet = Uint8Array.prototype.set
+Buffer.prototype = Uint8Array.prototype;
+Object.defineProperties(Buffer.prototype, {
+  parent: {
+    get: function() { return parents.get(this, undefined); }
+  },
+  view: {
+    get: function () {
+      let view = views.get(this, undefined);
+      if (view) return view;
+      view = new DataView(this.buffer);
+      views.set(this, view);
+      return view;
+    }
+  },
+  toString: {
+    value: function(encoding, start, end) {
+      encoding = !!encoding ? (encoding + '').toLowerCase() : 'utf8';
+      start = Math.max(0, ~~start);
+      end = Math.min(this.length, end === void(0) ? this.length : ~~end);
+      return new TextDecoder(encoding).decode(this.subarray(start, end));
+    }
+  },
+  toJSON: {
+    value: function() {
+      return { type: 'Buffer', data: Array.slice(this, 0) };
+    }
+  },
+  get: {
+    value: function(offset) {
+      return this[offset];
+    }
+  },
+  set: {
+    value: function(offset, value) { this[offset] = value; }
+  },
+  copy: {
+    value: function(target, offset, start, end) {
+      let length = this.length;
+      let targetLength = target.length;
+      offset = isNumber(offset) ? offset : 0;
+      start = isNumber(start) ? start : 0;
+
+      if (start < 0)
+        throw new RangeError('sourceStart is outside of valid range');
+      if (end < 0)
+        throw new RangeError('sourceEnd is outside of valid range');
+
+      // If sourceStart > sourceEnd, or targetStart > targetLength,
+      // zero bytes copied
+      if (start > end ||
+          offset > targetLength
+          )
+        return 0;
+
+      // If `end` is not defined, or if it is defined
+      // but would overflow `target`, redefine `end`
+      // so we can copy as much as we can
+      if (end - start > targetLength - offset ||
+          end == null) {
+        let remainingTarget = targetLength - offset;
+        let remainingSource = length - start;
+        if (remainingSource <= remainingTarget)
+          end = length;
+        else
+          end = start + remainingTarget;
+      }
+
+      Uint8ArraySet.call(target, this.subarray(start, end), offset);
+      return end - start;
+    }
+  },
+  slice: {
+    value: function(start, end) {
+      let length = this.length;
+      start = ~~start;
+      end = end != null ? end : length;
+
+      if (start < 0) {
+        start += length;
+        if (start < 0) start = 0;
+      } else if (start > length)
+        start = length;
+
+      if (end < 0) {
+        end += length;
+        if (end < 0) end = 0;
+      } else if (end > length)
+        end = length;
+
+      if (end < start)
+        end = start;
+
+      // This instantiation uses the new Uint8Array(buffer, offset, length) version
+      // of construction to share the same underling data structure
+      let buffer = new Buffer(this.buffer, start, end - start);
+
+      // If buffer has a value, assign its parent value to the
+      // buffer it shares its underlying structure with. If a slice of
+      // a slice, then use the root structure
+      if (buffer.length > 0)
+        parents.set(buffer, this.parent || this);
+
+      return buffer;
+    }
+  },
+  write: {
+    value: function(string, offset, length, encoding = 'utf8') {
+      // write(string, encoding);
+      if (typeof(offset) === 'string' && Number.isNaN(parseInt(offset))) {
+        [offset, length, encoding] = [0, null, offset];
+      }
+      // write(string, offset, encoding);
+      else if (typeof(length) === 'string')
+        [length, encoding] = [null, length];
+
+      if (offset < 0 || offset > this.length)
+        throw new RangeError('offset is outside of valid range');
+
+      offset = ~~offset;
+
+      // Clamp length if it would overflow buffer, or if its
+      // undefined
+      if (length == null || length + offset > this.length)
+        length = this.length - offset;
+
+      let buffer = new TextEncoder(encoding).encode(string);
+      let result = Math.min(buffer.length, length);
+      if (buffer.length !== length)
+        buffer = buffer.subarray(0, length);
+
+      Uint8ArraySet.call(this, buffer, offset);
+      return result;
+    }
+  },
+  fill: {
+    value: function fill(value, start, end) {
+      let length = this.length;
+      value = value || 0;
+      start = start || 0;
+      end = end || length;
+
+      if (typeof(value) === 'string')
+        value = value.charCodeAt(0);
+      if (typeof(value) !== 'number' || isNaN(value))
+        throw TypeError('value is not a number');
+      if (end < start)
+        throw new RangeError('end < start');
+
+      // Fill 0 bytes; we're done
+      if (end === start)
+        return 0;
+      if (length == 0)
+        return 0;
+
+      if (start < 0 || start >= length)
+        throw RangeError('start out of bounds');
+
+      if (end < 0 || end > length)
+        throw RangeError('end out of bounds');
+
+      let index = start;
+      while (index < end) this[index++] = value;
+    }
+  }
+});
+
+// Define nodejs Buffer's getter and setter functions that just proxy
+// to internal DataView's equivalent methods.
+
+// TODO do we need to check architecture to see if it's default big/little endian?
+[['readUInt16LE', 'getUint16', true],
+ ['readUInt16BE', 'getUint16', false],
+ ['readInt16LE', 'getInt16', true],
+ ['readInt16BE', 'getInt16', false],
+ ['readUInt32LE', 'getUint32', true],
+ ['readUInt32BE', 'getUint32', false],
+ ['readInt32LE', 'getInt32', true],
+ ['readInt32BE', 'getInt32', false],
+ ['readFloatLE', 'getFloat32', true],
+ ['readFloatBE', 'getFloat32', false],
+ ['readDoubleLE', 'getFloat64', true],
+ ['readDoubleBE', 'getFloat64', false],
+ ['readUInt8', 'getUint8'],
+ ['readInt8', 'getInt8']].forEach(([alias, name, littleEndian]) => {
+  Object.defineProperty(Buffer.prototype, alias, {
+    value: function(offset) {
+      return this.view[name](offset, littleEndian);
+    }
+  });
+});
+
+[['writeUInt16LE', 'setUint16', true],
+ ['writeUInt16BE', 'setUint16', false],
+ ['writeInt16LE', 'setInt16', true],
+ ['writeInt16BE', 'setInt16', false],
+ ['writeUInt32LE', 'setUint32', true],
+ ['writeUInt32BE', 'setUint32', false],
+ ['writeInt32LE', 'setInt32', true],
+ ['writeInt32BE', 'setInt32', false],
+ ['writeFloatLE', 'setFloat32', true],
+ ['writeFloatBE', 'setFloat32', false],
+ ['writeDoubleLE', 'setFloat64', true],
+ ['writeDoubleBE', 'setFloat64', false],
+ ['writeUInt8', 'setUint8'],
+ ['writeInt8', 'setInt8']].forEach(([alias, name, littleEndian]) => {
+  Object.defineProperty(Buffer.prototype, alias, {
+    value: function(value, offset) {
+      return this.view[name](offset, value, littleEndian);
+    }
+  });
+});
diff --git a/toolkit/jetpack/sdk/io/byte-streams.js b/toolkit/jetpack/sdk/io/byte-streams.js
new file mode 100644
index 000000000..6afab4369
--- /dev/null
+++ b/toolkit/jetpack/sdk/io/byte-streams.js
@@ -0,0 +1,104 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+exports.ByteReader = ByteReader;
+exports.ByteWriter = ByteWriter;
+
+const {Cc, Ci} = require("chrome");
+
+// This just controls the maximum number of bytes we read in at one time.
+const BUFFER_BYTE_LEN = 0x8000;
+
+function ByteReader(inputStream) {
+  const self = this;
+
+  let stream = Cc["@mozilla.org/binaryinputstream;1"].
+               createInstance(Ci.nsIBinaryInputStream);
+  stream.setInputStream(inputStream);
+
+  let manager = new StreamManager(this, stream);
+
+  this.read = function ByteReader_read(numBytes) {
+    manager.ensureOpened();
+    if (typeof(numBytes) !== "number")
+      numBytes = Infinity;
+
+    let data = "";
+    let read = 0;
+    try {
+      while (true) {
+        let avail = stream.available();
+        let toRead = Math.min(numBytes - read, avail, BUFFER_BYTE_LEN);
+        if (toRead <= 0)
+          break;
+        data += stream.readBytes(toRead);
+        read += toRead;
+      }
+    }
+    catch (err) {
+      throw new Error("Error reading from stream: " + err);
+    }
+
+    return data;
+  };
+}
+
+function ByteWriter(outputStream) {
+  const self = this;
+
+  let stream = Cc["@mozilla.org/binaryoutputstream;1"].
+               createInstance(Ci.nsIBinaryOutputStream);
+  stream.setOutputStream(outputStream);
+
+  let manager = new StreamManager(this, stream);
+
+  this.write = function ByteWriter_write(str) {
+    manager.ensureOpened();
+    try {
+      stream.writeBytes(str, str.length);
+    }
+    catch (err) {
+      throw new Error("Error writing to stream: " + err);
+    }
+  };
+}
+
+
+// This manages the lifetime of stream, a ByteReader or ByteWriter.  It defines
+// closed and close() on stream and registers an unload listener that closes
+// rawStream if it's still opened.  It also provides ensureOpened(), which
+// throws an exception if the stream is closed.
+function StreamManager(stream, rawStream) {
+  const self = this;
+  this.rawStream = rawStream;
+  this.opened = true;
+
+  stream.__defineGetter__("closed", function stream_closed() {
+    return !self.opened;
+  });
+
+  stream.close = function stream_close() {
+    self.ensureOpened();
+    self.unload();
+  };
+
+  require("../system/unload").ensure(this);
+}
+
+StreamManager.prototype = {
+  ensureOpened: function StreamManager_ensureOpened() {
+    if (!this.opened)
+      throw new Error("The stream is closed and cannot be used.");
+  },
+  unload: function StreamManager_unload() {
+    this.rawStream.close();
+    this.opened = false;
+  }
+};
diff --git a/toolkit/jetpack/sdk/io/file.js b/toolkit/jetpack/sdk/io/file.js
new file mode 100644
index 000000000..47467df87
--- /dev/null
+++ b/toolkit/jetpack/sdk/io/file.js
@@ -0,0 +1,196 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "deprecated"
+};
+
+const {Cc,Ci,Cr} = require("chrome");
+const byteStreams = require("./byte-streams");
+const textStreams = require("./text-streams");
+
+// Flags passed when opening a file.  See nsprpub/pr/include/prio.h.
+const OPEN_FLAGS = {
+  RDONLY: parseInt("0x01"),
+  WRONLY: parseInt("0x02"),
+  CREATE_FILE: parseInt("0x08"),
+  APPEND: parseInt("0x10"),
+  TRUNCATE: parseInt("0x20"),
+  EXCL: parseInt("0x80")
+};
+
+var dirsvc = Cc["@mozilla.org/file/directory_service;1"]
+             .getService(Ci.nsIProperties);
+
+function MozFile(path) {
+  var file = Cc['@mozilla.org/file/local;1']
+             .createInstance(Ci.nsILocalFile);
+  file.initWithPath(path);
+  return file;
+}
+
+function ensureReadable(file) {
+  if (!file.isReadable())
+    throw new Error("path is not readable: " + file.path);
+}
+
+function ensureDir(file) {
+  ensureExists(file);
+  if (!file.isDirectory())
+    throw new Error("path is not a directory: " + file.path);
+}
+
+function ensureFile(file) {
+  ensureExists(file);
+  if (!file.isFile())
+    throw new Error("path is not a file: " + file.path);
+}
+
+function ensureExists(file) {
+  if (!file.exists())
+    throw friendlyError(Cr.NS_ERROR_FILE_NOT_FOUND, file.path);
+}
+
+function friendlyError(errOrResult, filename) {
+  var isResult = typeof(errOrResult) === "number";
+  var result = isResult ? errOrResult : errOrResult.result;
+  switch (result) {
+  case Cr.NS_ERROR_FILE_NOT_FOUND:
+    return new Error("path does not exist: " + filename);
+  }
+  return isResult ? new Error("XPCOM error code: " + errOrResult) : errOrResult;
+}
+
+exports.exists = function exists(filename) {
+  return MozFile(filename).exists();
+};
+
+exports.isFile = function isFile(filename) {
+  return MozFile(filename).isFile();
+};
+
+exports.read = function read(filename, mode) {
+  if (typeof(mode) !== "string")
+    mode = "";
+
+  // Ensure mode is read-only.
+  mode = /b/.test(mode) ? "b" : "";
+
+  var stream = exports.open(filename, mode);
+  try {
+    var str = stream.read();
+  }
+  finally {
+    stream.close();
+  }
+
+  return str;
+};
+
+exports.join = function join(base) {
+  if (arguments.length < 2)
+    throw new Error("need at least 2 args");
+  base = MozFile(base);
+  for (var i = 1; i < arguments.length; i++)
+    base.append(arguments[i]);
+  return base.path;
+};
+
+exports.dirname = function dirname(path) {
+  var parent = MozFile(path).parent;
+  return parent ? parent.path : "";
+};
+
+exports.basename = function basename(path) {
+  var leafName = MozFile(path).leafName;
+
+  // On Windows, leafName when the path is a volume letter and colon ("c:") is
+  // the path itself.  But such a path has no basename, so we want the empty
+  // string.
+  return leafName == path ? "" : leafName;
+};
+
+exports.list = function list(path) {
+  var file = MozFile(path);
+  ensureDir(file);
+  ensureReadable(file);
+
+  var entries = file.directoryEntries;
+  var entryNames = [];
+  while(entries.hasMoreElements()) {
+    var entry = entries.getNext();
+    entry.QueryInterface(Ci.nsIFile);
+    entryNames.push(entry.leafName);
+  }
+  return entryNames;
+};
+
+exports.open = function open(filename, mode) {
+  var file = MozFile(filename);
+  if (typeof(mode) !== "string")
+    mode = "";
+
+  // File opened for write only.
+  if (/w/.test(mode)) {
+    if (file.exists())
+      ensureFile(file);
+    var stream = Cc['@mozilla.org/network/file-output-stream;1'].
+                 createInstance(Ci.nsIFileOutputStream);
+    var openFlags = OPEN_FLAGS.WRONLY |
+                    OPEN_FLAGS.CREATE_FILE |
+                    OPEN_FLAGS.TRUNCATE;
+    var permFlags = 0o644; // u+rw go+r
+    try {
+      stream.init(file, openFlags, permFlags, 0);
+    }
+    catch (err) {
+      throw friendlyError(err, filename);
+    }
+    return /b/.test(mode) ?
+           new byteStreams.ByteWriter(stream) :
+           new textStreams.TextWriter(stream);
+  }
+
+  // File opened for read only, the default.
+  ensureFile(file);
+  stream = Cc['@mozilla.org/network/file-input-stream;1'].
+           createInstance(Ci.nsIFileInputStream);
+  try {
+    stream.init(file, OPEN_FLAGS.RDONLY, 0, 0);
+  }
+  catch (err) {
+    throw friendlyError(err, filename);
+  }
+  return /b/.test(mode) ?
+         new byteStreams.ByteReader(stream) :
+         new textStreams.TextReader(stream);
+};
+
+exports.remove = function remove(path) {
+  var file = MozFile(path);
+  ensureFile(file);
+  file.remove(false);
+};
+
+exports.mkpath = function mkpath(path) {
+  var file = MozFile(path);
+  if (!file.exists())
+    file.create(Ci.nsIFile.DIRECTORY_TYPE, 0o755); // u+rwx go+rx
+  else if (!file.isDirectory())
+    throw new Error("The path already exists and is not a directory: " + path);
+};
+
+exports.rmdir = function rmdir(path) {
+  var file = MozFile(path);
+  ensureDir(file);
+  try {
+    file.remove(false);
+  }
+  catch (err) {
+    // Bug 566950 explains why we're not catching a specific exception here.
+    throw new Error("The directory is not empty: " + path);
+  }
+};
diff --git a/toolkit/jetpack/sdk/io/fs.js b/toolkit/jetpack/sdk/io/fs.js
new file mode 100644
index 000000000..860a884a5
--- /dev/null
+++ b/toolkit/jetpack/sdk/io/fs.js
@@ -0,0 +1,984 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci, CC } = require("chrome");
+
+const { setTimeout } = require("../timers");
+const { Stream, InputStream, OutputStream } = require("./stream");
+const { emit, on } = require("../event/core");
+const { Buffer } = require("./buffer");
+const { ns } = require("../core/namespace");
+const { Class } = require("../core/heritage");
+
+
+const nsILocalFile = CC("@mozilla.org/file/local;1", "nsILocalFile",
+                        "initWithPath");
+const FileOutputStream = CC("@mozilla.org/network/file-output-stream;1",
+                            "nsIFileOutputStream", "init");
+const FileInputStream = CC("@mozilla.org/network/file-input-stream;1",
+                           "nsIFileInputStream", "init");
+const BinaryInputStream = CC("@mozilla.org/binaryinputstream;1",
+                             "nsIBinaryInputStream", "setInputStream");
+const BinaryOutputStream = CC("@mozilla.org/binaryoutputstream;1",
+                              "nsIBinaryOutputStream", "setOutputStream");
+const StreamPump = CC("@mozilla.org/network/input-stream-pump;1",
+                      "nsIInputStreamPump", "init");
+
+const { createOutputTransport, createInputTransport } =
+  Cc["@mozilla.org/network/stream-transport-service;1"].
+  getService(Ci.nsIStreamTransportService);
+
+const { OPEN_UNBUFFERED } = Ci.nsITransport;
+
+
+const { REOPEN_ON_REWIND, DEFER_OPEN } = Ci.nsIFileInputStream;
+const { DIRECTORY_TYPE, NORMAL_FILE_TYPE } = Ci.nsIFile;
+const { NS_SEEK_SET, NS_SEEK_CUR, NS_SEEK_END } = Ci.nsISeekableStream;
+
+const FILE_PERMISSION = 0o666;
+const PR_UINT32_MAX = 0xfffffff;
+// Values taken from:
+// http://mxr.mozilla.org/mozilla-central/source/nsprpub/pr/include/prio.h#615
+const PR_RDONLY =       0x01;
+const PR_WRONLY =       0x02;
+const PR_RDWR =         0x04;
+const PR_CREATE_FILE =  0x08;
+const PR_APPEND =       0x10;
+const PR_TRUNCATE =     0x20;
+const PR_SYNC =         0x40;
+const PR_EXCL =         0x80;
+
+const FLAGS = {
+  "r":                  PR_RDONLY,
+  "r+":                 PR_RDWR,
+  "w":                  PR_CREATE_FILE | PR_TRUNCATE | PR_WRONLY,
+  "w+":                 PR_CREATE_FILE | PR_TRUNCATE | PR_RDWR,
+  "a":                  PR_APPEND | PR_CREATE_FILE | PR_WRONLY,
+  "a+":                 PR_APPEND | PR_CREATE_FILE | PR_RDWR
+};
+
+function accessor() {
+  let map = new WeakMap();
+  return function(fd, value) {
+    if (value === null) map.delete(fd);
+    if (value !== undefined) map.set(fd, value);
+    return map.get(fd);
+  }
+}
+
+var nsIFile = accessor();
+var nsIFileInputStream = accessor();
+var nsIFileOutputStream = accessor();
+var nsIBinaryInputStream = accessor();
+var nsIBinaryOutputStream = accessor();
+
+// Just a contstant object used to signal that all of the file
+// needs to be read.
+const ALL = new String("Read all of the file");
+
+function isWritable(mode) {
+  return !!(mode & PR_WRONLY || mode & PR_RDWR);
+}
+function isReadable(mode) {
+  return !!(mode & PR_RDONLY || mode & PR_RDWR);
+}
+
+function isString(value) {
+  return typeof(value) === "string";
+}
+function isFunction(value) {
+  return typeof(value) === "function";
+}
+
+function toArray(enumerator) {
+  let value = [];
+  while(enumerator.hasMoreElements())
+    value.push(enumerator.getNext())
+  return value
+}
+
+function getFileName(file) {
+  return file.QueryInterface(Ci.nsIFile).leafName;
+}
+
+
+function remove(path, recursive) {
+  let fd = new nsILocalFile(path)
+  if (fd.exists()) {
+    fd.remove(recursive || false);
+  }
+  else {
+    throw FSError("remove", "ENOENT", 34, path);
+  }
+}
+
+/**
+ * Utility function to convert either an octal number or string
+ * into an octal number
+ * 0777 => 0o777
+ * "0644" => 0o644
+ */
+function Mode(mode, fallback) {
+  return isString(mode) ? parseInt(mode, 8) : mode || fallback;
+}
+function Flags(flag) {
+  return !isString(flag) ? flag :
+         FLAGS[flag] || Error("Unknown file open flag: " + flag);
+}
+
+
+function FSError(op, code, errno, path, file, line) {
+  let error = Error(code + ", " + op + " " + path, file, line);
+  error.code = code;
+  error.path = path;
+  error.errno = errno;
+  return error;
+}
+
+const ReadStream = Class({
+  extends: InputStream,
+  initialize: function initialize(path, options) {
+    this.position = -1;
+    this.length = -1;
+    this.flags = "r";
+    this.mode = FILE_PERMISSION;
+    this.bufferSize = 64 * 1024;
+
+    options = options || {};
+
+    if ("flags" in options && options.flags)
+      this.flags = options.flags;
+    if ("bufferSize" in options && options.bufferSize)
+      this.bufferSize = options.bufferSize;
+    if ("length" in options && options.length)
+      this.length = options.length;
+    if ("position" in options && options.position !== undefined)
+      this.position = options.position;
+
+    let { flags, mode, position, length } = this;
+    let fd = isString(path) ? openSync(path, flags, mode) : path;
+    this.fd = fd;
+
+    let input = nsIFileInputStream(fd);
+    // Setting a stream position, unless it"s `-1` which means current position.
+    if (position >= 0)
+      input.QueryInterface(Ci.nsISeekableStream).seek(NS_SEEK_SET, position);
+    // We use `nsIStreamTransportService` service to transform blocking
+    // file input stream into a fully asynchronous stream that can be written
+    // without blocking the main thread.
+    let transport = createInputTransport(input, position, length, false);
+    // Open an input stream on a transport. We don"t pass flags to guarantee
+    // non-blocking stream semantics. Also we use defaults for segment size &
+    // count.
+    InputStream.prototype.initialize.call(this, {
+      asyncInputStream: transport.openInputStream(null, 0, 0)
+    });
+
+    // Close file descriptor on end and destroy the stream.
+    on(this, "end", _ => {
+      this.destroy();
+      emit(this, "close");
+    });
+
+    this.read();
+  },
+  destroy: function() {
+    closeSync(this.fd);
+    InputStream.prototype.destroy.call(this);
+  }
+});
+exports.ReadStream = ReadStream;
+exports.createReadStream = function createReadStream(path, options) {
+  return new ReadStream(path, options);
+};
+
+const WriteStream = Class({
+  extends: OutputStream,
+  initialize: function initialize(path, options) {
+    this.drainable = true;
+    this.flags = "w";
+    this.position = -1;
+    this.mode = FILE_PERMISSION;
+
+    options = options || {};
+
+    if ("flags" in options && options.flags)
+      this.flags = options.flags;
+    if ("mode" in options && options.mode)
+      this.mode = options.mode;
+    if ("position" in options && options.position !== undefined)
+      this.position = options.position;
+
+    let { position, flags, mode } = this;
+    // If pass was passed we create a file descriptor out of it. Otherwise
+    // we just use given file descriptor.
+    let fd = isString(path) ? openSync(path, flags, mode) : path;
+    this.fd = fd;
+
+    let output = nsIFileOutputStream(fd);
+    // Setting a stream position, unless it"s `-1` which means current position.
+    if (position >= 0)
+      output.QueryInterface(Ci.nsISeekableStream).seek(NS_SEEK_SET, position);
+    // We use `nsIStreamTransportService` service to transform blocking
+    // file output stream into a fully asynchronous stream that can be written
+    // without blocking the main thread.
+    let transport = createOutputTransport(output, position, -1, false);
+    // Open an output stream on a transport. We don"t pass flags to guarantee
+    // non-blocking stream semantics. Also we use defaults for segment size &
+    // count.
+    OutputStream.prototype.initialize.call(this, {
+      asyncOutputStream: transport.openOutputStream(OPEN_UNBUFFERED, 0, 0),
+      output: output
+    });
+
+    // For write streams "finish" basically means close.
+    on(this, "finish", _ => {
+       this.destroy();
+       emit(this, "close");
+    });
+  },
+  destroy: function() {
+    OutputStream.prototype.destroy.call(this);
+    closeSync(this.fd);
+  }
+});
+exports.WriteStream = WriteStream;
+exports.createWriteStream = function createWriteStream(path, options) {
+  return new WriteStream(path, options);
+};
+
+const Stats = Class({
+  initialize: function initialize(path) {
+    let file = new nsILocalFile(path);
+    if (!file.exists()) throw FSError("stat", "ENOENT", 34, path);
+    nsIFile(this, file);
+  },
+  isDirectory: function() {
+    return nsIFile(this).isDirectory();
+  },
+  isFile: function() {
+    return nsIFile(this).isFile();
+  },
+  isSymbolicLink: function() {
+    return nsIFile(this).isSymlink();
+  },
+  get mode() {
+    return nsIFile(this).permissions;
+  },
+  get size() {
+    return nsIFile(this).fileSize;
+  },
+  get mtime() {
+    return nsIFile(this).lastModifiedTime;
+  },
+  isBlockDevice: function() {
+    return nsIFile(this).isSpecial();
+  },
+  isCharacterDevice: function() {
+    return nsIFile(this).isSpecial();
+  },
+  isFIFO: function() {
+    return nsIFile(this).isSpecial();
+  },
+  isSocket: function() {
+    return nsIFile(this).isSpecial();
+  },
+  // non standard
+  get exists() {
+    return nsIFile(this).exists();
+  },
+  get hidden() {
+    return nsIFile(this).isHidden();
+  },
+  get writable() {
+    return nsIFile(this).isWritable();
+  },
+  get readable() {
+    return nsIFile(this).isReadable();
+  }
+});
+exports.Stats = Stats;
+
+const LStats = Class({
+  extends: Stats,
+  get size() {
+    return this.isSymbolicLink() ? nsIFile(this).fileSizeOfLink :
+                                   nsIFile(this).fileSize;
+  },
+  get mtime() {
+    return this.isSymbolicLink() ? nsIFile(this).lastModifiedTimeOfLink :
+                                   nsIFile(this).lastModifiedTime;
+  },
+  // non standard
+  get permissions() {
+    return this.isSymbolicLink() ? nsIFile(this).permissionsOfLink :
+                                   nsIFile(this).permissions;
+  }
+});
+
+const FStat = Class({
+  extends: Stats,
+  initialize: function initialize(fd) {
+    nsIFile(this, nsIFile(fd));
+  }
+});
+
+function noop() {}
+function Async(wrapped) {
+  return function (path, callback) {
+    let args = Array.slice(arguments);
+    callback = args.pop();
+    // If node is not given a callback argument
+    // it just does not calls it.
+    if (typeof(callback) !== "function") {
+      args.push(callback);
+      callback = noop;
+    }
+    setTimeout(function() {
+      try {
+        var result = wrapped.apply(this, args);
+        if (result === undefined) callback(null);
+        else callback(null, result);
+      } catch (error) {
+        callback(error);
+      }
+    }, 0);
+  }
+}
+
+
+/**
+ * Synchronous rename(2)
+ */
+function renameSync(oldPath, newPath) {
+  let source = new nsILocalFile(oldPath);
+  let target = new nsILocalFile(newPath);
+  if (!source.exists()) throw FSError("rename", "ENOENT", 34, oldPath);
+  return source.moveTo(target.parent, target.leafName);
+};
+exports.renameSync = renameSync;
+
+/**
+ * Asynchronous rename(2). No arguments other than a possible exception are
+ * given to the completion callback.
+ */
+var rename = Async(renameSync);
+exports.rename = rename;
+
+/**
+ * Test whether or not the given path exists by checking with the file system.
+ */
+function existsSync(path) {
+  return new nsILocalFile(path).exists();
+}
+exports.existsSync = existsSync;
+
+var exists = Async(existsSync);
+exports.exists = exists;
+
+/**
+ * Synchronous ftruncate(2).
+ */
+function truncateSync(path, length) {
+  let fd = openSync(path, "w");
+  ftruncateSync(fd, length);
+  closeSync(fd);
+}
+exports.truncateSync = truncateSync;
+
+/**
+ * Asynchronous ftruncate(2). No arguments other than a possible exception are
+ * given to the completion callback.
+ */
+function truncate(path, length, callback) {
+  open(path, "w", function(error, fd) {
+    if (error) return callback(error);
+    ftruncate(fd, length, function(error) {
+      if (error) {
+        closeSync(fd);
+        callback(error);
+      }
+      else {
+        close(fd, callback);
+      }
+    });
+  });
+}
+exports.truncate = truncate;
+
+function ftruncate(fd, length, callback) {
+  write(fd, new Buffer(length), 0, length, 0, function(error) {
+    callback(error);
+  });
+}
+exports.ftruncate = ftruncate;
+
+function ftruncateSync(fd, length = 0) {
+  writeSync(fd, new Buffer(length), 0, length, 0);
+}
+exports.ftruncateSync = ftruncateSync;
+
+function chownSync(path, uid, gid) {
+  throw Error("Not implemented yet!!");
+}
+exports.chownSync = chownSync;
+
+var chown = Async(chownSync);
+exports.chown = chown;
+
+function lchownSync(path, uid, gid) {
+  throw Error("Not implemented yet!!");
+}
+exports.lchownSync = chownSync;
+
+var lchown = Async(lchown);
+exports.lchown = lchown;
+
+/**
+ * Synchronous chmod(2).
+ */
+function chmodSync (path, mode) {
+  let file;
+  try {
+    file = new nsILocalFile(path);
+  } catch(e) {
+    throw FSError("chmod", "ENOENT", 34, path);
+  }
+
+  file.permissions = Mode(mode);
+}
+exports.chmodSync = chmodSync;
+/**
+ * Asynchronous chmod(2). No arguments other than a possible exception are
+ * given to the completion callback.
+ */
+var chmod = Async(chmodSync);
+exports.chmod = chmod;
+
+/**
+ * Synchronous chmod(2).
+ */
+function fchmodSync(fd, mode) {
+  throw Error("Not implemented yet!!");
+};
+exports.fchmodSync = fchmodSync;
+/**
+ * Asynchronous chmod(2). No arguments other than a possible exception are
+ * given to the completion callback.
+ */
+var fchmod = Async(fchmodSync);
+exports.fchmod = fchmod;
+
+
+/**
+ * Synchronous stat(2). Returns an instance of `fs.Stats`
+ */
+function statSync(path) {
+  return new Stats(path);
+};
+exports.statSync = statSync;
+
+/**
+ * Asynchronous stat(2). The callback gets two arguments (err, stats) where
+ * stats is a `fs.Stats` object. It looks like this:
+ */
+var stat = Async(statSync);
+exports.stat = stat;
+
+/**
+ * Synchronous lstat(2). Returns an instance of `fs.Stats`.
+ */
+function lstatSync(path) {
+  return new LStats(path);
+};
+exports.lstatSync = lstatSync;
+
+/**
+ * Asynchronous lstat(2). The callback gets two arguments (err, stats) where
+ * stats is a fs.Stats object. lstat() is identical to stat(), except that if
+ * path is a symbolic link, then the link itself is stat-ed, not the file that
+ * it refers to.
+ */
+var lstat = Async(lstatSync);
+exports.lstat = lstat;
+
+/**
+ * Synchronous fstat(2). Returns an instance of `fs.Stats`.
+ */
+function fstatSync(fd) {
+  return new FStat(fd);
+};
+exports.fstatSync = fstatSync;
+
+/**
+ * Asynchronous fstat(2). The callback gets two arguments (err, stats) where
+ * stats is a fs.Stats object.
+ */
+var fstat = Async(fstatSync);
+exports.fstat = fstat;
+
+/**
+ * Synchronous link(2).
+ */
+function linkSync(source, target) {
+  throw Error("Not implemented yet!!");
+};
+exports.linkSync = linkSync;
+
+/**
+ * Asynchronous link(2). No arguments other than a possible exception are given
+ * to the completion callback.
+ */
+var link = Async(linkSync);
+exports.link = link;
+
+/**
+ * Synchronous symlink(2).
+ */
+function symlinkSync(source, target) {
+  throw Error("Not implemented yet!!");
+};
+exports.symlinkSync = symlinkSync;
+
+/**
+ * Asynchronous symlink(2). No arguments other than a possible exception are
+ * given to the completion callback.
+ */
+var symlink = Async(symlinkSync);
+exports.symlink = symlink;
+
+/**
+ * Synchronous readlink(2). Returns the resolved path.
+ */
+function readlinkSync(path) {
+  return new nsILocalFile(path).target;
+};
+exports.readlinkSync = readlinkSync;
+
+/**
+ * Asynchronous readlink(2). The callback gets two arguments
+ * `(error, resolvedPath)`.
+ */
+var readlink = Async(readlinkSync);
+exports.readlink = readlink;
+
+/**
+ * Synchronous realpath(2). Returns the resolved path.
+ */
+function realpathSync(path) {
+  return new nsILocalFile(path).path;
+};
+exports.realpathSync = realpathSync;
+
+/**
+ * Asynchronous realpath(2). The callback gets two arguments
+ * `(err, resolvedPath)`.
+ */
+var realpath = Async(realpathSync);
+exports.realpath = realpath;
+
+/**
+ * Synchronous unlink(2).
+ */
+var unlinkSync = remove;
+exports.unlinkSync = unlinkSync;
+
+/**
+ * Asynchronous unlink(2). No arguments other than a possible exception are
+ * given to the completion callback.
+ */
+var unlink = Async(remove);
+exports.unlink = unlink;
+
+/**
+ * Synchronous rmdir(2).
+ */
+var rmdirSync = remove;
+exports.rmdirSync = rmdirSync;
+
+/**
+ * Asynchronous rmdir(2). No arguments other than a possible exception are
+ * given to the completion callback.
+ */
+var rmdir = Async(rmdirSync);
+exports.rmdir = rmdir;
+
+/**
+ * Synchronous mkdir(2).
+ */
+function mkdirSync(path, mode) {
+  try {
+    return nsILocalFile(path).create(DIRECTORY_TYPE, Mode(mode));
+  } catch (error) {
+    // Adjust exception thorw to match ones thrown by node.
+    if (error.name === "NS_ERROR_FILE_ALREADY_EXISTS") {
+      let { fileName, lineNumber } = error;
+      error = FSError("mkdir", "EEXIST", 47, path, fileName, lineNumber);
+    }
+    throw error;
+  }
+};
+exports.mkdirSync = mkdirSync;
+
+/**
+ * Asynchronous mkdir(2). No arguments other than a possible exception are
+ * given to the completion callback.
+ */
+var mkdir = Async(mkdirSync);
+exports.mkdir = mkdir;
+
+/**
+ * Synchronous readdir(3). Returns an array of filenames excluding `"."` and
+ * `".."`.
+ */
+function readdirSync(path) {
+  try {
+    return toArray(new nsILocalFile(path).directoryEntries).map(getFileName);
+  }
+  catch (error) {
+    // Adjust exception thorw to match ones thrown by node.
+    if (error.name === "NS_ERROR_FILE_TARGET_DOES_NOT_EXIST" ||
+        error.name === "NS_ERROR_FILE_NOT_FOUND")
+    {
+      let { fileName, lineNumber } = error;
+      error = FSError("readdir", "ENOENT", 34, path, fileName, lineNumber);
+    }
+    throw error;
+  }
+};
+exports.readdirSync = readdirSync;
+
+/**
+ * Asynchronous readdir(3). Reads the contents of a directory. The callback
+ * gets two arguments `(error, files)` where `files` is an array of the names
+ * of the files in the directory excluding `"."` and `".."`.
+ */
+var readdir = Async(readdirSync);
+exports.readdir = readdir;
+
+/**
+ * Synchronous close(2).
+ */
+ function closeSync(fd) {
+   let input = nsIFileInputStream(fd);
+   let output = nsIFileOutputStream(fd);
+
+   // Closing input stream and removing reference.
+   if (input) input.close();
+   // Closing output stream and removing reference.
+   if (output) output.close();
+
+   nsIFile(fd, null);
+   nsIFileInputStream(fd, null);
+   nsIFileOutputStream(fd, null);
+   nsIBinaryInputStream(fd, null);
+   nsIBinaryOutputStream(fd, null);
+};
+exports.closeSync = closeSync;
+/**
+ * Asynchronous close(2). No arguments other than a possible exception are
+ * given to the completion callback.
+ */
+var close = Async(closeSync);
+exports.close = close;
+
+/**
+ * Synchronous open(2).
+ */
+function openSync(aPath, aFlag, aMode) {
+  let [ fd, flags, mode, file ] =
+      [ { path: aPath }, Flags(aFlag), Mode(aMode), nsILocalFile(aPath) ];
+
+  nsIFile(fd, file);
+
+  // If trying to open file for just read that does not exists
+  // need to throw exception as node does.
+  if (!file.exists() && !isWritable(flags))
+    throw FSError("open", "ENOENT", 34, aPath);
+
+  // If we want to open file in read mode we initialize input stream.
+  if (isReadable(flags)) {
+    let input = FileInputStream(file, flags, mode, DEFER_OPEN);
+    nsIFileInputStream(fd, input);
+  }
+
+  // If we want to open file in write mode we initialize output stream for it.
+  if (isWritable(flags)) {
+    let output = FileOutputStream(file, flags, mode, DEFER_OPEN);
+    nsIFileOutputStream(fd, output);
+  }
+
+  return fd;
+}
+exports.openSync = openSync;
+/**
+ * Asynchronous file open. See open(2). Flags can be
+ * `"r", "r+", "w", "w+", "a"`, or `"a+"`. mode defaults to `0666`.
+ * The callback gets two arguments `(error, fd).
+ */
+var open = Async(openSync);
+exports.open = open;
+
+/**
+ * Synchronous version of buffer-based fs.write(). Returns the number of bytes
+ * written.
+ */
+function writeSync(fd, buffer, offset, length, position) {
+  if (length + offset > buffer.length) {
+    throw Error("Length is extends beyond buffer");
+  }
+  else if (length + offset !== buffer.length) {
+    buffer = buffer.slice(offset, offset + length);
+  }
+
+  let output = BinaryOutputStream(nsIFileOutputStream(fd));
+  nsIBinaryOutputStream(fd, output);
+  // We write content as a byte array as this will avoid any transcoding
+  // if content was a buffer.
+  output.writeByteArray(buffer.valueOf(), buffer.length);
+  output.flush();
+};
+exports.writeSync = writeSync;
+
+/**
+ * Write buffer to the file specified by fd.
+ *
+ * `offset` and `length` determine the part of the buffer to be written.
+ *
+ * `position` refers to the offset from the beginning of the file where this
+ * data should be written. If `position` is `null`, the data will be written
+ * at the current position. See pwrite(2).
+ *
+ * The callback will be given three arguments `(error, written, buffer)` where
+ * written specifies how many bytes were written into buffer.
+ *
+ * Note that it is unsafe to use `fs.write` multiple times on the same file
+ * without waiting for the callback.
+ */
+function write(fd, buffer, offset, length, position, callback) {
+  if (!Buffer.isBuffer(buffer)) {
+    // (fd, data, position, encoding, callback)
+    let encoding = null;
+    [ position, encoding, callback ] = Array.slice(arguments, 1);
+    buffer = new Buffer(String(buffer), encoding);
+    offset = 0;
+  } else if (length + offset > buffer.length) {
+    throw Error("Length is extends beyond buffer");
+  } else if (length + offset !== buffer.length) {
+    buffer = buffer.slice(offset, offset + length);
+  }
+
+  let writeStream = new WriteStream(fd, { position: position,
+                                          length: length });
+  writeStream.on("error", callback);
+  writeStream.write(buffer, function onEnd() {
+    writeStream.destroy();
+    if (callback)
+      callback(null, buffer.length, buffer);
+  });
+};
+exports.write = write;
+
+/**
+ * Synchronous version of string-based fs.read. Returns the number of
+ * bytes read.
+ */
+function readSync(fd, buffer, offset, length, position) {
+  let input = nsIFileInputStream(fd);
+  // Setting a stream position, unless it"s `-1` which means current position.
+  if (position >= 0)
+    input.QueryInterface(Ci.nsISeekableStream).seek(NS_SEEK_SET, position);
+  // We use `nsIStreamTransportService` service to transform blocking
+  // file input stream into a fully asynchronous stream that can be written
+  // without blocking the main thread.
+  let binaryInputStream = BinaryInputStream(input);
+  let count = length === ALL ? binaryInputStream.available() : length;
+  if (offset === 0) binaryInputStream.readArrayBuffer(count, buffer.buffer);
+  else {
+    let chunk = new Buffer(count);
+    binaryInputStream.readArrayBuffer(count, chunk.buffer);
+    chunk.copy(buffer, offset);
+  }
+
+  return buffer.slice(offset, offset + count);
+};
+exports.readSync = readSync;
+
+/**
+ * Read data from the file specified by `fd`.
+ *
+ * `buffer` is the buffer that the data will be written to.
+ * `offset` is offset within the buffer where writing will start.
+ *
+ * `length` is an integer specifying the number of bytes to read.
+ *
+ * `position` is an integer specifying where to begin reading from in the file.
+ * If `position` is `null`, data will be read from the current file position.
+ *
+ * The callback is given the three arguments, `(error, bytesRead, buffer)`.
+ */
+function read(fd, buffer, offset, length, position, callback) {
+  let bytesRead = 0;
+  let readStream = new ReadStream(fd, { position: position, length: length });
+  readStream.on("data", function onData(data) {
+      data.copy(buffer, offset + bytesRead);
+      bytesRead += data.length;
+  });
+  readStream.on("end", function onEnd() {
+    callback(null, bytesRead, buffer);
+    readStream.destroy();
+  });
+};
+exports.read = read;
+
+/**
+ * Asynchronously reads the entire contents of a file.
+ * The callback is passed two arguments `(error, data)`, where data is the
+ * contents of the file.
+ */
+function readFile(path, encoding, callback) {
+  if (isFunction(encoding)) {
+    callback = encoding
+    encoding = null
+  }
+
+  let buffer = null;
+  try {
+    let readStream = new ReadStream(path);
+    readStream.on("data", function(data) {
+      if (!buffer) buffer = data;
+      else buffer = Buffer.concat([buffer, data], 2);
+    });
+    readStream.on("error", function onError(error) {
+      callback(error);
+    });
+    readStream.on("end", function onEnd() {
+      // Note: Need to destroy before invoking a callback
+      // so that file descriptor is released.
+      readStream.destroy();
+      callback(null, buffer);
+    });
+  }
+  catch (error) {
+    setTimeout(callback, 0, error);
+  }
+};
+exports.readFile = readFile;
+
+/**
+ * Synchronous version of `fs.readFile`. Returns the contents of the path.
+ * If encoding is specified then this function returns a string.
+ * Otherwise it returns a buffer.
+ */
+function readFileSync(path, encoding) {
+  let fd = openSync(path, "r");
+  let size = fstatSync(fd).size;
+  let buffer = new Buffer(size);
+  try {
+    readSync(fd, buffer, 0, ALL, 0);
+  }
+  finally {
+    closeSync(fd);
+  }
+  return buffer;
+};
+exports.readFileSync = readFileSync;
+
+/**
+ * Asynchronously writes data to a file, replacing the file if it already
+ * exists. data can be a string or a buffer.
+ */
+function writeFile(path, content, encoding, callback) {
+  if (!isString(path))
+    throw new TypeError('path must be a string');
+
+  try {
+    if (isFunction(encoding)) {
+      callback = encoding
+      encoding = null
+    }
+    if (isString(content))
+      content = new Buffer(content, encoding);
+
+    let writeStream = new WriteStream(path);
+    let error = null;
+
+    writeStream.end(content, function() {
+      writeStream.destroy();
+      callback(error);
+    });
+
+    writeStream.on("error", function onError(reason) {
+      error = reason;
+      writeStream.destroy();
+    });
+  } catch (error) {
+    callback(error);
+  }
+};
+exports.writeFile = writeFile;
+
+/**
+ * The synchronous version of `fs.writeFile`.
+ */
+function writeFileSync(filename, data, encoding) {
+  // TODO: Implement this in bug 1148209 https://bugzilla.mozilla.org/show_bug.cgi?id=1148209
+  throw Error("Not implemented");
+};
+exports.writeFileSync = writeFileSync;
+
+
+function utimesSync(path, atime, mtime) {
+  throw Error("Not implemented");
+}
+exports.utimesSync = utimesSync;
+
+var utimes = Async(utimesSync);
+exports.utimes = utimes;
+
+function futimesSync(fd, atime, mtime, callback) {
+  throw Error("Not implemented");
+}
+exports.futimesSync = futimesSync;
+
+var futimes = Async(futimesSync);
+exports.futimes = futimes;
+
+function fsyncSync(fd, atime, mtime, callback) {
+  throw Error("Not implemented");
+}
+exports.fsyncSync = fsyncSync;
+
+var fsync = Async(fsyncSync);
+exports.fsync = fsync;
+
+
+/**
+ * Watch for changes on filename. The callback listener will be called each
+ * time the file is accessed.
+ *
+ * The second argument is optional. The options if provided should be an object
+ * containing two members a boolean, persistent, and interval, a polling value
+ * in milliseconds. The default is { persistent: true, interval: 0 }.
+ */
+function watchFile(path, options, listener) {
+  throw Error("Not implemented");
+};
+exports.watchFile = watchFile;
+
+
+function unwatchFile(path, listener) {
+  throw Error("Not implemented");
+}
+exports.unwatchFile = unwatchFile;
+
+function watch(path, options, listener) {
+  throw Error("Not implemented");
+}
+exports.watch = watch;
diff --git a/toolkit/jetpack/sdk/io/stream.js b/toolkit/jetpack/sdk/io/stream.js
new file mode 100644
index 000000000..0698b8e32
--- /dev/null
+++ b/toolkit/jetpack/sdk/io/stream.js
@@ -0,0 +1,440 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { CC, Cc, Ci, Cu, Cr, components } = require("chrome");
+const { EventTarget } = require("../event/target");
+const { emit } = require("../event/core");
+const { Buffer } = require("./buffer");
+const { Class } = require("../core/heritage");
+const { setTimeout } = require("../timers");
+
+
+const MultiplexInputStream = CC("@mozilla.org/io/multiplex-input-stream;1",
+                                "nsIMultiplexInputStream");
+const AsyncStreamCopier = CC("@mozilla.org/network/async-stream-copier;1",
+                             "nsIAsyncStreamCopier", "init");
+const StringInputStream = CC("@mozilla.org/io/string-input-stream;1",
+                             "nsIStringInputStream");
+const ArrayBufferInputStream = CC("@mozilla.org/io/arraybuffer-input-stream;1",
+                                  "nsIArrayBufferInputStream");
+
+const BinaryInputStream = CC("@mozilla.org/binaryinputstream;1",
+                             "nsIBinaryInputStream", "setInputStream");
+const InputStreamPump = CC("@mozilla.org/network/input-stream-pump;1",
+                           "nsIInputStreamPump", "init");
+
+const threadManager = Cc["@mozilla.org/thread-manager;1"].
+                      getService(Ci.nsIThreadManager);
+
+const eventTarget = Cc["@mozilla.org/network/stream-transport-service;1"].
+                    getService(Ci.nsIEventTarget);
+
+var isFunction = value => typeof(value) === "function"
+
+function accessor() {
+  let map = new WeakMap();
+  return function(target, value) {
+    if (value)
+      map.set(target, value);
+    return map.get(target);
+  }
+}
+
+const Stream = Class({
+  extends: EventTarget,
+  initialize: function() {
+    this.readable = false;
+    this.writable = false;
+    this.encoding = null;
+  },
+  setEncoding: function setEncoding(encoding) {
+    this.encoding = String(encoding).toUpperCase();
+  },
+  pipe: function pipe(target, options) {
+    let source = this;
+    function onData(chunk) {
+      if (target.writable) {
+        if (false === target.write(chunk))
+          source.pause();
+      }
+    }
+    function onDrain() {
+      if (source.readable)
+        source.resume();
+    }
+    function onEnd() {
+      target.end();
+    }
+    function onPause() {
+      source.pause();
+    }
+    function onResume() {
+      if (source.readable)
+        source.resume();
+    }
+
+    function cleanup() {
+      source.removeListener("data", onData);
+      target.removeListener("drain", onDrain);
+      source.removeListener("end", onEnd);
+
+      target.removeListener("pause", onPause);
+      target.removeListener("resume", onResume);
+
+      source.removeListener("end", cleanup);
+      source.removeListener("close", cleanup);
+
+      target.removeListener("end", cleanup);
+      target.removeListener("close", cleanup);
+    }
+
+    if (!options || options.end !== false)
+      target.on("end", onEnd);
+
+    source.on("data", onData);
+    target.on("drain", onDrain);
+    target.on("resume", onResume);
+    target.on("pause", onPause);
+
+    source.on("end", cleanup);
+    source.on("close", cleanup);
+
+    target.on("end", cleanup);
+    target.on("close", cleanup);
+
+    emit(target, "pipe", source);
+  },
+  pause: function pause() {
+    emit(this, "pause");
+  },
+  resume: function resume() {
+    emit(this, "resume");
+  },
+  destroySoon: function destroySoon() {
+    this.destroy();
+  }
+});
+exports.Stream = Stream;
+
+
+var nsIStreamListener = accessor();
+var nsIInputStreamPump = accessor();
+var nsIAsyncInputStream = accessor();
+var nsIBinaryInputStream = accessor();
+
+const StreamListener = Class({
+  initialize: function(stream) {
+    this.stream = stream;
+  },
+
+  // Next three methods are part of `nsIStreamListener` interface and are
+  // invoked by `nsIInputStreamPump.asyncRead`.
+  onDataAvailable: function(request, context, input, offset, count) {
+    let stream = this.stream;
+    let buffer = new ArrayBuffer(count);
+    nsIBinaryInputStream(stream).readArrayBuffer(count, buffer);
+    emit(stream, "data", new Buffer(buffer));
+  },
+
+  // Next two methods implement `nsIRequestObserver` interface and are invoked
+  // by `nsIInputStreamPump.asyncRead`.
+  onStartRequest: function() {},
+  // Called to signify the end of an asynchronous request. We only care to
+  // discover errors.
+  onStopRequest: function(request, context, status) {
+    let stream = this.stream;
+    stream.readable = false;
+    if (!components.isSuccessCode(status))
+      emit(stream, "error", status);
+    else
+      emit(stream, "end");
+  }
+});
+
+
+const InputStream = Class({
+  extends: Stream,
+  readable: false,
+  paused: false,
+  initialize: function initialize(options) {
+    let { asyncInputStream } = options;
+
+    this.readable = true;
+
+    let binaryInputStream = new BinaryInputStream(asyncInputStream);
+    let inputStreamPump = new InputStreamPump(asyncInputStream,
+                                              -1, -1, 0, 0, false);
+    let streamListener = new StreamListener(this);
+
+    nsIAsyncInputStream(this, asyncInputStream);
+    nsIInputStreamPump(this, inputStreamPump);
+    nsIBinaryInputStream(this, binaryInputStream);
+    nsIStreamListener(this, streamListener);
+
+    this.asyncInputStream = asyncInputStream;
+    this.inputStreamPump = inputStreamPump;
+    this.binaryInputStream = binaryInputStream;
+  },
+  get status() {
+    return nsIInputStreamPump(this).status;
+  },
+  read: function() {
+    nsIInputStreamPump(this).asyncRead(nsIStreamListener(this), null);
+  },
+  pause: function pause() {
+    this.paused = true;
+    nsIInputStreamPump(this).suspend();
+    emit(this, "paused");
+  },
+  resume: function resume() {
+    this.paused = false;
+    if (nsIInputStreamPump(this).isPending()) {
+        nsIInputStreamPump(this).resume();
+        emit(this, "resume");
+    }
+  },
+  close: function close() {
+    this.readable = false;
+    nsIInputStreamPump(this).cancel(Cr.NS_OK);
+    nsIBinaryInputStream(this).close();
+    nsIAsyncInputStream(this).close();
+  },
+  destroy: function destroy() {
+    this.close();
+
+    nsIInputStreamPump(this);
+    nsIAsyncInputStream(this);
+    nsIBinaryInputStream(this);
+    nsIStreamListener(this);
+  }
+});
+exports.InputStream = InputStream;
+
+
+
+var nsIRequestObserver = accessor();
+var nsIAsyncOutputStream = accessor();
+var nsIAsyncStreamCopier = accessor();
+var nsIMultiplexInputStream = accessor();
+
+const RequestObserver = Class({
+  initialize: function(stream) {
+    this.stream = stream;
+  },
+  // Method is part of `nsIRequestObserver` interface that is
+  // invoked by `nsIAsyncStreamCopier.asyncCopy`.
+  onStartRequest: function() {},
+  // Method is part of `nsIRequestObserver` interface that is
+  // invoked by `nsIAsyncStreamCopier.asyncCopy`.
+  onStopRequest: function(request, context, status) {
+    let stream = this.stream;
+    stream.drained = true;
+
+    // Remove copied chunk.
+    let multiplexInputStream = nsIMultiplexInputStream(stream);
+    multiplexInputStream.removeStream(0);
+
+    // If there was an error report.
+    if (!components.isSuccessCode(status))
+      emit(stream, "error", status);
+
+    // If there more chunks in queue then flush them.
+    else if (multiplexInputStream.count)
+      stream.flush();
+
+    // If stream is still writable notify that queue has drained.
+    else if (stream.writable)
+      emit(stream, "drain");
+
+    // If stream is no longer writable close it.
+    else {
+      nsIAsyncStreamCopier(stream).cancel(Cr.NS_OK);
+      nsIMultiplexInputStream(stream).close();
+      nsIAsyncOutputStream(stream).close();
+      nsIAsyncOutputStream(stream).flush();
+    }
+  }
+});
+
+const OutputStreamCallback = Class({
+  initialize: function(stream) {
+    this.stream = stream;
+  },
+  // Method is part of `nsIOutputStreamCallback` interface that
+  // is invoked by `nsIAsyncOutputStream.asyncWait`. It is registered
+  // with `WAIT_CLOSURE_ONLY` flag that overrides the default behavior,
+  // causing the `onOutputStreamReady` notification to be suppressed until
+  // the stream becomes closed.
+  onOutputStreamReady: function(nsIAsyncOutputStream) {
+    emit(this.stream, "finish");
+  }
+});
+
+const OutputStream = Class({
+  extends: Stream,
+  writable: false,
+  drained: true,
+  get bufferSize() {
+    let multiplexInputStream = nsIMultiplexInputStream(this);
+    return multiplexInputStream && multiplexInputStream.available();
+  },
+  initialize: function initialize(options) {
+    let { asyncOutputStream, output } = options;
+    this.writable = true;
+
+    // Ensure that `nsIAsyncOutputStream` was provided.
+    asyncOutputStream.QueryInterface(Ci.nsIAsyncOutputStream);
+
+    // Create a `nsIMultiplexInputStream` and `nsIAsyncStreamCopier`. Former
+    // is used to queue written data chunks that `asyncStreamCopier` will
+    // asynchronously drain into `asyncOutputStream`.
+    let multiplexInputStream = MultiplexInputStream();
+    let asyncStreamCopier = AsyncStreamCopier(multiplexInputStream,
+                                              output || asyncOutputStream,
+                                              eventTarget,
+                                              // nsIMultiplexInputStream
+                                              // implemnts .readSegments()
+                                              true,
+                                              // nsIOutputStream may or
+                                              // may not implemnet
+                                              // .writeSegments().
+                                              false,
+                                              // Use default buffer size.
+                                              null,
+                                              // Should not close an input.
+                                              false,
+                                              // Should not close an output.
+                                              false);
+
+    // Create `requestObserver` implementing `nsIRequestObserver` interface
+    // in the constructor that's gonna be reused across several flushes.
+    let requestObserver = RequestObserver(this);
+
+
+    // Create observer that implements `nsIOutputStreamCallback` and register
+    // using `WAIT_CLOSURE_ONLY` flag. That way it will be notfied once
+    // `nsIAsyncOutputStream` is closed.
+    asyncOutputStream.asyncWait(OutputStreamCallback(this),
+                                asyncOutputStream.WAIT_CLOSURE_ONLY,
+                                0,
+                                threadManager.currentThread);
+
+    nsIRequestObserver(this, requestObserver);
+    nsIAsyncOutputStream(this, asyncOutputStream);
+    nsIMultiplexInputStream(this, multiplexInputStream);
+    nsIAsyncStreamCopier(this, asyncStreamCopier);
+
+    this.asyncOutputStream = asyncOutputStream;
+    this.multiplexInputStream = multiplexInputStream;
+    this.asyncStreamCopier = asyncStreamCopier;
+  },
+  write: function write(content, encoding, callback) {
+    if (isFunction(encoding)) {
+      callback = encoding;
+      encoding = callback;
+    }
+
+    // If stream is not writable we throw an error.
+    if (!this.writable) throw Error("stream is not writable");
+
+    let chunk = null;
+
+    // If content is not a buffer then we create one out of it.
+    if (Buffer.isBuffer(content)) {
+      chunk = new ArrayBufferInputStream();
+      chunk.setData(content.buffer, 0, content.length);
+    }
+    else {
+      chunk = new StringInputStream();
+      chunk.setData(content, content.length);
+    }
+
+    if (callback)
+      this.once("drain", callback);
+
+    // Queue up chunk to be copied to output sync.
+    nsIMultiplexInputStream(this).appendStream(chunk);
+    this.flush();
+
+    return this.drained;
+  },
+  flush: function() {
+    if (this.drained) {
+      this.drained = false;
+      nsIAsyncStreamCopier(this).asyncCopy(nsIRequestObserver(this), null);
+    }
+  },
+  end: function end(content, encoding, callback) {
+    if (isFunction(content)) {
+      callback = content
+      content = callback
+    }
+    if (isFunction(encoding)) {
+      callback = encoding
+      encoding = callback
+    }
+
+    // Setting a listener to "finish" event if passed.
+    if (isFunction(callback))
+      this.once("finish", callback);
+
+
+    if (content)
+      this.write(content, encoding);
+    this.writable = false;
+
+    // Close `asyncOutputStream` only if output has drained. If it's
+    // not drained than `asyncStreamCopier` is busy writing, so let
+    // it finish. Note that since `this.writable` is false copier will
+    // close `asyncOutputStream` once output drains.
+    if (this.drained)
+      nsIAsyncOutputStream(this).close();
+  },
+  destroy: function destroy() {
+    nsIAsyncOutputStream(this).close();
+    nsIAsyncOutputStream(this);
+    nsIMultiplexInputStream(this);
+    nsIAsyncStreamCopier(this);
+    nsIRequestObserver(this);
+  }
+});
+exports.OutputStream = OutputStream;
+
+const DuplexStream = Class({
+  extends: Stream,
+  implements: [InputStream, OutputStream],
+  allowHalfOpen: true,
+  initialize: function initialize(options) {
+    options = options || {};
+    let { readable, writable, allowHalfOpen } = options;
+
+    InputStream.prototype.initialize.call(this, options);
+    OutputStream.prototype.initialize.call(this, options);
+
+    if (readable === false)
+      this.readable = false;
+
+    if (writable === false)
+      this.writable = false;
+
+    if (allowHalfOpen === false)
+      this.allowHalfOpen = false;
+
+    // If in a half open state and it's disabled enforce end.
+    this.once("end", () => {
+      if (!this.allowHalfOpen && (!this.readable || !this.writable))
+        this.end();
+    });
+  },
+  destroy: function destroy(error) {
+    InputStream.prototype.destroy.call(this);
+    OutputStream.prototype.destroy.call(this);
+  }
+});
+exports.DuplexStream = DuplexStream;
diff --git a/toolkit/jetpack/sdk/io/text-streams.js b/toolkit/jetpack/sdk/io/text-streams.js
new file mode 100644
index 000000000..ed4ec4972
--- /dev/null
+++ b/toolkit/jetpack/sdk/io/text-streams.js
@@ -0,0 +1,235 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci, Cu, components } = require("chrome");
+const { ensure } = require("../system/unload");
+const { NetUtil } = Cu.import("resource://gre/modules/NetUtil.jsm", {});
+
+// NetUtil.asyncCopy() uses this buffer length, and since we call it, for best
+// performance we use it, too.
+const BUFFER_BYTE_LEN = 0x8000;
+const PR_UINT32_MAX = 0xffffffff;
+const DEFAULT_CHARSET = "UTF-8";
+
+
+/**
+ * An input stream that reads text from a backing stream using a given text
+ * encoding.
+ *
+ * @param inputStream
+ *        The stream is backed by this nsIInputStream.  It must already be
+ *        opened.
+ * @param charset
+ *        Text in inputStream is expected to be in this character encoding.  If
+ *        not given, "UTF-8" is assumed.  See nsICharsetConverterManager.idl for
+ *        documentation on how to determine other valid values for this.
+ */
+function TextReader(inputStream, charset) {
+  charset = checkCharset(charset);
+
+  let stream = Cc["@mozilla.org/intl/converter-input-stream;1"].
+               createInstance(Ci.nsIConverterInputStream);
+  stream.init(inputStream, charset, BUFFER_BYTE_LEN,
+              Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
+
+  let manager = new StreamManager(this, stream);
+
+  /**
+   * Reads a string from the stream.  If the stream is closed, an exception is
+   * thrown.
+   *
+   * @param  numChars
+   *         The number of characters to read.  If not given, the remainder of
+   *         the stream is read.
+   * @return The string read.  If the stream is already at EOS, returns the
+   *         empty string.
+   */
+  this.read = function TextReader_read(numChars) {
+    manager.ensureOpened();
+
+    let readAll = false;
+    if (typeof(numChars) === "number")
+      numChars = Math.max(numChars, 0);
+    else
+      readAll = true;
+
+    let str = "";
+    let totalRead = 0;
+    let chunkRead = 1;
+
+    // Read in numChars or until EOS, whichever comes first.  Note that the
+    // units here are characters, not bytes.
+    while (true) {
+      let chunk = {};
+      let toRead = readAll ?
+                   PR_UINT32_MAX :
+                   Math.min(numChars - totalRead, PR_UINT32_MAX);
+      if (toRead <= 0 || chunkRead <= 0)
+        break;
+
+      // The converter stream reads in at most BUFFER_BYTE_LEN bytes in a call
+      // to readString, enough to fill its byte buffer.  chunkRead will be the
+      // number of characters encoded by the bytes in that buffer.
+      chunkRead = stream.readString(toRead, chunk);
+      str += chunk.value;
+      totalRead += chunkRead;
+    }
+
+    return str;
+  };
+}
+exports.TextReader = TextReader;
+
+/**
+ * A buffered output stream that writes text to a backing stream using a given
+ * text encoding.
+ *
+ * @param outputStream
+ *        The stream is backed by this nsIOutputStream.  It must already be
+ *        opened.
+ * @param charset
+ *        Text will be written to outputStream using this character encoding.
+ *        If not given, "UTF-8" is assumed.  See nsICharsetConverterManager.idl
+ *        for documentation on how to determine other valid values for this.
+ */
+function TextWriter(outputStream, charset) {
+  charset = checkCharset(charset);
+
+  let stream = outputStream;
+
+  // Buffer outputStream if it's not already.
+  let ioUtils = Cc["@mozilla.org/io-util;1"].getService(Ci.nsIIOUtil);
+  if (!ioUtils.outputStreamIsBuffered(outputStream)) {
+    stream = Cc["@mozilla.org/network/buffered-output-stream;1"].
+             createInstance(Ci.nsIBufferedOutputStream);
+    stream.init(outputStream, BUFFER_BYTE_LEN);
+  }
+
+  // I'd like to use nsIConverterOutputStream.  But NetUtil.asyncCopy(), which
+  // we use below in writeAsync(), naturally expects its sink to be an instance
+  // of nsIOutputStream, which nsIConverterOutputStream's only implementation is
+  // not.  So we use uconv and manually convert all strings before writing to
+  // outputStream.
+  let uconv = Cc["@mozilla.org/intl/scriptableunicodeconverter"].
+              createInstance(Ci.nsIScriptableUnicodeConverter);
+  uconv.charset = charset;
+
+  let manager = new StreamManager(this, stream);
+
+  /**
+   * Flushes the backing stream's buffer.
+   */
+  this.flush = function TextWriter_flush() {
+    manager.ensureOpened();
+    stream.flush();
+  };
+
+  /**
+   * Writes a string to the stream.  If the stream is closed, an exception is
+   * thrown.
+   *
+   * @param str
+   *        The string to write.
+   */
+  this.write = function TextWriter_write(str) {
+    manager.ensureOpened();
+    let istream = uconv.convertToInputStream(str);
+    let len = istream.available();
+    while (len > 0) {
+      stream.writeFrom(istream, len);
+      len = istream.available();
+    }
+    istream.close();
+  };
+
+  /**
+   * Writes a string on a background thread.  After the write completes, the
+   * backing stream's buffer is flushed, and both the stream and the backing
+   * stream are closed, also on the background thread.  If the stream is already
+   * closed, an exception is thrown immediately.
+   *
+   * @param str
+   *        The string to write.
+   * @param callback
+   *        An optional function.  If given, it's called as callback(error) when
+   *        the write completes.  error is an Error object or undefined if there
+   *        was no error.  Inside callback, |this| is the stream object.
+   */
+  this.writeAsync = function TextWriter_writeAsync(str, callback) {
+    manager.ensureOpened();
+    let istream = uconv.convertToInputStream(str);
+    NetUtil.asyncCopy(istream, stream, (result) => {
+        let err = components.isSuccessCode(result) ? undefined :
+        new Error("An error occured while writing to the stream: " + result);
+      if (err)
+        console.error(err);
+
+      // asyncCopy() closes its output (and input) stream.
+      manager.opened = false;
+
+      if (typeof(callback) === "function") {
+        try {
+          callback.call(this, err);
+        }
+        catch (exc) {
+          console.exception(exc);
+        }
+      }
+    });
+  };
+}
+exports.TextWriter = TextWriter;
+
+// This manages the lifetime of stream, a TextReader or TextWriter.  It defines
+// closed and close() on stream and registers an unload listener that closes
+// rawStream if it's still opened.  It also provides ensureOpened(), which
+// throws an exception if the stream is closed.
+function StreamManager(stream, rawStream) {
+  this.rawStream = rawStream;
+  this.opened = true;
+
+  /**
+   * True iff the stream is closed.
+   */
+  stream.__defineGetter__("closed", () => !this.opened);
+
+  /**
+   * Closes both the stream and its backing stream.  If the stream is already
+   * closed, an exception is thrown.  For TextWriters, this first flushes the
+   * backing stream's buffer.
+   */
+  stream.close = () => {
+    this.ensureOpened();
+    this.unload();
+  };
+
+  ensure(this);
+}
+
+StreamManager.prototype = {
+  ensureOpened: function StreamManager_ensureOpened() {
+    if (!this.opened)
+      throw new Error("The stream is closed and cannot be used.");
+  },
+  unload: function StreamManager_unload() {
+    // TextWriter.writeAsync() causes rawStream to close and therefore sets
+    // opened to false, so check that we're still opened.
+    if (this.opened) {
+      // Calling close() on both an nsIUnicharInputStream and
+      // nsIBufferedOutputStream closes their backing streams.  It also forces
+      // nsIOutputStreams to flush first.
+      this.rawStream.close();
+      this.opened = false;
+    }
+  }
+};
+
+function checkCharset(charset) {
+  return typeof(charset) === "string" ? charset : DEFAULT_CHARSET;
+}
diff --git a/toolkit/jetpack/sdk/keyboard/hotkeys.js b/toolkit/jetpack/sdk/keyboard/hotkeys.js
new file mode 100644
index 000000000..a179502b8
--- /dev/null
+++ b/toolkit/jetpack/sdk/keyboard/hotkeys.js
@@ -0,0 +1,110 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { observer: keyboardObserver } = require("./observer");
+const { getKeyForCode, normalize, isFunctionKey,
+        MODIFIERS } = require("./utils");
+
+/**
+ * Register a global `hotkey` that executes `listener` when the key combination
+ * in `hotkey` is pressed. If more then one `listener` is registered on the same
+ * key combination only last one will be executed.
+ *
+ * @param {string} hotkey
+ *    Key combination in the format of 'modifier key'.
+ *
+ * Examples:
+ *
+ *     "accel s"
+ *     "meta shift i"
+ *     "control alt d"
+ *
+ * Modifier keynames:
+ *
+ *  - **shift**: The Shift key.
+ *  - **alt**: The Alt key. On the Macintosh, this is the Option key. On
+ *    Macintosh this can only be used in conjunction with another modifier,
+ *    since `Alt+Letter` combinations are reserved for entering special
+ *    characters in text.
+ *  - **meta**: The Meta key. On the Macintosh, this is the Command key.
+ *  - **control**: The Control key.
+ *  - **accel**: The key used for keyboard shortcuts on the user's platform,
+ *    which is Control on Windows and Linux, and Command on Mac. Usually, this
+ *    would be the value you would use.
+ *
+ * @param {function} listener
+ *    Function to execute when the `hotkey` is executed.
+ */
+exports.register = function register(hotkey, listener) {
+  hotkey = normalize(hotkey);
+  hotkeys[hotkey] = listener;
+};
+
+/**
+ * Unregister a global `hotkey`. If passed `listener` is not the one registered
+ * for the given `hotkey`, the call to this function will be ignored.
+ *
+ * @param {string} hotkey
+ *    Key combination in the format of 'modifier key'.
+ * @param {function} listener
+ *    Function that will be invoked when the `hotkey` is pressed.
+ */
+exports.unregister = function unregister(hotkey, listener) {
+  hotkey = normalize(hotkey);
+  if (hotkeys[hotkey] === listener)
+    delete hotkeys[hotkey];
+};
+
+/**
+ * Map of hotkeys and associated functions.
+ */
+const hotkeys = exports.hotkeys = {};
+
+keyboardObserver.on("keydown", function onKeypress(event, window) {
+  let key, modifiers = [];
+  let isChar = "isChar" in event && event.isChar;
+  let which = "which" in event ? event.which : null;
+  let keyCode = "keyCode" in event ? event.keyCode : null;
+
+  if ("shiftKey" in event && event.shiftKey)
+    modifiers.push("shift");
+  if ("altKey" in event && event.altKey)
+    modifiers.push("alt");
+  if ("ctrlKey" in event && event.ctrlKey)
+    modifiers.push("control");
+  if ("metaKey" in event && event.metaKey)
+    modifiers.push("meta");
+
+  // If it's not a printable character then we fall back to a human readable
+  // equivalent of one of the following constants.
+  // http://dxr.mozilla.org/mozilla-central/source/dom/interfaces/events/nsIDOMKeyEvent.idl
+  key = getKeyForCode(keyCode);
+
+  // If only non-function (f1 - f24) key or only modifiers are pressed we don't
+  // have a valid combination so we return immediately (Also, sometimes
+  // `keyCode` may be one for the modifier which means we do not have a
+  // modifier).
+  if (!key || (!isFunctionKey(key) && !modifiers.length) || key in MODIFIERS)
+    return;
+
+  let combination = normalize({ key: key, modifiers: modifiers });
+  let hotkey = hotkeys[combination];
+
+  if (hotkey) {
+    try {
+      hotkey();
+    } catch (exception) {
+      console.exception(exception);
+    } finally {
+      // Work around bug 582052 by preventing the (nonexistent) default action.
+      event.preventDefault();
+    }
+  }
+});
diff --git a/toolkit/jetpack/sdk/keyboard/observer.js b/toolkit/jetpack/sdk/keyboard/observer.js
new file mode 100644
index 000000000..b8e32b95c
--- /dev/null
+++ b/toolkit/jetpack/sdk/keyboard/observer.js
@@ -0,0 +1,58 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Class } = require("../core/heritage");
+const { EventTarget } = require("../event/target");
+const { emit } = require("../event/core");
+const { DOMEventAssembler } = require("../deprecated/events/assembler");
+const { browserWindowIterator } = require('../deprecated/window-utils');
+const { isBrowser } = require('../window/utils');
+const { observer: windowObserver } = require("../windows/observer");
+
+// Event emitter objects used to register listeners and emit events on them
+// when they occur.
+const Observer = Class({
+  implements: [DOMEventAssembler, EventTarget],
+  initialize() {
+    // Adding each opened window to a list of observed windows.
+    windowObserver.on("open", window => {
+      if (isBrowser(window))
+        this.observe(window);
+    });
+
+    // Removing each closed window form the list of observed windows.
+    windowObserver.on("close", window => {
+      if (isBrowser(window))
+        this.ignore(window);
+    });
+
+    // Making observer aware of already opened windows.
+    for (let window of browserWindowIterator()) {
+      this.observe(window);
+    }
+  },
+  /**
+   * Events that are supported and emitted by the module.
+   */
+  supportedEventsTypes: [ "keydown", "keyup", "keypress" ],
+  /**
+   * Function handles all the supported events on all the windows that are
+   * observed. Method is used to proxy events to the listeners registered on
+   * this event emitter.
+   * @param {Event} event
+   *    Keyboard event being emitted.
+   */
+  handleEvent(event) {
+    emit(this, event.type, event, event.target.ownerDocument ? event.target.ownerDocument.defaultView
+                                                             : undefined);
+  }
+});
+
+exports.observer = new Observer();
diff --git a/toolkit/jetpack/sdk/keyboard/utils.js b/toolkit/jetpack/sdk/keyboard/utils.js
new file mode 100644
index 000000000..1b7df4ce3
--- /dev/null
+++ b/toolkit/jetpack/sdk/keyboard/utils.js
@@ -0,0 +1,189 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci } = require("chrome");
+const runtime = require("../system/runtime");
+const { isString } = require("../lang/type");
+const array = require("../util/array");
+
+
+const SWP = "{{SEPARATOR}}";
+const SEPARATOR = "-"
+const INVALID_COMBINATION = "Hotkey key combination must contain one or more " +
+                            "modifiers and only one key";
+
+// Map of modifier key mappings.
+const MODIFIERS = exports.MODIFIERS = {
+  'accel': runtime.OS === "Darwin" ? 'meta' : 'control',
+  'meta': 'meta',
+  'control': 'control',
+  'ctrl': 'control',
+  'option': 'alt',
+  'command': 'meta',
+  'alt': 'alt',
+  'shift': 'shift'
+};
+
+// Hash of key:code pairs for all the chars supported by `nsIDOMKeyEvent`.
+// This is just a copy of the `nsIDOMKeyEvent` hash with normalized names.
+// @See: http://dxr.mozilla.org/mozilla-central/source/dom/interfaces/events/nsIDOMKeyEvent.idl
+const CODES = exports.CODES = new function Codes() {
+  let nsIDOMKeyEvent = Ci.nsIDOMKeyEvent;
+  // Names that will be substituted with a shorter analogs.
+  let aliases = {
+    'subtract':     '-',
+    'add':          '+',
+    'equals':       '=',
+    'slash':        '/',
+    'backslash':    '\\',
+    'openbracket':  '[',
+    'closebracket': ']',
+    'quote':        '\'',
+    'backquote':    '`',
+    'period':       '.',
+    'semicolon':    ';',
+    'comma':        ','
+  };
+
+  // Normalizing keys and copying values to `this` object.
+  Object.keys(nsIDOMKeyEvent).filter(function(key) {
+    // Filter out only key codes.
+    return key.indexOf('DOM_VK') === 0;
+  }).map(function(key) {
+    // Map to key:values
+    return [ key, nsIDOMKeyEvent[key] ];
+  }).map(function([key, value]) {
+    return [ key.replace('DOM_VK_', '').replace('_', '').toLowerCase(), value ];
+  }).forEach(function ([ key, value ]) {
+    this[aliases[key] || key] = value;
+  }, this);
+};
+
+// Inverted `CODES` hash of `code:key`.
+const KEYS = exports.KEYS = new function Keys() {
+  Object.keys(CODES).forEach(function(key) {
+    this[CODES[key]] = key;
+  }, this)
+}
+
+exports.getKeyForCode = function getKeyForCode(code) {
+  return (code in KEYS) && KEYS[code];
+};
+exports.getCodeForKey = function getCodeForKey(key) {
+  return (key in CODES) && CODES[key];
+};
+
+/**
+ * Utility function that takes string or JSON that defines a `hotkey` and
+ * returns normalized string version of it.
+ * @param {JSON|String} hotkey
+ * @param {String} [separator=" "]
+ *    Optional string that represents separator used to concatenate keys in the
+ *    given `hotkey`.
+ * @returns {String}
+ * @examples
+ *
+ *    require("keyboard/hotkeys").normalize("b Shift accel");
+ *    // 'control shift b' -> on windows & linux
+ *    // 'meta shift b'    -> on mac
+ *    require("keyboard/hotkeys").normalize("alt-d-shift", "-");
+ *    // 'alt shift d'
+ */
+var normalize = exports.normalize = function normalize(hotkey, separator) {
+  if (!isString(hotkey))
+    hotkey = toString(hotkey, separator);
+  return toString(toJSON(hotkey, separator), separator);
+};
+
+/*
+ * Utility function that splits a string of characters that defines a `hotkey`
+ * into modifier keys and the defining key.
+ * @param {String} hotkey
+ * @param {String} [separator=" "]
+ *    Optional string that represents separator used to concatenate keys in the
+ *    given `hotkey`.
+ * @returns {JSON}
+ * @examples
+ *
+ *    require("keyboard/hotkeys").toJSON("accel shift b");
+ *    // { key: 'b', modifiers: [ 'control', 'shift' ] } -> on windows & linux
+ *    // { key: 'b', modifiers: [ 'meta', 'shift' ] }    -> on mac
+ *
+ *    require("keyboard/hotkeys").normalize("alt-d-shift", "-");
+ *    // { key: 'd', modifiers: [ 'alt', 'shift' ] }
+ */
+var toJSON = exports.toJSON = function toJSON(hotkey, separator) {
+  separator = separator || SEPARATOR;
+  // Since default separator is `-`, combination may take form of `alt--`. To
+  // avoid misbehavior we replace `--` with `-{{SEPARATOR}}` where
+  // `{{SEPARATOR}}` can be swapped later.
+  hotkey = hotkey.toLowerCase().replace(separator + separator, separator + SWP);
+
+  let value = {};
+  let modifiers = [];
+  let keys = hotkey.split(separator);
+  keys.forEach(function(name) {
+    // If name is `SEPARATOR` than we swap it back.
+    if (name === SWP)
+      name = separator;
+    if (name in MODIFIERS) {
+      array.add(modifiers, MODIFIERS[name]);
+    } else {
+      if (!value.key)
+        value.key = name;
+      else
+        throw new TypeError(INVALID_COMBINATION);
+    }
+  });
+
+  if (!value.key)
+      throw new TypeError(INVALID_COMBINATION);
+
+  value.modifiers = modifiers.sort();
+  return value;
+};
+
+/**
+ * Utility function that takes object that defines a `hotkey` and returns
+ * string representation of it.
+ *
+ * _Please note that this function does not validates data neither it normalizes
+ * it, if you are unsure that data is well formed use `normalize` function
+ * instead.
+ *
+ * @param {JSON} hotkey
+ * @param {String} [separator=" "]
+ *    Optional string that represents separator used to concatenate keys in the
+ *    given `hotkey`.
+ * @returns {String}
+ * @examples
+ *
+ *    require("keyboard/hotkeys").toString({
+ *      key: 'b',
+ *      modifiers: [ 'control', 'shift' ]
+ *    }, '+');
+ *    // 'control+shift+b
+ *
+ */
+var toString = exports.toString = function toString(hotkey, separator) {
+  let keys = hotkey.modifiers.slice();
+  keys.push(hotkey.key);
+  return keys.join(separator || SEPARATOR);
+};
+
+/**
+ * Utility function takes `key` name and returns `true` if it's function key
+ * (F1, ..., F24) and `false` if it's not.
+ */
+var isFunctionKey = exports.isFunctionKey = function isFunctionKey(key) {
+  var $
+  return key[0].toLowerCase() === 'f' &&
+         ($ = parseInt(key.substr(1)), 0 < $ && $ < 25);
+};
diff --git a/toolkit/jetpack/sdk/l10n.js b/toolkit/jetpack/sdk/l10n.js
new file mode 100644
index 000000000..db5a9d7b6
--- /dev/null
+++ b/toolkit/jetpack/sdk/l10n.js
@@ -0,0 +1,91 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const json = require("./l10n/json/core");
+const { get: getKey } = require("./l10n/core");
+const properties = require("./l10n/properties/core");
+const { getRulesForLocale } = require("./l10n/plural-rules");
+
+// Retrieve the plural mapping function
+var pluralMappingFunction = getRulesForLocale(json.language()) ||
+                            getRulesForLocale("en");
+
+exports.get = function get(k) {
+  // For now, we only accept a "string" as first argument
+  // TODO: handle plural forms in gettext pattern
+  if (typeof k !== "string")
+    throw new Error("First argument of localization method should be a string");
+  let n = arguments[1];
+
+  // Get translation from big hashmap or default to hard coded string:
+  let localized = getKey(k, n) || k;
+
+  // # Simplest usecase:
+  //   // String hard coded in source code:
+  //   _("Hello world")
+  //   // Identifier of a key stored in properties file
+  //   _("helloString")
+  if (arguments.length <= 1)
+    return localized;
+
+  let args = Array.slice(arguments);
+  let placeholders = [null, ...args.slice(typeof(n) === "number" ? 2 : 1)];
+
+  if (typeof localized == "object" && "other" in localized) {
+    // # Plural form:
+    //   // Strings hard coded in source code:
+    //   _(["One download", "%d downloads"], 10);
+    //   // Identifier of a key stored in properties file
+    //   _("downloadNumber", 0);
+    let n = arguments[1];
+
+    // First handle simple universal forms that may not be mandatory
+    // for each language, (i.e. not different than 'other' form,
+    // but still usefull for better phrasing)
+    // For example 0 in english is the same form than 'other'
+    // but we accept 'zero' form if specified in localization file
+    if (n === 0 && "zero" in localized)
+      localized = localized["zero"];
+    else if (n === 1 && "one" in localized)
+      localized = localized["one"];
+    else if (n === 2 && "two" in localized)
+      localized = localized["two"];
+    else {
+      let pluralForm = pluralMappingFunction(n);
+      if (pluralForm in localized)
+        localized = localized[pluralForm];
+      else // Fallback in case of error: missing plural form
+        localized = localized["other"];
+    }
+
+    // Simulate a string with one placeholder:
+    args = [null, n];
+  }
+
+  // # String with placeholders:
+  //   // Strings hard coded in source code:
+  //   _("Hello %s", username)
+  //   // Identifier of a key stored in properties file
+  //   _("helloString", username)
+  // * We supports `%1s`, `%2s`, ... pattern in order to change arguments order
+  // in translation.
+  // * In case of plural form, we has `%d` instead of `%s`.
+  let offset = 1;
+  if (placeholders.length > 1) {
+    args = placeholders;
+  }
+
+  localized = localized.replace(/%(\d*)[sd]/g, (v, n) => {
+    let rv = args[n != "" ? n : offset];
+    offset++;
+    return rv;
+  });
+
+  return localized;
+}
diff --git a/toolkit/jetpack/sdk/l10n/core.js b/toolkit/jetpack/sdk/l10n/core.js
new file mode 100644
index 000000000..2f8f84c04
--- /dev/null
+++ b/toolkit/jetpack/sdk/l10n/core.js
@@ -0,0 +1,9 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const json = require("./json/core");
+const properties = require("./properties/core");
+
+exports.get = json.usingJSON ? json.get : properties.get;
diff --git a/toolkit/jetpack/sdk/l10n/html.js b/toolkit/jetpack/sdk/l10n/html.js
new file mode 100644
index 000000000..fa2cf9cf0
--- /dev/null
+++ b/toolkit/jetpack/sdk/l10n/html.js
@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { processes, remoteRequire } = require("../remote/parent");
+remoteRequire("sdk/content/l10n-html");
+
+var enabled = false;
+function enable() {
+  if (!enabled) {
+    processes.port.emit("sdk/l10n/html/enable");
+    enabled = true;
+  }
+}
+exports.enable = enable;
+
+function disable() {
+  if (enabled) {
+    processes.port.emit("sdk/l10n/html/disable");
+    enabled = false;
+  }
+}
+exports.disable = disable;
+
+processes.forEvery(process => {
+  process.port.emit(enabled ? "sdk/l10n/html/enable" : "sdk/l10n/html/disable");
+});
diff --git a/toolkit/jetpack/sdk/l10n/json/core.js b/toolkit/jetpack/sdk/l10n/json/core.js
new file mode 100644
index 000000000..af52f956f
--- /dev/null
+++ b/toolkit/jetpack/sdk/l10n/json/core.js
@@ -0,0 +1,36 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ "use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+var usingJSON = false;
+var hash = {}, bestMatchingLocale = null;
+try {
+  let data = require("@l10n/data");
+  hash = data.hash;
+  bestMatchingLocale = data.bestMatchingLocale;
+  usingJSON = true;
+}
+catch(e) {}
+
+exports.usingJSON = usingJSON;
+
+// Returns the translation for a given key, if available.
+exports.get = function get(k) {
+  return k in hash ? hash[k] : null;
+}
+
+// Returns the full length locale code: ja-JP-mac, en-US or fr
+exports.locale = function locale() {
+  return bestMatchingLocale;
+}
+
+// Returns the short locale code: ja, en, fr
+exports.language = function language() {
+  return bestMatchingLocale ? bestMatchingLocale.split("-")[0].toLowerCase()
+                            : "en";
+}
diff --git a/toolkit/jetpack/sdk/l10n/loader.js b/toolkit/jetpack/sdk/l10n/loader.js
new file mode 100644
index 000000000..60e219e44
--- /dev/null
+++ b/toolkit/jetpack/sdk/l10n/loader.js
@@ -0,0 +1,70 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci } = require("chrome");
+const { getPreferedLocales, findClosestLocale } = require("./locale");
+const { readURI } = require("../net/url");
+const { resolve } = require("../core/promise");
+
+function parseJsonURI(uri) {
+  return readURI(uri).
+    then(JSON.parse).
+    then(null, function (error) {
+      throw Error("Failed to parse locale file:\n" + uri + "\n" + error);
+    });
+}
+
+// Returns the array stored in `locales.json` manifest that list available
+// locales files
+function getAvailableLocales(rootURI) {
+  let uri = rootURI + "locales.json";
+  return parseJsonURI(uri).then(function (manifest) {
+    return "locales" in manifest &&
+           Array.isArray(manifest.locales) ?
+           manifest.locales : [];
+  });
+}
+
+// Returns URI of the best locales file to use from the XPI
+function getBestLocale(rootURI) {
+  // Read localization manifest file that contains list of available languages
+  return getAvailableLocales(rootURI).then(function (availableLocales) {
+    // Retrieve list of prefered locales to use
+    let preferedLocales = getPreferedLocales();
+
+    // Compute the most preferable locale to use by using these two lists
+    return findClosestLocale(availableLocales, preferedLocales);
+  });
+}
+
+/**
+ * Read localization files and returns a promise of data to put in `@l10n/data`
+ * pseudo module, in order to allow l10n/json/core to fetch it.
+ */
+exports.load = function load(rootURI) {
+  // First, search for a locale file:
+  return getBestLocale(rootURI).then(function (bestMatchingLocale) {
+    // It may be null if the addon doesn't have any locale file
+    if (!bestMatchingLocale)
+      return resolve(null);
+
+    let localeURI = rootURI + "locale/" + bestMatchingLocale + ".json";
+
+    // Locale files only contains one big JSON object that is used as
+    // an hashtable of: "key to translate" => "translated key"
+    // TODO: We are likely to change this in order to be able to overload
+    //       a specific key translation. For a specific package, module or line?
+    return parseJsonURI(localeURI).then(function (json) {
+      return {
+        hash: json,
+        bestMatchingLocale: bestMatchingLocale
+      };
+    });
+  });
+}
diff --git a/toolkit/jetpack/sdk/l10n/locale.js b/toolkit/jetpack/sdk/l10n/locale.js
new file mode 100644
index 000000000..950b33b20
--- /dev/null
+++ b/toolkit/jetpack/sdk/l10n/locale.js
@@ -0,0 +1,127 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const prefs = require("../preferences/service");
+const { Cu, Cc, Ci } = require("chrome");
+const { Services } = Cu.import("resource://gre/modules/Services.jsm");
+
+/**
+ * Gets the currently selected locale for display.
+ * Gets all usable locale that we can use sorted by priority of relevance
+ * @return  Array of locales, begins with highest priority
+ */
+const PREF_MATCH_OS_LOCALE  = "intl.locale.matchOS";
+const PREF_SELECTED_LOCALE  = "general.useragent.locale";
+const PREF_ACCEPT_LANGUAGES = "intl.accept_languages";
+
+function getPreferedLocales(caseSensitve) {
+  let locales = [];
+  function addLocale(locale) {
+    locale = locale.trim();
+    if (!caseSensitve)
+      locale = locale.toLowerCase();
+    if (locales.indexOf(locale) === -1)
+      locales.push(locale);
+  }
+
+  // Most important locale is OS one. But we use it, only if
+  // "intl.locale.matchOS" pref is set to `true`.
+  // Currently only used for multi-locales mobile builds.
+  // http://mxr.mozilla.org/mozilla-central/source/mobile/android/installer/Makefile.in#46
+  if (prefs.get(PREF_MATCH_OS_LOCALE, false)) {
+    let localeService = Cc["@mozilla.org/intl/nslocaleservice;1"].
+                        getService(Ci.nsILocaleService);
+    let osLocale = localeService.getLocaleComponentForUserAgent();
+    addLocale(osLocale);
+  }
+
+  // In some cases, mainly on Fennec and on Linux version,
+  // `general.useragent.locale` is a special 'localized' value, like:
+  // "chrome://global/locale/intl.properties"
+  let browserUiLocale = prefs.getLocalized(PREF_SELECTED_LOCALE, "") ||
+                        prefs.get(PREF_SELECTED_LOCALE, "");
+  if (browserUiLocale)
+    addLocale(browserUiLocale);
+
+  // Third priority is the list of locales used for web content
+  let contentLocales = prefs.getLocalized(PREF_ACCEPT_LANGUAGES, "") ||
+                       prefs.get(PREF_ACCEPT_LANGUAGES, "");
+  if (contentLocales) {
+    // This list is a string of locales seperated by commas.
+    // There is spaces after commas, so strip each item
+    for (let locale of contentLocales.split(","))
+      addLocale(locale.replace(/(^\s+)|(\s+$)/g, ""));
+  }
+
+  // Finally, we ensure that en-US is the final fallback if it wasn't added
+  addLocale("en-US");
+
+  return locales;
+}
+exports.getPreferedLocales = getPreferedLocales;
+
+/**
+ * Selects the closest matching locale from a list of locales.
+ *
+ * @param  aLocales
+ *         An array of available locales
+ * @param  aMatchLocales
+ *         An array of prefered locales, ordered by priority. Most wanted first.
+ *         Locales have to be in lowercase.
+ *         If null, uses getPreferedLocales() results
+ * @return the best match for the currently selected locale
+ *
+ * Stolen from http://dxr.mozilla.org/mozilla-central/source/toolkit/mozapps/extensions/internal/XPIProvider.jsm
+ */
+exports.findClosestLocale = function findClosestLocale(aLocales, aMatchLocales) {
+  aMatchLocales = aMatchLocales || getPreferedLocales();
+
+  // Holds the best matching localized resource
+  let bestmatch = null;
+  // The number of locale parts it matched with
+  let bestmatchcount = 0;
+  // The number of locale parts in the match
+  let bestpartcount = 0;
+
+  for (let locale of aMatchLocales) {
+    let lparts = locale.split("-");
+    for (let localized of aLocales) {
+      let found = localized.toLowerCase();
+      // Exact match is returned immediately
+      if (locale == found)
+        return localized;
+
+      let fparts = found.split("-");
+      /* If we have found a possible match and this one isn't any longer
+         then we dont need to check further. */
+      if (bestmatch && fparts.length < bestmatchcount)
+        continue;
+
+      // Count the number of parts that match
+      let maxmatchcount = Math.min(fparts.length, lparts.length);
+      let matchcount = 0;
+      while (matchcount < maxmatchcount &&
+             fparts[matchcount] == lparts[matchcount])
+        matchcount++;
+
+      /* If we matched more than the last best match or matched the same and
+         this locale is less specific than the last best match. */
+      if (matchcount > bestmatchcount ||
+         (matchcount == bestmatchcount && fparts.length < bestpartcount)) {
+        bestmatch = localized;
+        bestmatchcount = matchcount;
+        bestpartcount = fparts.length;
+      }
+    }
+    // If we found a valid match for this locale return it
+    if (bestmatch)
+      return bestmatch;
+  }
+  return null;
+}
diff --git a/toolkit/jetpack/sdk/l10n/plural-rules.js b/toolkit/jetpack/sdk/l10n/plural-rules.js
new file mode 100644
index 000000000..a3ef48a5e
--- /dev/null
+++ b/toolkit/jetpack/sdk/l10n/plural-rules.js
@@ -0,0 +1,407 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// This file is automatically generated with /python-lib/plural-rules-generator.py
+// Fetching data from: http://unicode.org/repos/cldr/trunk/common/supplemental/plurals.xml
+
+// Mapping of short locale name == to == > rule index in following list
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const LOCALES_TO_RULES = {
+  "af": 3, 
+  "ak": 4, 
+  "am": 4, 
+  "ar": 1, 
+  "asa": 3, 
+  "az": 0, 
+  "be": 11, 
+  "bem": 3, 
+  "bez": 3, 
+  "bg": 3, 
+  "bh": 4, 
+  "bm": 0, 
+  "bn": 3, 
+  "bo": 0, 
+  "br": 20, 
+  "brx": 3, 
+  "bs": 11, 
+  "ca": 3, 
+  "cgg": 3, 
+  "chr": 3, 
+  "cs": 12, 
+  "cy": 17, 
+  "da": 3, 
+  "de": 3, 
+  "dv": 3, 
+  "dz": 0, 
+  "ee": 3, 
+  "el": 3, 
+  "en": 3, 
+  "eo": 3, 
+  "es": 3, 
+  "et": 3, 
+  "eu": 3, 
+  "fa": 0, 
+  "ff": 5, 
+  "fi": 3, 
+  "fil": 4, 
+  "fo": 3, 
+  "fr": 5, 
+  "fur": 3, 
+  "fy": 3, 
+  "ga": 8, 
+  "gd": 24, 
+  "gl": 3, 
+  "gsw": 3, 
+  "gu": 3, 
+  "guw": 4, 
+  "gv": 23, 
+  "ha": 3, 
+  "haw": 3, 
+  "he": 2, 
+  "hi": 4, 
+  "hr": 11, 
+  "hu": 0, 
+  "id": 0, 
+  "ig": 0, 
+  "ii": 0, 
+  "is": 3, 
+  "it": 3, 
+  "iu": 7, 
+  "ja": 0, 
+  "jmc": 3, 
+  "jv": 0, 
+  "ka": 0, 
+  "kab": 5, 
+  "kaj": 3, 
+  "kcg": 3, 
+  "kde": 0, 
+  "kea": 0, 
+  "kk": 3, 
+  "kl": 3, 
+  "km": 0, 
+  "kn": 0, 
+  "ko": 0, 
+  "ksb": 3, 
+  "ksh": 21, 
+  "ku": 3, 
+  "kw": 7, 
+  "lag": 18, 
+  "lb": 3, 
+  "lg": 3, 
+  "ln": 4, 
+  "lo": 0, 
+  "lt": 10, 
+  "lv": 6, 
+  "mas": 3, 
+  "mg": 4, 
+  "mk": 16, 
+  "ml": 3, 
+  "mn": 3, 
+  "mo": 9, 
+  "mr": 3, 
+  "ms": 0, 
+  "mt": 15, 
+  "my": 0, 
+  "nah": 3, 
+  "naq": 7, 
+  "nb": 3, 
+  "nd": 3, 
+  "ne": 3, 
+  "nl": 3, 
+  "nn": 3, 
+  "no": 3, 
+  "nr": 3, 
+  "nso": 4, 
+  "ny": 3, 
+  "nyn": 3, 
+  "om": 3, 
+  "or": 3, 
+  "pa": 3, 
+  "pap": 3, 
+  "pl": 13, 
+  "ps": 3, 
+  "pt": 3, 
+  "rm": 3, 
+  "ro": 9, 
+  "rof": 3, 
+  "ru": 11, 
+  "rwk": 3, 
+  "sah": 0, 
+  "saq": 3, 
+  "se": 7, 
+  "seh": 3, 
+  "ses": 0, 
+  "sg": 0, 
+  "sh": 11, 
+  "shi": 19, 
+  "sk": 12, 
+  "sl": 14, 
+  "sma": 7, 
+  "smi": 7, 
+  "smj": 7, 
+  "smn": 7, 
+  "sms": 7, 
+  "sn": 3, 
+  "so": 3, 
+  "sq": 3, 
+  "sr": 11, 
+  "ss": 3, 
+  "ssy": 3, 
+  "st": 3, 
+  "sv": 3, 
+  "sw": 3, 
+  "syr": 3, 
+  "ta": 3, 
+  "te": 3, 
+  "teo": 3, 
+  "th": 0, 
+  "ti": 4, 
+  "tig": 3, 
+  "tk": 3, 
+  "tl": 4, 
+  "tn": 3, 
+  "to": 0, 
+  "tr": 0, 
+  "ts": 3, 
+  "tzm": 22, 
+  "uk": 11, 
+  "ur": 3, 
+  "ve": 3, 
+  "vi": 0, 
+  "vun": 3, 
+  "wa": 4, 
+  "wae": 3, 
+  "wo": 0, 
+  "xh": 3, 
+  "xog": 3, 
+  "yo": 0, 
+  "zh": 0, 
+  "zu": 3
+};
+
+// Utility functions for plural rules methods
+function isIn(n, list) {
+  return list.indexOf(n) !== -1;
+}
+function isBetween(n, start, end) {
+  return start <= n && n <= end;
+}
+
+// List of all plural rules methods, that maps an integer to the plural form name to use
+const RULES = {
+  "0": function (n) {
+    
+    return "other"
+  },
+  "1": function (n) {
+    if ((isBetween((n % 100), 3, 10)))
+      return "few";
+    if (n == 0)
+      return "zero";
+    if ((isBetween((n % 100), 11, 99)))
+      return "many";
+    if (n == 2)
+      return "two";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "2": function (n) {
+    if (n != 0 && (n % 10) == 0)
+      return "many";
+    if (n == 2)
+      return "two";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "3": function (n) {
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "4": function (n) {
+    if ((isBetween(n, 0, 1)))
+      return "one";
+    return "other"
+  },
+  "5": function (n) {
+    if ((isBetween(n, 0, 2)) && n != 2)
+      return "one";
+    return "other"
+  },
+  "6": function (n) {
+    if (n == 0)
+      return "zero";
+    if ((n % 10) == 1 && (n % 100) != 11)
+      return "one";
+    return "other"
+  },
+  "7": function (n) {
+    if (n == 2)
+      return "two";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "8": function (n) {
+    if ((isBetween(n, 3, 6)))
+      return "few";
+    if ((isBetween(n, 7, 10)))
+      return "many";
+    if (n == 2)
+      return "two";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "9": function (n) {
+    if (n == 0 || n != 1 && (isBetween((n % 100), 1, 19)))
+      return "few";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "10": function (n) {
+    if ((isBetween((n % 10), 2, 9)) && !(isBetween((n % 100), 11, 19)))
+      return "few";
+    if ((n % 10) == 1 && !(isBetween((n % 100), 11, 19)))
+      return "one";
+    return "other"
+  },
+  "11": function (n) {
+    if ((isBetween((n % 10), 2, 4)) && !(isBetween((n % 100), 12, 14)))
+      return "few";
+    if ((n % 10) == 0 || (isBetween((n % 10), 5, 9)) || (isBetween((n % 100), 11, 14)))
+      return "many";
+    if ((n % 10) == 1 && (n % 100) != 11)
+      return "one";
+    return "other"
+  },
+  "12": function (n) {
+    if ((isBetween(n, 2, 4)))
+      return "few";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "13": function (n) {
+    if ((isBetween((n % 10), 2, 4)) && !(isBetween((n % 100), 12, 14)))
+      return "few";
+    if (n != 1 && (isBetween((n % 10), 0, 1)) || (isBetween((n % 10), 5, 9)) || (isBetween((n % 100), 12, 14)))
+      return "many";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "14": function (n) {
+    if ((isBetween((n % 100), 3, 4)))
+      return "few";
+    if ((n % 100) == 2)
+      return "two";
+    if ((n % 100) == 1)
+      return "one";
+    return "other"
+  },
+  "15": function (n) {
+    if (n == 0 || (isBetween((n % 100), 2, 10)))
+      return "few";
+    if ((isBetween((n % 100), 11, 19)))
+      return "many";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "16": function (n) {
+    if ((n % 10) == 1 && n != 11)
+      return "one";
+    return "other"
+  },
+  "17": function (n) {
+    if (n == 3)
+      return "few";
+    if (n == 0)
+      return "zero";
+    if (n == 6)
+      return "many";
+    if (n == 2)
+      return "two";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "18": function (n) {
+    if (n == 0)
+      return "zero";
+    if ((isBetween(n, 0, 2)) && n != 0 && n != 2)
+      return "one";
+    return "other"
+  },
+  "19": function (n) {
+    if ((isBetween(n, 2, 10)))
+      return "few";
+    if ((isBetween(n, 0, 1)))
+      return "one";
+    return "other"
+  },
+  "20": function (n) {
+    if ((isBetween((n % 10), 3, 4) || ((n % 10) == 9)) && !(isBetween((n % 100), 10, 19) || isBetween((n % 100), 70, 79) || isBetween((n % 100), 90, 99)))
+      return "few";
+    if ((n % 1000000) == 0 && n != 0)
+      return "many";
+    if ((n % 10) == 2 && !isIn((n % 100), [12, 72, 92]))
+      return "two";
+    if ((n % 10) == 1 && !isIn((n % 100), [11, 71, 91]))
+      return "one";
+    return "other"
+  },
+  "21": function (n) {
+    if (n == 0)
+      return "zero";
+    if (n == 1)
+      return "one";
+    return "other"
+  },
+  "22": function (n) {
+    if ((isBetween(n, 0, 1)) || (isBetween(n, 11, 99)))
+      return "one";
+    return "other"
+  },
+  "23": function (n) {
+    if ((isBetween((n % 10), 1, 2)) || (n % 20) == 0)
+      return "one";
+    return "other"
+  },
+  "24": function (n) {
+    if ((isBetween(n, 3, 10) || isBetween(n, 13, 19)))
+      return "few";
+    if (isIn(n, [2, 12]))
+      return "two";
+    if (isIn(n, [1, 11]))
+      return "one";
+    return "other"
+  },
+};
+
+/**
+  * Return a function that gives the plural form name for a given integer
+  * for the specified `locale`
+  *   let fun = getRulesForLocale('en');
+  *   fun(1)    -> 'one'
+  *   fun(0)    -> 'other'
+  *   fun(1000) -> 'other'
+  */
+exports.getRulesForLocale = function getRulesForLocale(locale) {
+  let index = LOCALES_TO_RULES[locale];
+  if (!(index in RULES)) {
+    console.warn('Plural form unknown for locale "' + locale + '"');
+    return function () { return "other"; };
+  }
+  return RULES[index];
+}
+
diff --git a/toolkit/jetpack/sdk/l10n/prefs.js b/toolkit/jetpack/sdk/l10n/prefs.js
new file mode 100644
index 000000000..8ee26fc5b
--- /dev/null
+++ b/toolkit/jetpack/sdk/l10n/prefs.js
@@ -0,0 +1,51 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { on } = require("../system/events");
+const core = require("./core");
+const { id: jetpackId } = require('../self');
+
+const OPTIONS_DISPLAYED = "addon-options-displayed";
+
+function enable() {
+  on(OPTIONS_DISPLAYED, onOptionsDisplayed);  
+}
+exports.enable = enable;
+
+function onOptionsDisplayed({ subject: document, data: addonId }) {
+  if (addonId !== jetpackId)
+    return;
+  localizeInlineOptions(document);
+}
+
+function localizeInlineOptions(document) {
+  let query = 'setting[data-jetpack-id="' + jetpackId + '"][pref-name], ' +
+              'button[data-jetpack-id="' + jetpackId + '"][pref-name]';
+  let nodes = document.querySelectorAll(query);
+  for (let node of nodes) {
+    let name = node.getAttribute("pref-name");
+    if (node.tagName == "setting") {
+      let desc = core.get(name + "_description");
+      if (desc)
+        node.setAttribute("desc", desc);
+      let title = core.get(name + "_title");
+      if (title)
+        node.setAttribute("title", title);
+
+      for (let item of node.querySelectorAll("menuitem, radio")) {
+          let key = name + "_options." + item.getAttribute("label");
+          let label = core.get(key);
+          if (label)
+            item.setAttribute("label", label);
+      }
+    }
+    else if (node.tagName == "button") {
+      let label = core.get(name + "_label");
+      if (label)
+        node.setAttribute("label", label);
+    }
+  }
+}
+exports.localizeInlineOptions = localizeInlineOptions;
diff --git a/toolkit/jetpack/sdk/l10n/properties/core.js b/toolkit/jetpack/sdk/l10n/properties/core.js
new file mode 100644
index 000000000..7a9081d0b
--- /dev/null
+++ b/toolkit/jetpack/sdk/l10n/properties/core.js
@@ -0,0 +1,87 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Cu } = require("chrome");
+const { newURI } = require('../../url/utils')
+const { getRulesForLocale } = require("../plural-rules");
+const { getPreferedLocales } = require('../locale');
+const { rootURI } = require("@loader/options");
+const { Services } = Cu.import("resource://gre/modules/Services.jsm", {});
+
+const baseURI = rootURI + "locale/";
+const preferedLocales = getPreferedLocales(true);
+
+// Make sure we don't get stale data after an update
+// (See Bug 1300735 for rationale).
+Services.strings.flushBundles();
+
+function getLocaleURL(locale) {
+  // if the locale is a valid chrome URI, return it
+  try {
+    let uri = newURI(locale);
+    if (uri.scheme == 'chrome')
+      return uri.spec;
+  }
+  catch(_) {}
+  // otherwise try to construct the url
+  return baseURI + locale + ".properties";
+}
+
+function getKey(locale, key) {
+  let bundle = Services.strings.createBundle(getLocaleURL(locale));
+  try {
+    return bundle.GetStringFromName(key) + "";
+  }
+  catch (_) {}
+  return undefined;
+}
+
+function get(key, n, locales) {
+  // try this locale
+  let locale = locales.shift();
+  let localized;
+
+  if (typeof n == 'number') {
+    if (n == 0) {
+      localized = getKey(locale, key + '[zero]');
+    }
+    else if (n == 1) {
+      localized = getKey(locale, key + '[one]');
+    }
+    else if (n == 2) {
+      localized = getKey(locale, key + '[two]');
+    }
+
+    if (!localized) {
+      // Retrieve the plural mapping function
+      let pluralForm = (getRulesForLocale(locale.split("-")[0].toLowerCase()) ||
+                        getRulesForLocale("en"))(n);
+      localized = getKey(locale, key + '[' + pluralForm + ']');
+    }
+
+    if (!localized) {
+      localized = getKey(locale, key + '[other]');
+    }
+  }
+
+  if (!localized) {
+    localized = getKey(locale, key);
+  }
+
+  if (!localized) {
+    localized = getKey(locale, key + '[other]');
+  }
+
+  if (localized) {
+    return localized;
+  }
+
+  // try next locale
+  if (locales.length)
+    return get(key, n, locales);
+
+  return undefined;
+}
+exports.get = (k, n) => get(k, n, Array.slice(preferedLocales));
diff --git a/toolkit/jetpack/sdk/lang/functional.js b/toolkit/jetpack/sdk/lang/functional.js
new file mode 100644
index 000000000..66e30edfa
--- /dev/null
+++ b/toolkit/jetpack/sdk/lang/functional.js
@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Disclaimer: Some of the functions in this module implement APIs from
+// Jeremy Ashkenas's http://underscorejs.org/ library and all credits for
+// those goes to him.
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { defer, remit, delay, debounce,
+        throttle } = require("./functional/concurrent");
+const { method, invoke, partial, curry, compose, wrap, identity, memoize, once,
+        cache, complement, constant, when, apply, flip, field, query,
+        isInstance, chainable, is, isnt } = require("./functional/core");
+
+exports.defer = defer;
+exports.remit = remit;
+exports.delay = delay;
+exports.debounce = debounce;
+exports.throttle = throttle;
+
+exports.method = method;
+exports.invoke = invoke;
+exports.partial = partial;
+exports.curry = curry;
+exports.compose = compose;
+exports.wrap = wrap;
+exports.identity = identity;
+exports.memoize = memoize;
+exports.once = once;
+exports.cache = cache;
+exports.complement = complement;
+exports.constant = constant;
+exports.when = when;
+exports.apply = apply;
+exports.flip = flip;
+exports.field = field;
+exports.query = query;
+exports.isInstance = isInstance;
+exports.chainable = chainable;
+exports.is = is;
+exports.isnt = isnt;
diff --git a/toolkit/jetpack/sdk/lang/functional/concurrent.js b/toolkit/jetpack/sdk/lang/functional/concurrent.js
new file mode 100644
index 000000000..85e8cff46
--- /dev/null
+++ b/toolkit/jetpack/sdk/lang/functional/concurrent.js
@@ -0,0 +1,110 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Disclaimer: Some of the functions in this module implement APIs from
+// Jeremy Ashkenas's http://underscorejs.org/ library and all credits for
+// those goes to him.
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { arity, name, derive, invoke } = require("./helpers");
+const { setTimeout, clearTimeout, setImmediate } = require("../../timers");
+
+/**
+ * Takes a function and returns a wrapped one instead, calling which will call
+ * original function in the next turn of event loop. This is basically utility
+ * to do `setImmediate(function() { ... })`, with a difference that returned
+ * function is reused, instead of creating a new one each time. This also allows
+ * to use this functions as event listeners.
+ */
+const defer = f => derive(function(...args) {
+  setImmediate(invoke, f, args, this);
+}, f);
+exports.defer = defer;
+// Exporting `remit` alias as `defer` may conflict with promises.
+exports.remit = defer;
+
+/**
+ * Much like setTimeout, invokes function after wait milliseconds. If you pass
+ * the optional arguments, they will be forwarded on to the function when it is
+ * invoked.
+ */
+const delay = function delay(f, ms, ...args) {
+  setTimeout(() => f.apply(this, args), ms);
+};
+exports.delay = delay;
+
+/**
+ * From underscore's `_.debounce`
+ * http://underscorejs.org
+ * (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Underscore may be freely distributed under the MIT license.
+ */
+const debounce = function debounce (fn, wait) {
+  let timeout, args, context, timestamp, result;
+
+  let later = function () {
+    let last = Date.now() - timestamp;
+    if (last < wait) {
+      timeout = setTimeout(later, wait - last);
+    } else {
+      timeout = null;
+      result = fn.apply(context, args);
+      context = args = null;
+    }
+  };
+
+  return function (...aArgs) {
+    context = this;
+    args = aArgs;
+    timestamp  = Date.now();
+    if (!timeout) {
+      timeout = setTimeout(later, wait);
+    }
+
+    return result;
+  };
+};
+exports.debounce = debounce;
+
+/**
+ * From underscore's `_.throttle`
+ * http://underscorejs.org
+ * (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+ * Underscore may be freely distributed under the MIT license.
+ */
+const throttle = function throttle (func, wait, options) {
+  let context, args, result;
+  let timeout = null;
+  let previous = 0;
+  options || (options = {});
+  let later = function() {
+    previous = options.leading === false ? 0 : Date.now();
+    timeout = null;
+    result = func.apply(context, args);
+    context = args = null;
+  };
+  return function() {
+    let now = Date.now();
+    if (!previous && options.leading === false) previous = now;
+    let remaining = wait - (now - previous);
+    context = this;
+    args = arguments;
+    if (remaining <= 0) {
+      clearTimeout(timeout);
+      timeout = null;
+      previous = now;
+      result = func.apply(context, args);
+      context = args = null;
+    } else if (!timeout && options.trailing !== false) {
+      timeout = setTimeout(later, remaining);
+    }
+    return result;
+  };
+};
+exports.throttle = throttle;
diff --git a/toolkit/jetpack/sdk/lang/functional/core.js b/toolkit/jetpack/sdk/lang/functional/core.js
new file mode 100644
index 000000000..0d9143364
--- /dev/null
+++ b/toolkit/jetpack/sdk/lang/functional/core.js
@@ -0,0 +1,290 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Disclaimer: Some of the functions in this module implement APIs from
+// Jeremy Ashkenas's http://underscorejs.org/ library and all credits for
+// those goes to him.
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+}
+const { arity, name, derive, invoke } = require("./helpers");
+
+/**
+ * Takes variadic numeber of functions and returns composed one.
+ * Returned function pushes `this` pseudo-variable to the head
+ * of the passed arguments and invokes all the functions from
+ * left to right passing same arguments to them. Composite function
+ * returns return value of the right most funciton.
+ */
+const method = (...lambdas) => {
+  return function method(...args) {
+    args.unshift(this);
+    return lambdas.reduce((_, lambda) => lambda.apply(this, args),
+                          void(0));
+  };
+};
+exports.method = method;
+
+/**
+ * Invokes `callee` by passing `params` as an arguments and `self` as `this`
+ * pseudo-variable. Returns value that is returned by a callee.
+ * @param {Function} callee
+ *    Function to invoke.
+ * @param {Array} params
+ *    Arguments to invoke function with.
+ * @param {Object} self
+ *    Object to be passed as a `this` pseudo variable.
+ */
+exports.invoke = invoke;
+
+/**
+ * Takes a function and bind values to one or more arguments, returning a new
+ * function of smaller arity.
+ *
+ * @param {Function} fn
+ *    The function to partial
+ *
+ * @returns The new function with binded values
+ */
+const partial = (f, ...curried) => {
+  if (typeof(f) !== "function")
+    throw new TypeError(String(f) + " is not a function");
+
+  let fn = derive(function(...args) {
+    return f.apply(this, curried.concat(args));
+  }, f);
+  fn.arity = arity(f) - curried.length;
+  return fn;
+};
+exports.partial = partial;
+
+/**
+ * Returns function with implicit currying, which will continue currying until
+ * expected number of argument is collected. Expected number of arguments is
+ * determined by `fn.length`. Using this with variadic functions is stupid,
+ * so don't do it.
+ *
+ * @examples
+ *
+ * var sum = curry(function(a, b) {
+ *   return a + b
+ * })
+ * console.log(sum(2, 2)) // 4
+ * console.log(sum(2)(4)) // 6
+ */
+const curry = new function() {
+  const currier = (fn, arity, params) => {
+    // Function either continues to curry arguments or executes function
+    // if desired arguments have being collected.
+    const curried = function(...input) {
+      // Prepend all curried arguments to the given arguments.
+      if (params) input.unshift.apply(input, params);
+      // If expected number of arguments has being collected invoke fn,
+      // othrewise return curried version Otherwise continue curried.
+      return (input.length >= arity) ? fn.apply(this, input) :
+             currier(fn, arity, input);
+    };
+    curried.arity = arity - (params ? params.length : 0);
+
+    return curried;
+  };
+
+  return fn => currier(fn, arity(fn));
+};
+exports.curry = curry;
+
+/**
+ * Returns the composition of a list of functions, where each function consumes
+ * the return value of the function that follows. In math terms, composing the
+ * functions `f()`, `g()`, and `h()` produces `f(g(h()))`.
+ * @example
+ *
+ *   var greet = function(name) { return "hi: " + name; };
+ *   var exclaim = function(statement) { return statement + "!"; };
+ *   var welcome = compose(exclaim, greet);
+ *
+ *   welcome('moe');    // => 'hi: moe!'
+ */
+function compose(...lambdas) {
+  return function composed(...args) {
+    let index = lambdas.length;
+    while (0 <= --index)
+      args = [lambdas[index].apply(this, args)];
+
+    return args[0];
+  };
+}
+exports.compose = compose;
+
+/*
+ * Returns the first function passed as an argument to the second,
+ * allowing you to adjust arguments, run code before and after, and
+ * conditionally execute the original function.
+ * @example
+ *
+ *  var hello = function(name) { return "hello: " + name; };
+ *  hello = wrap(hello, function(f) {
+ *    return "before, " + f("moe") + ", after";
+ *  });
+ *
+ *  hello();    // => 'before, hello: moe, after'
+ */
+const wrap = (f, wrapper) => derive(function wrapped(...args) {
+  return wrapper.apply(this, [f].concat(args));
+}, f);
+exports.wrap = wrap;
+
+/**
+ * Returns the same value that is used as the argument. In math: f(x) = x
+ */
+const identity = value => value;
+exports.identity = identity;
+
+/**
+ * Memoizes a given function by caching the computed result. Useful for
+ * speeding up slow-running computations. If passed an optional hashFunction,
+ * it will be used to compute the hash key for storing the result, based on
+ * the arguments to the original function. The default hashFunction just uses
+ * the first argument to the memoized function as the key.
+ */
+const memoize = (f, hasher) => {
+  let memo = Object.create(null);
+  let cache = new WeakMap();
+  hasher = hasher || identity;
+  return derive(function memoizer(...args) {
+    const key = hasher.apply(this, args);
+    const type = typeof(key);
+    if (key && (type === "object" || type === "function")) {
+      if (!cache.has(key))
+        cache.set(key, f.apply(this, args));
+      return cache.get(key);
+    }
+    else {
+      if (!(key in memo))
+        memo[key] = f.apply(this, args);
+      return memo[key];
+    }
+  }, f);
+};
+exports.memoize = memoize;
+
+/*
+ * Creates a version of the function that can only be called one time. Repeated
+ * calls to the modified function will have no effect, returning the value from
+ * the original call. Useful for initialization functions, instead of having to
+ * set a boolean flag and then check it later.
+ */
+const once = f => {
+  let ran = false, cache;
+  return derive(function(...args) {
+    return ran ? cache : (ran = true, cache = f.apply(this, args));
+  }, f);
+};
+exports.once = once;
+// export cache as once will may be conflicting with event once a lot.
+exports.cache = once;
+
+// Takes a `f` function and returns a function that takes the same
+// arguments as `f`, has the same effects, if any, and returns the
+// opposite truth value.
+const complement = f => derive(function(...args) {
+  return args.length < arity(f) ? complement(partial(f, ...args)) :
+         !f.apply(this, args);
+}, f);
+exports.complement = complement;
+
+// Constructs function that returns `x` no matter what is it
+// invoked with.
+const constant = x => _ => x;
+exports.constant = constant;
+
+// Takes `p` predicate, `consequent` function and an optional
+// `alternate` function and composes function that returns
+// application of arguments over `consequent` if application over
+// `p` is `true` otherwise returns application over `alternate`.
+// If `alternate` is not a function returns `undefined`.
+const when = (p, consequent, alternate) => {
+  if (typeof(alternate) !== "function" && alternate !== void(0))
+    throw TypeError("alternate must be a function");
+  if (typeof(consequent) !== "function")
+    throw TypeError("consequent must be a function");
+
+  return function(...args) {
+    return p.apply(this, args) ?
+           consequent.apply(this, args) :
+           alternate && alternate.apply(this, args);
+  };
+};
+exports.when = when;
+
+// Apply function that behaves as `apply` does in lisp:
+// apply(f, x, [y, z]) => f.apply(f, [x, y, z])
+// apply(f, x) => f.apply(f, [x])
+const apply = (f, ...rest) => f.apply(f, rest.concat(rest.pop()));
+exports.apply = apply;
+
+// Returns function identical to given `f` but with flipped order
+// of arguments.
+const flip = f => derive(function(...args) {
+  return f.apply(this, args.reverse());
+}, f);
+exports.flip = flip;
+
+// Takes field `name` and `target` and returns value of that field.
+// If `target` is `null` or `undefined` it would be returned back
+// instead of attempt to access it's field. Function is implicitly
+// curried, this allows accessor function generation by calling it
+// with only `name` argument.
+const field = curry((name, target) =>
+  // Note: Permisive `==` is intentional.
+  target == null ? target : target[name]);
+exports.field = field;
+
+// Takes `.` delimited string representing `path` to a nested field
+// and a `target` to get it from. For convinience function is
+// implicitly curried, there for accessors can be created by invoking
+// it with just a `path` argument.
+const query = curry((path, target) => {
+  const names = path.split(".");
+  const count = names.length;
+  let index = 0;
+  let result = target;
+  // Note: Permisive `!=` is intentional.
+  while (result != null && index < count) {
+    result = result[names[index]];
+    index = index + 1;
+  }
+  return result;
+});
+exports.query = query;
+
+// Takes `Type` (constructor function) and a `value` and returns
+// `true` if `value` is instance of the given `Type`. Function is
+// implicitly curried this allows predicate generation by calling
+// function with just first argument.
+const isInstance = curry((Type, value) => value instanceof Type);
+exports.isInstance = isInstance;
+
+/*
+ * Takes a funtion and returns a wrapped function that returns `this`
+ */
+const chainable = f => derive(function(...args) {
+  f.apply(this, args);
+  return this;
+}, f);
+exports.chainable = chainable;
+
+// Functions takes `expected` and `actual` values and returns `true` if
+// `expected === actual`. Returns curried function if called with less then
+// two arguments.
+//
+// [ 1, 0, 1, 0, 1 ].map(is(1)) // => [ true, false, true, false, true ]
+const is = curry((expected, actual) => actual === expected);
+exports.is = is;
+
+const isnt = complement(is);
+exports.isnt = isnt;
diff --git a/toolkit/jetpack/sdk/lang/functional/helpers.js b/toolkit/jetpack/sdk/lang/functional/helpers.js
new file mode 100644
index 000000000..60f4e3300
--- /dev/null
+++ b/toolkit/jetpack/sdk/lang/functional/helpers.js
@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Disclaimer: Some of the functions in this module implement APIs from
+// Jeremy Ashkenas's http://underscorejs.org/ library and all credits for
+// those goes to him.
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+}
+
+const arity = f => f.arity || f.length;
+exports.arity = arity;
+
+const name = f => f.displayName || f.name;
+exports.name = name;
+
+const derive = (f, source) => {
+  f.displayName = name(source);
+  f.arity = arity(source);
+  return f;
+};
+exports.derive = derive;
+
+const invoke = (callee, params, self) => callee.apply(self, params);
+exports.invoke = invoke;
diff --git a/toolkit/jetpack/sdk/lang/type.js b/toolkit/jetpack/sdk/lang/type.js
new file mode 100644
index 000000000..b50e6be4c
--- /dev/null
+++ b/toolkit/jetpack/sdk/lang/type.js
@@ -0,0 +1,388 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+/**
+ * Returns `true` if `value` is `undefined`.
+ * @examples
+ *    var foo; isUndefined(foo); // true
+ *    isUndefined(0); // false
+ */
+function isUndefined(value) {
+  return value === undefined;
+}
+exports.isUndefined = isUndefined;
+
+/**
+ * Returns `true` if value is `null`.
+ * @examples
+ *    isNull(null); // true
+ *    isNull(undefined); // false
+ */
+function isNull(value) {
+  return value === null;
+}
+exports.isNull = isNull;
+
+/**
+ * Returns `true` if value is `null` or `undefined`.
+ * It's equivalent to `== null`, but resolve the ambiguity of the writer
+ * intention, makes clear that he's clearly checking both `null` and `undefined`
+ * values, and it's not a typo for `=== null`.
+ */
+function isNil(value) {
+  return value === null || value === undefined;
+}
+exports.isNil = isNil;
+
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+exports.isBoolean = isBoolean;
+/**
+ * Returns `true` if value is a string.
+ * @examples
+ *    isString("moe"); // true
+ */
+function isString(value) {
+  return typeof value === "string";
+}
+exports.isString = isString;
+
+/**
+ * Returns `true` if `value` is a number.
+ * @examples
+ *    isNumber(8.4 * 5); // true
+ */
+function isNumber(value) {
+  return typeof value === "number";
+}
+exports.isNumber = isNumber;
+
+/**
+ * Returns `true` if `value` is a `RegExp`.
+ * @examples
+ *    isRegExp(/moe/); // true
+ */
+function isRegExp(value) {
+  return isObject(value) && instanceOf(value, RegExp);
+}
+exports.isRegExp = isRegExp;
+
+/**
+ * Returns true if `value` is a `Date`.
+ * @examples
+ *    isDate(new Date()); // true
+ */
+function isDate(value) {
+  return isObject(value) && instanceOf(value, Date);
+}
+exports.isDate = isDate;
+
+/**
+ * Returns true if object is a Function.
+ * @examples
+ *    isFunction(function foo(){}) // true
+ */
+function isFunction(value) {
+    return typeof value === "function";
+}
+exports.isFunction = isFunction;
+
+/**
+ * Returns `true` if `value` is an object (please note that `null` is considered
+ * to be an atom and not an object).
+ * @examples
+ *    isObject({}) // true
+ *    isObject(null) // false
+ */
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+exports.isObject = isObject;
+
+/**
+ * Detect whether a value is a generator.
+ *
+ * @param aValue
+ *        The value to identify.
+ * @return A boolean indicating whether the value is a generator.
+ */
+function isGenerator(aValue) {
+  return !!(aValue && aValue.isGenerator && aValue.isGenerator());
+}
+exports.isGenerator = isGenerator;
+
+/**
+ * Returns true if `value` is an Array.
+ * @examples
+ *    isArray([1, 2, 3])  // true
+ *    isArray({ 0: 'foo', length: 1 }) // false
+ */
+var isArray = Array.isArray;
+exports.isArray = isArray;
+
+/**
+ * Returns `true` if `value` is an Arguments object.
+ * @examples
+ *    (function(){ return isArguments(arguments); })(1, 2, 3); // true
+ *    isArguments([1,2,3]); // false
+ */
+function isArguments(value) {
+  return Object.prototype.toString.call(value) === "[object Arguments]";
+}
+exports.isArguments = isArguments;
+
+var isMap = value => Object.prototype.toString.call(value) === "[object Map]"
+exports.isMap = isMap;
+
+var isSet = value => Object.prototype.toString.call(value) === "[object Set]"
+exports.isSet = isSet;
+
+/**
+ * Returns true if it is a primitive `value`. (null, undefined, number,
+ * boolean, string)
+ * @examples
+ *    isPrimitive(3) // true
+ *    isPrimitive('foo') // true
+ *    isPrimitive({ bar: 3 }) // false
+ */
+function isPrimitive(value) {
+  return !isFunction(value) && !isObject(value);
+}
+exports.isPrimitive = isPrimitive;
+
+/**
+ * Returns `true` if given `object` is flat (it is direct decedent of
+ * `Object.prototype` or `null`).
+ * @examples
+ *    isFlat({}) // true
+ *    isFlat(new Type()) // false
+ */
+function isFlat(object) {
+  return isObject(object) && (isNull(Object.getPrototypeOf(object)) ||
+                              isNull(Object.getPrototypeOf(
+                                     Object.getPrototypeOf(object))));
+}
+exports.isFlat = isFlat;
+
+/**
+ * Returns `true` if object contains no values.
+ */
+function isEmpty(object) {
+  if (isObject(object)) {
+    for (var key in object)
+      return false;
+    return true;
+  }
+  return false;
+}
+exports.isEmpty = isEmpty;
+
+/**
+ * Returns `true` if `value` is an array / flat object containing only atomic
+ * values and other flat objects.
+ */
+function isJSON(value, visited) {
+    // Adding value to array of visited values.
+    (visited || (visited = [])).push(value);
+            // If `value` is an atom return `true` cause it's valid JSON.
+    return  isPrimitive(value) ||
+            // If `value` is an array of JSON values that has not been visited
+            // yet.
+            (isArray(value) &&  value.every(function(element) {
+                                  return isJSON(element, visited);
+                                })) ||
+            // If `value` is a plain object containing properties with a JSON
+            // values it's a valid JSON.
+            (isFlat(value) && Object.keys(value).every(function(key) {
+                var $ = Object.getOwnPropertyDescriptor(value, key);
+                // Check every proprety of a plain object to verify that
+                // it's neither getter nor setter, but a JSON value, that
+                // has not been visited yet.
+                return  ((!isObject($.value) || !~visited.indexOf($.value)) &&
+                        !('get' in $) && !('set' in $) &&
+                        isJSON($.value, visited));
+            }));
+}
+exports.isJSON = function (value) {
+  return isJSON(value);
+};
+
+/**
+ * Returns `true` if `value` is JSONable
+ */
+const isJSONable = (value) => {
+  try {
+    JSON.parse(JSON.stringify(value));
+  }
+  catch (e) {
+    return false;
+  }
+  return true;
+};
+exports.isJSONable = isJSONable;
+
+/**
+ * Returns if `value` is an instance of a given `Type`. This is exactly same as
+ * `value instanceof Type` with a difference that `Type` can be from a scope
+ * that has a different top level object. (Like in case where `Type` is a
+ * function from different iframe / jetpack module / sandbox).
+ */
+function instanceOf(value, Type) {
+  var isConstructorNameSame;
+  var isConstructorSourceSame;
+
+  // If `instanceof` returned `true` we know result right away.
+  var isInstanceOf = value instanceof Type;
+
+  // If `instanceof` returned `false` we do ducktype check since `Type` may be
+  // from a different sandbox. If a constructor of the `value` or a constructor
+  // of the value's prototype has same name and source we assume that it's an
+  // instance of the Type.
+  if (!isInstanceOf && value) {
+    isConstructorNameSame = value.constructor.name === Type.name;
+    isConstructorSourceSame = String(value.constructor) == String(Type);
+    isInstanceOf = (isConstructorNameSame && isConstructorSourceSame) ||
+                    instanceOf(Object.getPrototypeOf(value), Type);
+  }
+  return isInstanceOf;
+}
+exports.instanceOf = instanceOf;
+
+/**
+ * Function returns textual representation of a value passed to it. Function
+ * takes additional `indent` argument that is used for indentation. Also
+ * optional `limit` argument may be passed to limit amount of detail returned.
+ * @param {Object} value
+ * @param {String} [indent="    "]
+ * @param {Number} [limit]
+ */
+function source(value, indent, limit, offset, visited) {
+  var result;
+  var names;
+  var nestingIndex;
+  var isCompact = !isUndefined(limit);
+
+  indent = indent || "    ";
+  offset = (offset || "");
+  result = "";
+  visited = visited || [];
+
+  if (isUndefined(value)) {
+    result += "undefined";
+  }
+  else if (isNull(value)) {
+    result += "null";
+  }
+  else if (isString(value)) {
+    result += '"' + value + '"';
+  }
+  else if (isFunction(value)) {
+    value = String(value).split("\n");
+    if (isCompact && value.length > 2) {
+      value = value.splice(0, 2);
+      value.push("...}");
+    }
+    result += value.join("\n" + offset);
+  }
+  else if (isArray(value)) {
+    if ((nestingIndex = (visited.indexOf(value) + 1))) {
+      result = "#" + nestingIndex + "#";
+    }
+    else {
+      visited.push(value);
+
+      if (isCompact)
+        value = value.slice(0, limit);
+
+      result += "[\n";
+      result += value.map(function(value) {
+        return offset + indent + source(value, indent, limit, offset + indent,
+                                        visited);
+      }).join(",\n");
+      result += isCompact && value.length > limit ?
+                ",\n" + offset + "...]" : "\n" + offset + "]";
+    }
+  }
+  else if (isObject(value)) {
+    if ((nestingIndex = (visited.indexOf(value) + 1))) {
+      result = "#" + nestingIndex + "#"
+    }
+    else {
+      visited.push(value)
+
+      names = Object.keys(value);
+
+      result += "{ // " + value + "\n";
+      result += (isCompact ? names.slice(0, limit) : names).map(function(name) {
+        var _limit = isCompact ? limit - 1 : limit;
+        var descriptor = Object.getOwnPropertyDescriptor(value, name);
+        var result = offset + indent + "// ";
+        var accessor;
+        if (0 <= name.indexOf(" "))
+          name = '"' + name + '"';
+
+        if (descriptor.writable)
+          result += "writable ";
+        if (descriptor.configurable)
+          result += "configurable ";
+        if (descriptor.enumerable)
+          result += "enumerable ";
+
+        result += "\n";
+        if ("value" in descriptor) {
+          result += offset + indent + name + ": ";
+          result += source(descriptor.value, indent, _limit, indent + offset,
+                           visited);
+        }
+        else {
+
+          if (descriptor.get) {
+            result += offset + indent + "get " + name + " ";
+            accessor = source(descriptor.get, indent, _limit, indent + offset,
+                              visited);
+            result += accessor.substr(accessor.indexOf("{"));
+          }
+
+          if (descriptor.set) {
+            result += offset + indent + "set " + name + " ";
+            accessor = source(descriptor.set, indent, _limit, indent + offset,
+                              visited);
+            result += accessor.substr(accessor.indexOf("{"));
+          }
+        }
+        return result;
+      }).join(",\n");
+
+      if (isCompact) {
+        if (names.length > limit && limit > 0) {
+          result += ",\n" + offset  + indent + "//...";
+        }
+      }
+      else {
+        if (names.length)
+          result += ",";
+
+        result += "\n" + offset + indent + '"__proto__": ';
+        result += source(Object.getPrototypeOf(value), indent, 0,
+                         offset + indent);
+      }
+
+      result += "\n" + offset + "}";
+    }
+  }
+  else {
+    result += String(value);
+  }
+  return result;
+}
+exports.source = function (value, indentation, limit) {
+  return source(value, indentation, limit);
+};
diff --git a/toolkit/jetpack/sdk/lang/weak-set.js b/toolkit/jetpack/sdk/lang/weak-set.js
new file mode 100644
index 000000000..8972602a5
--- /dev/null
+++ b/toolkit/jetpack/sdk/lang/weak-set.js
@@ -0,0 +1,75 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+"use strict";
+
+const { Cu } = require("chrome");
+
+function makeGetterFor(Type) {
+  let cache = new WeakMap();
+
+  return {
+    getFor(target) {
+      if (!cache.has(target))
+        cache.set(target, new Type());
+
+      return cache.get(target);
+    },
+    clearFor(target) {
+      return cache.delete(target)
+    }
+  }
+}
+
+var {getFor: getLookupFor, clearFor: clearLookupFor} = makeGetterFor(WeakMap);
+var {getFor: getRefsFor, clearFor: clearRefsFor} = makeGetterFor(Set);
+
+function add(target, value) {
+  if (has(target, value))
+    return;
+
+  getLookupFor(target).set(value, true);
+  getRefsFor(target).add(Cu.getWeakReference(value));
+}
+exports.add = add;
+
+function remove(target, value) {
+  getLookupFor(target).delete(value);
+}
+exports.remove = remove;
+
+function has(target, value) {
+  return getLookupFor(target).has(value);
+}
+exports.has = has;
+
+function clear(target) {
+  clearLookupFor(target);
+  clearRefsFor(target);
+}
+exports.clear = clear;
+
+function iterator(target) {
+  let refs = getRefsFor(target);
+
+  for (let ref of refs) {
+    let value = ref.get();
+
+    // If `value` is already gc'ed, it would be `null`.
+    // The `has` function is using a WeakMap as lookup table, so passing `null`
+    // would raise an exception because WeakMap accepts as value only non-null
+    // object.
+    // Plus, if `value` is already gc'ed, we do not have to take it in account
+    // during the iteration, and remove it from the references.
+    if (value !== null && has(target, value))
+      yield value;
+    else
+      refs.delete(ref);
+  }
+}
+exports.iterator = iterator;
diff --git a/toolkit/jetpack/sdk/loader/cuddlefish.js b/toolkit/jetpack/sdk/loader/cuddlefish.js
new file mode 100644
index 000000000..6ba19157b
--- /dev/null
+++ b/toolkit/jetpack/sdk/loader/cuddlefish.js
@@ -0,0 +1,102 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+// This module is manually loaded by bootstrap.js in a sandbox and immediatly
+// put in module cache so that it is never loaded in any other way.
+
+/* Workarounds to include dependencies in the manifest
+require('chrome')                  // Otherwise CFX will complain about Components
+require('toolkit/loader')          // Otherwise CFX will stip out loader.js
+require('sdk/addon/runner')        // Otherwise CFX will stip out addon/runner.js
+*/
+
+const { classes: Cc, Constructor: CC, interfaces: Ci, utils: Cu } = Components;
+
+// `loadSandbox` is exposed by bootstrap.js
+const loaderURI = module.uri.replace("sdk/loader/cuddlefish.js",
+                                     "toolkit/loader.js");
+const xulappURI = module.uri.replace("loader/cuddlefish.js",
+                                     "system/xul-app.jsm");
+// We need to keep a reference to the sandbox in order to unload it in
+// bootstrap.js
+
+var loaderSandbox = loadSandbox(loaderURI);
+const loaderModule = loaderSandbox.exports;
+
+const { incompatibility } = Cu.import(xulappURI, {}).XulApp;
+
+const { override, load } = loaderModule;
+
+function CuddlefishLoader(options) {
+  let { manifest } = options;
+
+  options = override(options, {
+    // Put `api-utils/loader` and `api-utils/cuddlefish` loaded as JSM to module
+    // cache to avoid subsequent loads via `require`.
+    modules: override({
+      'toolkit/loader': loaderModule,
+      'sdk/loader/cuddlefish': exports
+    }, options.modules),
+    resolve: function resolve(id, requirer) {
+      let entry = requirer && requirer in manifest && manifest[requirer];
+      let uri = null;
+
+      // If manifest entry for this requirement is present we follow manifest.
+      // Note: Standard library modules like 'panel' will be present in
+      // manifest unless they were moved to platform.
+      if (entry) {
+        let requirement = entry.requirements[id];
+        // If requirer entry is in manifest and it's requirement is not, than
+        // it has no authority to load since linker was not able to find it.
+        if (!requirement)
+          throw Error('Module: ' + requirer + ' has no authority to load: '
+                      + id, requirer);
+
+        uri = requirement;
+      } else {
+        // If requirer is off manifest than it's a system module and we allow it
+        // to go off manifest by resolving a relative path.
+        uri = loaderModule.resolve(id, requirer);
+      }
+      return uri;
+    },
+    load: function(loader, module) {
+      let result;
+      let error;
+
+      // In order to get the module's metadata, we need to load the module.
+      // if an exception is raised here, it could be that is due to application
+      // incompatibility. Therefore the exception is stored, and thrown again
+      // only if the module seems be compatible with the application currently
+      // running. Otherwise the incompatibility message takes the precedence.
+      try {
+        result = load(loader, module);
+      }
+      catch (e) {
+        error = e;
+      }
+
+      error = incompatibility(module) || error;
+
+      if (error)
+        throw error;
+
+      return result;
+    }
+  });
+
+  let loader = loaderModule.Loader(options);
+  // Hack to allow loading from `toolkit/loader`.
+  loader.modules[loaderURI] = loaderSandbox;
+  return loader;
+}
+
+exports = override(loaderModule, {
+  Loader: CuddlefishLoader
+});
diff --git a/toolkit/jetpack/sdk/loader/sandbox.js b/toolkit/jetpack/sdk/loader/sandbox.js
new file mode 100644
index 000000000..791dbc086
--- /dev/null
+++ b/toolkit/jetpack/sdk/loader/sandbox.js
@@ -0,0 +1,74 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci, CC, Cu } = require('chrome');
+const systemPrincipal = CC('@mozilla.org/systemprincipal;1', 'nsIPrincipal')();
+const scriptLoader = Cc['@mozilla.org/moz/jssubscript-loader;1'].
+                     getService(Ci.mozIJSSubScriptLoader);
+const self = require('sdk/self');
+const { getTabId } = require('../tabs/utils');
+const { getInnerId } = require('../window/utils');
+
+const { devtools } = Cu.import("resource://devtools/shared/Loader.jsm", {});
+const { require: devtoolsRequire } = devtools;
+const { addContentGlobal, removeContentGlobal } = devtoolsRequire("devtools/server/content-globals");
+
+/**
+ * Make a new sandbox that inherits given `source`'s principals. Source can be
+ * URI string, DOMWindow or `null` for system principals.
+ */
+function sandbox(target, options) {
+  options = options || {};
+  options.metadata = options.metadata ? options.metadata : {};
+  options.metadata.addonID = options.metadata.addonID ?
+    options.metadata.addonID : self.id;
+
+  let sandbox = Cu.Sandbox(target || systemPrincipal, options);
+  Cu.setSandboxMetadata(sandbox, options.metadata);
+  let innerWindowID = options.metadata['inner-window-id']
+  if (innerWindowID) {
+    addContentGlobal({
+      global: sandbox,
+      'inner-window-id': innerWindowID
+    });
+  }
+  return sandbox;
+}
+exports.sandbox = sandbox;
+
+/**
+ * Evaluates given `source` in a given `sandbox` and returns result.
+ */
+function evaluate(sandbox, code, uri, line, version) {
+  return Cu.evalInSandbox(code, sandbox, version || '1.8', uri || '', line || 1);
+}
+exports.evaluate = evaluate;
+
+/**
+ * Evaluates code under the given `uri` in the given `sandbox`.
+ *
+ * @param {String} uri
+ *    The URL pointing to the script to load.
+ *    It must be a local chrome:, resource:, file: or data: URL.
+ */
+function load(sandbox, uri) {
+  if (uri.indexOf('data:') === 0) {
+    let source = uri.substr(uri.indexOf(',') + 1);
+
+    return evaluate(sandbox, decodeURIComponent(source), '1.8', uri, 0);
+  } else {
+    return scriptLoader.loadSubScript(uri, sandbox, 'UTF-8');
+  }
+}
+exports.load = load;
+
+/**
+ * Forces the given `sandbox` to be freed immediately.
+ */
+exports.nuke = Cu.nukeSandbox
diff --git a/toolkit/jetpack/sdk/messaging.js b/toolkit/jetpack/sdk/messaging.js
new file mode 100644
index 000000000..07580eb33
--- /dev/null
+++ b/toolkit/jetpack/sdk/messaging.js
@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { window } = require("sdk/addon/window");
+exports.MessageChannel = window.MessageChannel;
+exports.MessagePort = window.MessagePort;
diff --git a/toolkit/jetpack/sdk/model/core.js b/toolkit/jetpack/sdk/model/core.js
new file mode 100644
index 000000000..315f8b1cd
--- /dev/null
+++ b/toolkit/jetpack/sdk/model/core.js
@@ -0,0 +1,23 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { dispatcher } = require("../util/dispatcher");
+
+
+// Define `modelFor` accessor function that can be implemented
+// for different types of views. Since view's we'll be dealing
+// with types that don't really play well with `instanceof`
+// operator we're gonig to use `dispatcher` that is slight
+// extension over polymorphic dispatch provided by method.
+// This allows models to extend implementations of this by
+// providing predicates:
+//
+// modelFor.when($ => $ && $.nodeName === "tab", findTabById($.id))
+const modelFor = dispatcher("modelFor");
+exports.modelFor = modelFor;
diff --git a/toolkit/jetpack/sdk/net/url.js b/toolkit/jetpack/sdk/net/url.js
new file mode 100644
index 000000000..5502171ee
--- /dev/null
+++ b/toolkit/jetpack/sdk/net/url.js
@@ -0,0 +1,94 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Ci, Cu, components } = require("chrome");
+
+const { defer } = require("../core/promise");
+const { merge } = require("../util/object");
+
+const { NetUtil } = Cu.import("resource://gre/modules/NetUtil.jsm", {});
+const { Services } = Cu.import("resource://gre/modules/Services.jsm", {});
+
+/**
+ * Reads a URI and returns a promise.
+ *
+ * @param uri {string} The URI to read
+ * @param [options] {object} This parameter can have any or all of the following
+ * fields: `charset`. By default the `charset` is set to 'UTF-8'.
+ *
+ * @returns {promise}  The promise that will be resolved with the content of the
+ *          URL given.
+ *
+ * @example
+ *  let promise = readURI('resource://gre/modules/NetUtil.jsm', {
+ *    charset: 'US-ASCII'
+ *  });
+ */
+function readURI(uri, options) {
+  options = options || {};
+  let charset = options.charset || 'UTF-8';
+
+  let channel = NetUtil.newChannel({
+    uri: NetUtil.newURI(uri, charset),
+    loadUsingSystemPrincipal: true});
+
+  let { promise, resolve, reject } = defer();
+
+  try {
+    NetUtil.asyncFetch(channel, function (stream, result) {
+      if (components.isSuccessCode(result)) {
+        let count = stream.available();
+        let data = NetUtil.readInputStreamToString(stream, count, { charset : charset });
+
+        resolve(data);
+      } else {
+        reject("Failed to read: '" + uri + "' (Error Code: " + result + ")");
+      }
+    });
+  }
+  catch (e) {
+    reject("Failed to read: '" + uri + "' (Error: " + e.message + ")");
+  }
+
+  return promise;
+}
+
+exports.readURI = readURI;
+
+/**
+ * Reads a URI synchronously.
+ * This function is intentionally undocumented to favorites the `readURI` usage.
+ *
+ * @param uri {string} The URI to read
+ * @param [charset] {string} The character set to use when read the content of
+ *        the `uri` given.  By default is set to 'UTF-8'.
+ *
+ * @returns {string} The content of the URI given.
+ *
+ * @example
+ *  let data = readURISync('resource://gre/modules/NetUtil.jsm');
+ */
+function readURISync(uri, charset) {
+  charset = typeof charset === "string" ? charset : "UTF-8";
+
+  let channel = NetUtil.newChannel({
+    uri: NetUtil.newURI(uri, charset),
+    loadUsingSystemPrincipal: true});
+  let stream = channel.open2();
+
+  let count = stream.available();
+  let data = NetUtil.readInputStreamToString(stream, count, { charset : charset });
+
+  stream.close();
+
+  return data;
+}
+
+exports.readURISync = readURISync;
diff --git a/toolkit/jetpack/sdk/net/xhr.js b/toolkit/jetpack/sdk/net/xhr.js
new file mode 100644
index 000000000..415b9cbf4
--- /dev/null
+++ b/toolkit/jetpack/sdk/net/xhr.js
@@ -0,0 +1,36 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { deprecateFunction } = require("../util/deprecate");
+const { Cc, Ci } = require("chrome");
+const XMLHttpRequest = require("../addon/window").window.XMLHttpRequest;
+
+Object.defineProperties(XMLHttpRequest.prototype, {
+  mozBackgroundRequest: {
+    value: true,
+  },
+  forceAllowThirdPartyCookie: {
+    configurable: true,
+    value: deprecateFunction(function() {
+      forceAllowThirdPartyCookie(this);
+
+    }, "`xhr.forceAllowThirdPartyCookie()` is deprecated, please use" +
+       "`require('sdk/net/xhr').forceAllowThirdPartyCookie(request)` instead")
+  }
+});
+exports.XMLHttpRequest = XMLHttpRequest;
+
+function forceAllowThirdPartyCookie(xhr) {
+  if (xhr.channel instanceof Ci.nsIHttpChannelInternal)
+    xhr.channel.forceAllowThirdPartyCookie = true;
+}
+exports.forceAllowThirdPartyCookie = forceAllowThirdPartyCookie;
+
+// No need to handle add-on unloads as addon/window is closed at unload
+// and it will take down all the associated requests.
diff --git a/toolkit/jetpack/sdk/notifications.js b/toolkit/jetpack/sdk/notifications.js
new file mode 100644
index 000000000..752e08fb1
--- /dev/null
+++ b/toolkit/jetpack/sdk/notifications.js
@@ -0,0 +1,112 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { Cc, Ci, Cr } = require("chrome");
+const apiUtils = require("./deprecated/api-utils");
+const { isString, isUndefined, instanceOf } = require('./lang/type');
+const { URL, isLocalURL } = require('./url');
+const { data } = require('./self');
+
+const NOTIFICATION_DIRECTIONS  = ["auto", "ltr", "rtl"];
+
+try {
+  let alertServ = Cc["@mozilla.org/alerts-service;1"].
+                  getService(Ci.nsIAlertsService);
+
+  // The unit test sets this to a mock notification function.
+  var notify = alertServ.showAlertNotification.bind(alertServ);
+}
+catch (err) {
+  // An exception will be thrown if the platform doesn't provide an alert
+  // service, e.g., if Growl is not installed on OS X.  In that case, use a
+  // mock notification function that just logs to the console.
+  notify = notifyUsingConsole;
+}
+
+exports.notify = function notifications_notify(options) {
+  let valOpts = validateOptions(options);
+  let clickObserver = !valOpts.onClick ? null : {
+    observe: (subject, topic, data) => {
+      if (topic === "alertclickcallback") {
+        try {
+          valOpts.onClick.call(exports, valOpts.data);
+        }
+        catch(e) {
+          console.exception(e);
+        }
+      }
+    }
+  };
+  function notifyWithOpts(notifyFn) {
+    let { iconURL } = valOpts;
+    iconURL = iconURL && isLocalURL(iconURL) ? data.url(iconURL) : iconURL;
+
+    notifyFn(iconURL, valOpts.title, valOpts.text, !!clickObserver,
+             valOpts.data, clickObserver, valOpts.tag, valOpts.dir, valOpts.lang);
+  }
+  try {
+    notifyWithOpts(notify);
+  }
+  catch (err) {
+    if (err instanceof Ci.nsIException && err.result == Cr.NS_ERROR_FILE_NOT_FOUND) {
+      console.warn("The notification icon named by " + iconURL +
+                   " does not exist.  A default icon will be used instead.");
+      delete valOpts.iconURL;
+      notifyWithOpts(notify);
+    }
+    else {
+      notifyWithOpts(notifyUsingConsole);
+    }
+  }
+};
+
+function notifyUsingConsole(iconURL, title, text) {
+  title = title ? "[" + title + "]" : "";
+  text = text || "";
+  let str = [title, text].filter(s => s).join(" ");
+  console.log(str);
+}
+
+function validateOptions(options) {
+  return apiUtils.validateOptions(options, {
+    data: {
+      is: ["string", "undefined"]
+    },
+    iconURL: {
+      is: ["string", "undefined", "object"],
+      ok: function(value) {
+        return isUndefined(value) || isString(value) || (value instanceof URL);
+      },
+      msg: "`iconURL` must be a string or an URL instance."
+    },
+    onClick: {
+      is: ["function", "undefined"]
+    },
+    text: {
+      is: ["string", "undefined", "number"]
+    },
+    title: {
+      is: ["string", "undefined", "number"]
+    },
+    tag: {
+      is: ["string", "undefined", "number"]
+    },
+    dir: {
+      is: ["string", "undefined"],
+      ok: function(value) {
+        return isUndefined(value) || ~NOTIFICATION_DIRECTIONS.indexOf(value);
+      },
+      msg: '`dir` option must be one of: "auto", "ltr" or "rtl".'
+    },
+    lang: {
+      is: ["string", "undefined"]
+    }
+  });
+}
diff --git a/toolkit/jetpack/sdk/output/system.js b/toolkit/jetpack/sdk/output/system.js
new file mode 100644
index 000000000..4fb16dcd5
--- /dev/null
+++ b/toolkit/jetpack/sdk/output/system.js
@@ -0,0 +1,71 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Cc, Ci, Cr } = require("chrome");
+const { Input, start, stop, receive, outputs } = require("../event/utils");
+const { id: addonID } = require("../self");
+const { setImmediate } = require("../timers");
+const { notifyObservers } = Cc['@mozilla.org/observer-service;1'].
+                             getService(Ci.nsIObserverService);
+
+const NOT_AN_INPUT = "OutputPort can be used only for sending messages";
+
+// `OutputPort` creates a port to which messages can be send. Those
+// messages are actually disptached as `subject`'s of the observer
+// notifications. This is handy for communicating between different
+// components of the SDK. By default messages are dispatched
+// asynchronously, although `options.sync` can be used to make them
+// synchronous. If `options.id` is given `topic` for observer
+// notifications is generated by namespacing it, to avoid spamming
+// other SDK add-ons. It's also possible to provide `options.topic`
+// to use excat `topic` without namespacing it.
+//
+// Note: Symmetric `new InputPort({ id: "x" })` instances can be used to
+// receive messages send to the instances of `new OutputPort({ id: "x" })`.
+const OutputPort = function({id, topic, sync}) {
+  this.id = id || topic;
+  this.sync = !!sync;
+  this.topic = topic || "sdk:" + addonID + ":" + id;
+};
+// OutputPort extends base signal type to implement same message
+// receiving interface.
+OutputPort.prototype = new Input();
+OutputPort.constructor = OutputPort;
+
+// OutputPort can not be consumed there for starting or stopping it
+// is not supported.
+OutputPort.prototype[start] = _ => { throw TypeError(NOT_AN_INPUT); };
+OutputPort.prototype[stop] = _ => { throw TypeError(NOT_AN_INPUT); };
+
+// Port reecives message send to it, which will be dispatched via
+// observer notification service.
+OutputPort.receive = ({topic, sync}, message) => {
+  const type = typeof(message);
+  const supported = message === null ||
+                    type === "object" ||
+                    type === "function";
+
+  // There is no sensible way to wrap JS primitives that would make sense
+  // for general observer notification users. It's also probably not very
+  // useful to dispatch JS primitives as subject of observer service, there
+  // for we do not support those use cases.
+  if (!supported)
+    throw new TypeError("Unsupproted message type: `" + type + "`");
+
+  // Normalize `message` to create a valid observer notification `subject`.
+  // If `message` is `null`, implements `nsISupports` interface or already
+  // represents wrapped JS object use it as is. Otherwise create a wrapped
+  // object so that observers could receive it.
+  const subject = message === null ? null :
+                  message instanceof Ci.nsISupports ? message :
+                  message.wrappedJSObject ? message :
+                  {wrappedJSObject: message};
+  if (sync)
+    notifyObservers(subject, topic, null);
+  else
+    setImmediate(notifyObservers, subject, topic, null);
+};
+OutputPort.prototype[receive] = OutputPort.receive;
+exports.OutputPort = OutputPort;
diff --git a/toolkit/jetpack/sdk/page-mod.js b/toolkit/jetpack/sdk/page-mod.js
new file mode 100644
index 000000000..538be2732
--- /dev/null
+++ b/toolkit/jetpack/sdk/page-mod.js
@@ -0,0 +1,190 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { contract: loaderContract } = require('./content/loader');
+const { contract } = require('./util/contract');
+const { WorkerHost, connect } = require('./content/utils');
+const { Class } = require('./core/heritage');
+const { Disposable } = require('./core/disposable');
+const { Worker } = require('./content/worker');
+const { EventTarget } = require('./event/target');
+const { on, emit, once, setListeners } = require('./event/core');
+const { isRegExp, isUndefined } = require('./lang/type');
+const { merge, omit } = require('./util/object');
+const { remove, has, hasAny } = require("./util/array");
+const { Rules } = require("./util/rules");
+const { processes, frames, remoteRequire } = require('./remote/parent');
+remoteRequire('sdk/content/page-mod');
+
+const pagemods = new Map();
+const workers = new Map();
+const models = new WeakMap();
+var modelFor = (mod) => models.get(mod);
+var workerFor = (mod) => workers.get(mod)[0];
+
+// Helper functions
+var isRegExpOrString = (v) => isRegExp(v) || typeof v === 'string';
+
+var PAGEMOD_ID = 0;
+
+// Validation Contracts
+const modOptions = {
+  // contentStyle* / contentScript* are sharing the same validation constraints,
+  // so they can be mostly reused, except for the messages.
+  contentStyle: merge(Object.create(loaderContract.rules.contentScript), {
+    msg: 'The `contentStyle` option must be a string or an array of strings.'
+  }),
+  contentStyleFile: merge(Object.create(loaderContract.rules.contentScriptFile), {
+    msg: 'The `contentStyleFile` option must be a local URL or an array of URLs'
+  }),
+  include: {
+    is: ['string', 'array', 'regexp'],
+    ok: (rule) => {
+      if (isRegExpOrString(rule))
+        return true;
+      if (Array.isArray(rule) && rule.length > 0)
+        return rule.every(isRegExpOrString);
+      return false;
+    },
+    msg: 'The `include` option must always contain atleast one rule as a string, regular expression, or an array of strings and regular expressions.'
+  },
+  exclude: {
+    is: ['string', 'array', 'regexp', 'undefined'],
+    ok: (rule) => {
+      if (isRegExpOrString(rule) || isUndefined(rule))
+        return true;
+      if (Array.isArray(rule) && rule.length > 0)
+        return rule.every(isRegExpOrString);
+      return false;
+    },
+    msg: 'If set, the `exclude` option must always contain at least one ' +
+      'rule as a string, regular expression, or an array of strings and ' +
+      'regular expressions.'
+  },
+  attachTo: {
+    is: ['string', 'array', 'undefined'],
+    map: function (attachTo) {
+      if (!attachTo) return ['top', 'frame'];
+      if (typeof attachTo === 'string') return [attachTo];
+      return attachTo;
+    },
+    ok: function (attachTo) {
+      return hasAny(attachTo, ['top', 'frame']) &&
+        attachTo.every(has.bind(null, ['top', 'frame', 'existing']));
+    },
+    msg: 'The `attachTo` option must be a string or an array of strings. ' +
+      'The only valid options are "existing", "top" and "frame", and must ' +
+      'contain at least "top" or "frame" values.'
+  },
+};
+
+const modContract = contract(merge({}, loaderContract.rules, modOptions));
+
+/**
+ * PageMod constructor (exported below).
+ * @constructor
+ */
+const PageMod = Class({
+  implements: [
+    modContract.properties(modelFor),
+    EventTarget,
+    Disposable,
+  ],
+  extends: WorkerHost(workerFor),
+  setup: function PageMod(options) {
+    let mod = this;
+    let model = modContract(options);
+    models.set(this, model);
+    model.id = PAGEMOD_ID++;
+
+    let include = model.include;
+    model.include = Rules();
+    model.include.add.apply(model.include, [].concat(include));
+
+    let exclude = isUndefined(model.exclude) ? [] : model.exclude;
+    model.exclude = Rules();
+    model.exclude.add.apply(model.exclude, [].concat(exclude));
+
+    // Set listeners on {PageMod} itself, not the underlying worker,
+    // like `onMessage`, as it'll get piped.
+    setListeners(this, options);
+
+    pagemods.set(model.id, this);
+    workers.set(this, []);
+
+    function serializeRules(rules) {
+      for (let rule of rules) {
+        yield isRegExp(rule) ? { type: "regexp", pattern: rule.source, flags: rule.flags }
+                             : { type: "string", value: rule };
+      }
+    }
+
+    model.childOptions = omit(model, ["include", "exclude", "contentScriptOptions"]);
+    model.childOptions.include = [...serializeRules(model.include)];
+    model.childOptions.exclude = [...serializeRules(model.exclude)];
+    model.childOptions.contentScriptOptions = model.contentScriptOptions ?
+                                              JSON.stringify(model.contentScriptOptions) :
+                                              null;
+
+    processes.port.emit('sdk/page-mod/create', model.childOptions);
+  },
+
+  dispose: function(reason) {
+    processes.port.emit('sdk/page-mod/destroy', modelFor(this).id);
+    pagemods.delete(modelFor(this).id);
+    workers.delete(this);
+  },
+
+  destroy: function(reason) {
+    // Explicit destroy call, i.e. not via unload so destroy the workers
+    let list = workers.get(this);
+    if (!list)
+      return;
+
+    // Triggers dispose which will cause the child page-mod to be destroyed
+    Disposable.prototype.destroy.call(this, reason);
+
+    // Destroy any active workers
+    for (let worker of list)
+      worker.destroy(reason);
+  }
+});
+exports.PageMod = PageMod;
+
+// Whenever a new process starts send over the list of page-mods
+processes.forEvery(process => {
+  for (let mod of pagemods.values())
+    process.port.emit('sdk/page-mod/create', modelFor(mod).childOptions);
+});
+
+frames.port.on('sdk/page-mod/worker-create', (frame, modId, workerOptions) => {
+  let mod = pagemods.get(modId);
+  if (!mod)
+    return;
+
+  // Attach the parent side of the worker to the child
+  let worker = Worker();
+
+  workers.get(mod).unshift(worker);
+  worker.on('*', (event, ...args) => {
+    // page-mod's "attach" event needs to be passed a worker
+    if (event === 'attach')
+      emit(mod, event, worker)
+    else
+      emit(mod, event, ...args);
+  });
+
+  worker.on('detach', () => {
+    let array = workers.get(mod);
+    if (array)
+      remove(array, worker);
+  });
+
+  connect(worker, frame, workerOptions);
+});
diff --git a/toolkit/jetpack/sdk/page-mod/match-pattern.js b/toolkit/jetpack/sdk/page-mod/match-pattern.js
new file mode 100644
index 000000000..afbbd401e
--- /dev/null
+++ b/toolkit/jetpack/sdk/page-mod/match-pattern.js
@@ -0,0 +1,10 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+ "use strict";
+
+var { deprecateUsage } = require("../util/deprecate");
+
+deprecateUsage("Module 'sdk/page-mod/match-pattern' is deprecated use 'sdk/util/match-pattern' instead");
+
+module.exports = require("../util/match-pattern");
diff --git a/toolkit/jetpack/sdk/page-worker.js b/toolkit/jetpack/sdk/page-worker.js
new file mode 100644
index 000000000..837cf774b
--- /dev/null
+++ b/toolkit/jetpack/sdk/page-worker.js
@@ -0,0 +1,194 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { Class } = require('./core/heritage');
+const { ns } = require('./core/namespace');
+const { pipe, stripListeners } = require('./event/utils');
+const { connect, destroy, WorkerHost } = require('./content/utils');
+const { Worker } = require('./content/worker');
+const { Disposable } = require('./core/disposable');
+const { EventTarget } = require('./event/target');
+const { setListeners } = require('./event/core');
+const { window } = require('./addon/window');
+const { create: makeFrame, getDocShell } = require('./frame/utils');
+const { contract } = require('./util/contract');
+const { contract: loaderContract } = require('./content/loader');
+const { Rules } = require('./util/rules');
+const { merge } = require('./util/object');
+const { uuid } = require('./util/uuid');
+const { useRemoteProcesses, remoteRequire, frames } = require("./remote/parent");
+remoteRequire("sdk/content/page-worker");
+
+const workers = new WeakMap();
+const pages = new Map();
+
+const internal = ns();
+
+let workerFor = (page) => workers.get(page);
+let isDisposed = (page) => !pages.has(internal(page).id);
+
+// The frame is used to ensure we have a remote process to load workers in
+let remoteFrame = null;
+let framePromise = null;
+function getFrame() {
+  if (framePromise)
+    return framePromise;
+
+  framePromise = new Promise(resolve => {
+    let view = makeFrame(window.document, {
+      namespaceURI: "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul",
+      nodeName: "iframe",
+      type: "content",
+      remote: useRemoteProcesses,
+      uri: "about:blank"
+    });
+
+    // Wait for the remote side to connect
+    let listener = (frame) => {
+      if (frame.frameElement != view)
+        return;
+      frames.off("attach", listener);
+      remoteFrame = frame;
+      resolve(frame);
+    }
+    frames.on("attach", listener);
+  });
+  return framePromise;
+}
+
+var pageContract = contract(merge({
+  allow: {
+    is: ['object', 'undefined', 'null'],
+    map: function (allow) { return { script: !allow || allow.script !== false }}
+  },
+  onMessage: {
+    is: ['function', 'undefined']
+  },
+  include: {
+    is: ['string', 'array', 'regexp', 'undefined']
+  },
+  contentScriptWhen: {
+    is: ['string', 'undefined'],
+    map: (when) => when || "end"
+  }
+}, loaderContract.rules));
+
+function enableScript (page) {
+  getDocShell(viewFor(page)).allowJavascript = true;
+}
+
+function disableScript (page) {
+  getDocShell(viewFor(page)).allowJavascript = false;
+}
+
+function Allow (page) {
+  return {
+    get script() {
+      return internal(page).options.allow.script;
+    },
+    set script(value) {
+      internal(page).options.allow.script = value;
+
+      if (isDisposed(page))
+        return;
+
+      remoteFrame.port.emit("sdk/frame/set", internal(page).id, { allowScript: value });
+    }
+  };
+}
+
+function isValidURL(page, url) {
+  return !page.rules || page.rules.matchesAny(url);
+}
+
+const Page = Class({
+  implements: [
+    EventTarget,
+    Disposable
+  ],
+  extends: WorkerHost(workerFor),
+  setup: function Page(options) {
+    options = pageContract(options);
+    // Sanitize the options
+    if ("contentScriptOptions" in options)
+      options.contentScriptOptions = JSON.stringify(options.contentScriptOptions);
+
+    internal(this).id = uuid().toString();
+    internal(this).options = options;
+
+    for (let prop of ['contentScriptFile', 'contentScript', 'contentScriptWhen']) {
+      this[prop] = options[prop];
+    }
+
+    pages.set(internal(this).id, this);
+
+    // Set listeners on the {Page} object itself, not the underlying worker,
+    // like `onMessage`, as it gets piped
+    setListeners(this, options);
+    let worker = new Worker(stripListeners(options));
+    workers.set(this, worker);
+    pipe(worker, this);
+
+    if (options.include) {
+      this.rules = Rules();
+      this.rules.add.apply(this.rules, [].concat(options.include));
+    }
+
+    getFrame().then(frame => {
+      if (isDisposed(this))
+        return;
+
+      frame.port.emit("sdk/frame/create", internal(this).id, stripListeners(options));
+    });
+  },
+  get allow() { return Allow(this); },
+  set allow(value) {
+    if (isDisposed(this))
+      return;
+    this.allow.script = pageContract({ allow: value }).allow.script;
+  },
+  get contentURL() {
+    return internal(this).options.contentURL;
+  },
+  set contentURL(value) {
+    if (!isValidURL(this, value))
+      return;
+    internal(this).options.contentURL = value;
+    if (isDisposed(this))
+      return;
+
+    remoteFrame.port.emit("sdk/frame/set", internal(this).id, { contentURL: value });
+  },
+  dispose: function () {
+    if (isDisposed(this))
+      return;
+    pages.delete(internal(this).id);
+    let worker = workerFor(this);
+    if (worker)
+      destroy(worker);
+    remoteFrame.port.emit("sdk/frame/destroy", internal(this).id);
+
+    // Destroy the remote frame if all the pages have been destroyed
+    if (pages.size == 0) {
+      framePromise = null;
+      remoteFrame.frameElement.remove();
+      remoteFrame = null;
+    }
+  },
+  toString: function () { return '[object Page]' }
+});
+
+exports.Page = Page;
+
+frames.port.on("sdk/frame/connect", (frame, id, params) => {
+  let page = pages.get(id);
+  if (!page)
+    return;
+  connect(workerFor(page), frame, params);
+});
diff --git a/toolkit/jetpack/sdk/panel.js b/toolkit/jetpack/sdk/panel.js
new file mode 100644
index 000000000..4b625799d
--- /dev/null
+++ b/toolkit/jetpack/sdk/panel.js
@@ -0,0 +1,427 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+// The panel module currently supports only Firefox and SeaMonkey.
+// See: https://bugzilla.mozilla.org/show_bug.cgi?id=jetpack-panel-apps
+module.metadata = {
+  "stability": "stable",
+  "engines": {
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+const { Cu, Ci } = require("chrome");
+const { setTimeout } = require('./timers');
+const { Class } = require("./core/heritage");
+const { merge } = require("./util/object");
+const { WorkerHost } = require("./content/utils");
+const { Worker } = require("./deprecated/sync-worker");
+const { Disposable } = require("./core/disposable");
+const { WeakReference } = require('./core/reference');
+const { contract: loaderContract } = require("./content/loader");
+const { contract } = require("./util/contract");
+const { on, off, emit, setListeners } = require("./event/core");
+const { EventTarget } = require("./event/target");
+const domPanel = require("./panel/utils");
+const { getDocShell } = require('./frame/utils');
+const { events } = require("./panel/events");
+const systemEvents = require("./system/events");
+const { filter, pipe, stripListeners } = require("./event/utils");
+const { getNodeView, getActiveView } = require("./view/core");
+const { isNil, isObject, isNumber } = require("./lang/type");
+const { getAttachEventType } = require("./content/utils");
+const { number, boolean, object } = require('./deprecated/api-utils');
+const { Style } = require("./stylesheet/style");
+const { attach, detach } = require("./content/mod");
+
+var isRect = ({top, right, bottom, left}) => [top, right, bottom, left].
+  some(value => isNumber(value) && !isNaN(value));
+
+var isSDKObj = obj => obj instanceof Class;
+
+var rectContract = contract({
+  top: number,
+  right: number,
+  bottom: number,
+  left: number
+});
+
+var position = {
+  is: object,
+  map: v => (isNil(v) || isSDKObj(v) || !isObject(v)) ? v : rectContract(v),
+  ok: v => isNil(v) || isSDKObj(v) || (isObject(v) && isRect(v)),
+  msg: 'The option "position" must be a SDK object registered as anchor; ' +
+        'or an object with one or more of the following keys set to numeric ' +
+        'values: top, right, bottom, left.'
+}
+
+var displayContract = contract({
+  width: number,
+  height: number,
+  focus: boolean,
+  position: position
+});
+
+var panelContract = contract(merge({
+  // contentStyle* / contentScript* are sharing the same validation constraints,
+  // so they can be mostly reused, except for the messages.
+  contentStyle: merge(Object.create(loaderContract.rules.contentScript), {
+    msg: 'The `contentStyle` option must be a string or an array of strings.'
+  }),
+  contentStyleFile: merge(Object.create(loaderContract.rules.contentScriptFile), {
+    msg: 'The `contentStyleFile` option must be a local URL or an array of URLs'
+  }),
+  contextMenu: boolean,
+  allow: {
+    is: ['object', 'undefined', 'null'],
+    map: function (allow) { return { script: !allow || allow.script !== false }}
+  },
+}, displayContract.rules, loaderContract.rules));
+
+function Allow(panel) {
+  return {
+    get script() { return getDocShell(viewFor(panel).backgroundFrame).allowJavascript; },
+    set script(value) { return setScriptState(panel, value); },
+  };
+}
+
+function setScriptState(panel, value) {
+  let view = viewFor(panel);
+  getDocShell(view.backgroundFrame).allowJavascript = value;
+  getDocShell(view.viewFrame).allowJavascript = value;
+  view.setAttribute("sdkscriptenabled", "" + value);
+}
+
+function isDisposed(panel) {
+  return !views.has(panel);
+}
+
+var panels = new WeakMap();
+var models = new WeakMap();
+var views = new WeakMap();
+var workers = new WeakMap();
+var styles = new WeakMap();
+
+const viewFor = (panel) => views.get(panel);
+const modelFor = (panel) => models.get(panel);
+const panelFor = (view) => panels.get(view);
+const workerFor = (panel) => workers.get(panel);
+const styleFor = (panel) => styles.get(panel);
+
+function getPanelFromWeakRef(weakRef) {
+  if (!weakRef) {
+    return null;
+  }
+  let panel = weakRef.get();
+  if (!panel) {
+    return null;
+  }
+  if (isDisposed(panel)) {
+    return null;
+  }
+  return panel;
+}
+
+var SinglePanelManager = {
+  visiblePanel: null,
+  enqueuedPanel: null,
+  enqueuedPanelCallback: null,
+  // Calls |callback| with no arguments when the panel may be shown.
+  requestOpen: function(panelToOpen, callback) {
+    let currentPanel = getPanelFromWeakRef(SinglePanelManager.visiblePanel);
+    if (currentPanel || SinglePanelManager.enqueuedPanel) {
+      SinglePanelManager.enqueuedPanel = Cu.getWeakReference(panelToOpen);
+      SinglePanelManager.enqueuedPanelCallback = callback;
+      if (currentPanel && currentPanel.isShowing) {
+        currentPanel.hide();
+      }
+    } else {
+      SinglePanelManager.notifyPanelCanOpen(panelToOpen, callback);
+    }
+  },
+  notifyPanelCanOpen: function(panel, callback) {
+    let view = viewFor(panel);
+    // Can't pass an arrow function as the event handler because we need to be
+    // able to call |removeEventListener| later.
+    view.addEventListener("popuphidden", SinglePanelManager.onVisiblePanelHidden, true);
+    view.addEventListener("popupshown", SinglePanelManager.onVisiblePanelShown, false);
+    SinglePanelManager.enqueuedPanel = null;
+    SinglePanelManager.enqueuedPanelCallback = null;
+    SinglePanelManager.visiblePanel = Cu.getWeakReference(panel);
+    callback();
+  },
+  onVisiblePanelShown: function(event) {
+    let panel = panelFor(event.target);
+    if (SinglePanelManager.enqueuedPanel) {
+      // Another panel started waiting for |panel| to close before |panel| was
+      // even done opening.
+      panel.hide();
+    }
+  },
+  onVisiblePanelHidden: function(event) {
+    let view = event.target;
+    let panel = panelFor(view);
+    let currentPanel = getPanelFromWeakRef(SinglePanelManager.visiblePanel);
+    if (currentPanel && currentPanel != panel) {
+      return;
+    }
+    SinglePanelManager.visiblePanel = null;
+    view.removeEventListener("popuphidden", SinglePanelManager.onVisiblePanelHidden, true);
+    view.removeEventListener("popupshown", SinglePanelManager.onVisiblePanelShown, false);
+    let nextPanel = getPanelFromWeakRef(SinglePanelManager.enqueuedPanel);
+    let nextPanelCallback = SinglePanelManager.enqueuedPanelCallback;
+    if (nextPanel) {
+      SinglePanelManager.notifyPanelCanOpen(nextPanel, nextPanelCallback);
+    }
+  }
+};
+
+const Panel = Class({
+  implements: [
+    // Generate accessors for the validated properties that update model on
+    // set and return values from model on get.
+    panelContract.properties(modelFor),
+    EventTarget,
+    Disposable,
+    WeakReference
+  ],
+  extends: WorkerHost(workerFor),
+  setup: function setup(options) {
+    let model = merge({
+      defaultWidth: 320,
+      defaultHeight: 240,
+      focus: true,
+      position: Object.freeze({}),
+      contextMenu: false
+    }, panelContract(options));
+    model.ready = false;
+    models.set(this, model);
+
+    if (model.contentStyle || model.contentStyleFile) {
+      styles.set(this, Style({
+        uri: model.contentStyleFile,
+        source: model.contentStyle
+      }));
+    }
+
+    // Setup view
+    let viewOptions = {allowJavascript: !model.allow || (model.allow.script !== false)};
+    let view = domPanel.make(null, viewOptions);
+    panels.set(view, this);
+    views.set(this, view);
+
+    // Load panel content.
+    domPanel.setURL(view, model.contentURL);
+
+    // Allow context menu
+    domPanel.allowContextMenu(view, model.contextMenu);
+
+    // Setup listeners.
+    setListeners(this, options);
+    let worker = new Worker(stripListeners(options));
+    workers.set(this, worker);
+
+    // pipe events from worker to a panel.
+    pipe(worker, this);
+  },
+  dispose: function dispose() {
+    this.hide();
+    off(this);
+
+    workerFor(this).destroy();
+    detach(styleFor(this));
+
+    domPanel.dispose(viewFor(this));
+
+    // Release circular reference between view and panel instance. This
+    // way view will be GC-ed. And panel as well once all the other refs
+    // will be removed from it.
+    views.delete(this);
+  },
+  /* Public API: Panel.width */
+  get width() {
+    return modelFor(this).width;
+  },
+  set width(value) {
+    this.resize(value, this.height);
+  },
+  /* Public API: Panel.height */
+  get height() {
+    return modelFor(this).height;
+  },
+  set height(value) {
+    this.resize(this.width, value);
+  },
+
+  /* Public API: Panel.focus */
+  get focus() {
+    return modelFor(this).focus;
+  },
+
+  /* Public API: Panel.position */
+  get position() {
+    return modelFor(this).position;
+  },
+
+  /* Public API: Panel.contextMenu */
+  get contextMenu() {
+    return modelFor(this).contextMenu;
+  },
+  set contextMenu(allow) {
+    let model = modelFor(this);
+    model.contextMenu = panelContract({ contextMenu: allow }).contextMenu;
+    domPanel.allowContextMenu(viewFor(this), model.contextMenu);
+  },
+
+  get contentURL() {
+    return modelFor(this).contentURL;
+  },
+  set contentURL(value) {
+    let model = modelFor(this);
+    model.contentURL = panelContract({ contentURL: value }).contentURL;
+    domPanel.setURL(viewFor(this), model.contentURL);
+    // Detach worker so that messages send will be queued until it's
+    // reatached once panel content is ready.
+    workerFor(this).detach();
+  },
+
+  get allow() { return Allow(this); },
+  set allow(value) {
+    let allowJavascript = panelContract({ allow: value }).allow.script;
+    return setScriptState(this, value);
+  },
+
+  /* Public API: Panel.isShowing */
+  get isShowing() {
+    return !isDisposed(this) && domPanel.isOpen(viewFor(this));
+  },
+
+  /* Public API: Panel.show */
+  show: function show(options={}, anchor) {
+    SinglePanelManager.requestOpen(this, () => {
+      if (options instanceof Ci.nsIDOMElement) {
+        [anchor, options] = [options, null];
+      }
+
+      if (anchor instanceof Ci.nsIDOMElement) {
+        console.warn(
+          "Passing a DOM node to Panel.show() method is an unsupported " +
+          "feature that will be soon replaced. " +
+          "See: https://bugzilla.mozilla.org/show_bug.cgi?id=878877"
+        );
+      }
+
+      let model = modelFor(this);
+      let view = viewFor(this);
+      let anchorView = getNodeView(anchor || options.position || model.position);
+
+      options = merge({
+        position: model.position,
+        width: model.width,
+        height: model.height,
+        defaultWidth: model.defaultWidth,
+        defaultHeight: model.defaultHeight,
+        focus: model.focus,
+        contextMenu: model.contextMenu
+      }, displayContract(options));
+
+      if (!isDisposed(this)) {
+        domPanel.show(view, options, anchorView);
+      }
+    });
+    return this;
+  },
+
+  /* Public API: Panel.hide */
+  hide: function hide() {
+    // Quit immediately if panel is disposed or there is no state change.
+    domPanel.close(viewFor(this));
+
+    return this;
+  },
+
+  /* Public API: Panel.resize */
+  resize: function resize(width, height) {
+    let model = modelFor(this);
+    let view = viewFor(this);
+    let change = panelContract({
+      width: width || model.width || model.defaultWidth,
+      height: height || model.height || model.defaultHeight
+    });
+
+    model.width = change.width
+    model.height = change.height
+
+    domPanel.resize(view, model.width, model.height);
+
+    return this;
+  }
+});
+exports.Panel = Panel;
+
+// Note must be defined only after value to `Panel` is assigned.
+getActiveView.define(Panel, viewFor);
+
+// Filter panel events to only panels that are create by this module.
+var panelEvents = filter(events, ({target}) => panelFor(target));
+
+// Panel events emitted after panel has being shown.
+var shows = filter(panelEvents, ({type}) => type === "popupshown");
+
+// Panel events emitted after panel became hidden.
+var hides = filter(panelEvents, ({type}) => type === "popuphidden");
+
+// Panel events emitted after content inside panel is ready. For different
+// panels ready may mean different state based on `contentScriptWhen` attribute.
+// Weather given event represents readyness is detected by `getAttachEventType`
+// helper function.
+var ready = filter(panelEvents, ({type, target}) =>
+  getAttachEventType(modelFor(panelFor(target))) === type);
+
+// Panel event emitted when the contents of the panel has been loaded.
+var readyToShow = filter(panelEvents, ({type}) => type === "DOMContentLoaded");
+
+// Styles should be always added as soon as possible, and doesn't makes them
+// depends on `contentScriptWhen`
+var start = filter(panelEvents, ({type}) => type === "document-element-inserted");
+
+// Forward panel show / hide events to panel's own event listeners.
+on(shows, "data", ({target}) => {
+  let panel = panelFor(target);
+  if (modelFor(panel).ready)
+    emit(panel, "show");
+});
+
+on(hides, "data", ({target}) => {
+  let panel = panelFor(target);
+  if (modelFor(panel).ready)
+    emit(panel, "hide");
+});
+
+on(ready, "data", ({target}) => {
+  let panel = panelFor(target);
+  let window = domPanel.getContentDocument(target).defaultView;
+
+  workerFor(panel).attach(window);
+});
+
+on(readyToShow, "data", ({target}) => {
+  let panel = panelFor(target);
+
+  if (!modelFor(panel).ready) {
+    modelFor(panel).ready = true;
+
+    if (viewFor(panel).state == "open")
+      emit(panel, "show");
+  }
+});
+
+on(start, "data", ({target}) => {
+  let panel = panelFor(target);
+  let window = domPanel.getContentDocument(target).defaultView;
+
+  attach(styleFor(panel), window);
+});
diff --git a/toolkit/jetpack/sdk/panel/events.js b/toolkit/jetpack/sdk/panel/events.js
new file mode 100644
index 000000000..f3040a11d
--- /dev/null
+++ b/toolkit/jetpack/sdk/panel/events.js
@@ -0,0 +1,27 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+// This module basically translates system/events to a SDK standard events
+// so that `map`, `filter` and other utilities could be used with them.
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const events = require("../system/events");
+const { emit } = require("../event/core");
+
+var channel = {};
+
+function forward({ subject, type, data }) {
+  return emit(channel, "data", { target: subject, type: type, data: data });
+}
+
+["popupshowing", "popuphiding", "popupshown", "popuphidden",
+"document-element-inserted", "DOMContentLoaded", "load"
+].forEach(type => events.on(type, forward));
+
+exports.events = channel;
diff --git a/toolkit/jetpack/sdk/panel/utils.js b/toolkit/jetpack/sdk/panel/utils.js
new file mode 100644
index 000000000..c85b274bc
--- /dev/null
+++ b/toolkit/jetpack/sdk/panel/utils.js
@@ -0,0 +1,451 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci } = require("chrome");
+const { Services } = require("resource://gre/modules/Services.jsm");
+const { setTimeout } = require("../timers");
+const { platform } = require("../system");
+const { getMostRecentBrowserWindow, getOwnerBrowserWindow,
+        getHiddenWindow, getScreenPixelsPerCSSPixel } = require("../window/utils");
+
+const { create: createFrame, swapFrameLoaders, getDocShell } = require("../frame/utils");
+const { window: addonWindow } = require("../addon/window");
+const { isNil } = require("../lang/type");
+const { data } = require('../self');
+
+const events = require("../system/events");
+
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+function calculateRegion({ position, width, height, defaultWidth, defaultHeight }, rect) {
+  position = position || {};
+
+  let x, y;
+
+  let hasTop = !isNil(position.top);
+  let hasRight = !isNil(position.right);
+  let hasBottom = !isNil(position.bottom);
+  let hasLeft = !isNil(position.left);
+  let hasWidth = !isNil(width);
+  let hasHeight = !isNil(height);
+
+  // if width is not specified by constructor or show's options, then get
+  // the default width
+  if (!hasWidth)
+    width = defaultWidth;
+
+  // if height is not specified by constructor or show's options, then get
+  // the default height
+  if (!hasHeight)
+    height = defaultHeight;
+
+  // default position is centered
+  x = (rect.right - width) / 2;
+  y = (rect.top + rect.bottom - height) / 2;
+
+  if (hasTop) {
+    y = rect.top + position.top;
+
+    if (hasBottom && !hasHeight)
+      height = rect.bottom - position.bottom - y;
+  }
+  else if (hasBottom) {
+    y = rect.bottom - position.bottom - height;
+  }
+
+  if (hasLeft) {
+    x = position.left;
+
+    if (hasRight && !hasWidth)
+      width = rect.right - position.right - x;
+  }
+  else if (hasRight) {
+    x = rect.right - width - position.right;
+  }
+
+  return {x: x, y: y, width: width, height: height};
+}
+
+function open(panel, options, anchor) {
+  // Wait for the XBL binding to be constructed
+  if (!panel.openPopup) setTimeout(open, 50, panel, options, anchor);
+  else display(panel, options, anchor);
+}
+exports.open = open;
+
+function isOpen(panel) {
+  return panel.state === "open"
+}
+exports.isOpen = isOpen;
+
+function isOpening(panel) {
+  return panel.state === "showing"
+}
+exports.isOpening = isOpening
+
+function close(panel) {
+  // Sometimes "TypeError: panel.hidePopup is not a function" is thrown
+  // when quitting the host application while a panel is visible.  To suppress
+  // these errors, check for "hidePopup" in panel before calling it.
+  // It's not clear if there's an issue or it's expected behavior.
+  // See Bug 1151796.
+
+  return panel.hidePopup && panel.hidePopup();
+}
+exports.close = close
+
+
+function resize(panel, width, height) {
+  // Resize the iframe instead of using panel.sizeTo
+  // because sizeTo doesn't work with arrow panels
+  if (panel.firstChild) {
+    panel.firstChild.style.width = width + "px";
+    panel.firstChild.style.height = height + "px";
+  }
+}
+exports.resize = resize
+
+function display(panel, options, anchor) {
+  let document = panel.ownerDocument;
+
+  let x, y;
+  let { width, height, defaultWidth, defaultHeight } = options;
+
+  let popupPosition = null;
+
+  // Panel XBL has some SDK incompatible styling decisions. We shim panel
+  // instances until proper fix for Bug 859504 is shipped.
+  shimDefaultStyle(panel);
+
+  if (!anchor) {
+    // The XUL Panel doesn't have an arrow, so the margin needs to be reset
+    // in order to, be positioned properly
+    panel.style.margin = "0";
+
+    let viewportRect = document.defaultView.gBrowser.getBoundingClientRect();
+
+    ({x, y, width, height} = calculateRegion(options, viewportRect));
+  }
+  else {
+    // The XUL Panel has an arrow, so the margin needs to be reset
+    // to the default value.
+    panel.style.margin = "";
+    let { CustomizableUI, window } = anchor.ownerDocument.defaultView;
+
+    // In Australis, widgets may be positioned in an overflow panel or the
+    // menu panel.
+    // In such cases clicking this widget will hide the overflow/menu panel,
+    // and the widget's panel will show instead.
+    // If `CustomizableUI` is not available, it means the anchor is not in a
+    // chrome browser window, and therefore there is no need for this check.
+    if (CustomizableUI) {
+      let node = anchor;
+      ({anchor} = CustomizableUI.getWidget(anchor.id).forWindow(window));
+
+      // if `node` is not the `anchor` itself, it means the widget is
+      // positioned in a panel, therefore we have to hide it before show
+      // the widget's panel in the same anchor
+      if (node !== anchor)
+        CustomizableUI.hidePanelForNode(anchor);
+    }
+
+    width = width || defaultWidth;
+    height = height || defaultHeight;
+
+    // Open the popup by the anchor.
+    let rect = anchor.getBoundingClientRect();
+
+    let zoom = getScreenPixelsPerCSSPixel(window);
+    let screenX = rect.left + window.mozInnerScreenX * zoom;
+    let screenY = rect.top + window.mozInnerScreenY * zoom;
+
+    // Set up the vertical position of the popup relative to the anchor
+    // (always display the arrow on anchor center)
+    let horizontal, vertical;
+    if (screenY > window.screen.availHeight / 2 + height)
+      vertical = "top";
+    else
+      vertical = "bottom";
+
+    if (screenY > window.screen.availWidth / 2 + width)
+      horizontal = "left";
+    else
+      horizontal = "right";
+
+    let verticalInverse = vertical == "top" ? "bottom" : "top";
+    popupPosition = vertical + "center " + verticalInverse + horizontal;
+
+    // Allow panel to flip itself if the panel can't be displayed at the
+    // specified position (useful if we compute a bad position or if the
+    // user moves the window and panel remains visible)
+    panel.setAttribute("flip", "both");
+  }
+
+  if (!panel.viewFrame) {
+    panel.viewFrame = document.importNode(panel.backgroundFrame, false);
+    panel.appendChild(panel.viewFrame);
+
+    let {privateBrowsingId} = getDocShell(panel.viewFrame).getOriginAttributes();
+    let principal = Services.scriptSecurityManager.createNullPrincipal({privateBrowsingId});
+    getDocShell(panel.viewFrame).createAboutBlankContentViewer(principal);
+  }
+
+  // Resize the iframe instead of using panel.sizeTo
+  // because sizeTo doesn't work with arrow panels
+  panel.firstChild.style.width = width + "px";
+  panel.firstChild.style.height = height + "px";
+
+  panel.openPopup(anchor, popupPosition, x, y);
+}
+exports.display = display;
+
+// This utility function is just a workaround until Bug 859504 has shipped.
+function shimDefaultStyle(panel) {
+  let document = panel.ownerDocument;
+  // Please note that `panel` needs to be part of document in order to reach
+  // it's anonymous nodes. One of the anonymous node has a big padding which
+  // doesn't work well since panel frame needs to fill all of the panel.
+  // XBL binding is a not the best option as it's applied asynchronously, and
+  // makes injected frames behave in strange way. Also this feels a lot
+  // cheaper to do.
+  ["panel-inner-arrowcontent", "panel-arrowcontent"].forEach(function(value) {
+    let node = document.getAnonymousElementByAttribute(panel, "class", value);
+      if (node) node.style.padding = 0;
+  });
+}
+
+function show(panel, options, anchor) {
+  // Prevent the panel from getting focus when showing up
+  // if focus is set to false
+  panel.setAttribute("noautofocus", !options.focus);
+
+  let window = anchor && getOwnerBrowserWindow(anchor);
+  let { document } = window ? window : getMostRecentBrowserWindow();
+  attach(panel, document);
+
+  open(panel, options, anchor);
+}
+exports.show = show
+
+function onPanelClick(event) {
+  let { target, metaKey, ctrlKey, shiftKey, button } = event;
+  let accel = platform === "darwin" ? metaKey : ctrlKey;
+  let isLeftClick = button === 0;
+  let isMiddleClick = button === 1;
+
+  if ((isLeftClick && (accel || shiftKey)) || isMiddleClick) {
+    let link = target.closest('a');
+
+    if (link && link.href)
+       getMostRecentBrowserWindow().openUILink(link.href, event)
+  }
+}
+
+function setupPanelFrame(frame) {
+  frame.setAttribute("flex", 1);
+  frame.setAttribute("transparent", "transparent");
+  frame.setAttribute("autocompleteenabled", true);
+  frame.setAttribute("tooltip", "aHTMLTooltip");
+  if (platform === "darwin") {
+    frame.style.borderRadius = "var(--arrowpanel-border-radius, 3.5px)";
+    frame.style.padding = "1px";
+  }
+}
+
+function make(document, options) {
+  document = document || getMostRecentBrowserWindow().document;
+  let panel = document.createElementNS(XUL_NS, "panel");
+  panel.setAttribute("type", "arrow");
+  panel.setAttribute("sdkscriptenabled", options.allowJavascript);
+
+  // The panel needs to be attached to a browser window in order for us
+  // to copy browser styles to the content document when it loads.
+  attach(panel, document);
+
+  let frameOptions =  {
+    allowJavascript: options.allowJavascript,
+    allowPlugins: true,
+    allowAuth: true,
+    allowWindowControl: false,
+    // Need to override `nodeName` to use `iframe` as `browsers` save session
+    // history and in consequence do not dispatch "inner-window-destroyed"
+    // notifications.
+    browser: false,
+  };
+
+  let backgroundFrame = createFrame(addonWindow, frameOptions);
+  setupPanelFrame(backgroundFrame);
+
+  getDocShell(backgroundFrame).inheritPrivateBrowsingId = false;
+
+  function onPopupShowing({type, target}) {
+    if (target === this) {
+      let attrs = getDocShell(backgroundFrame).getOriginAttributes();
+      getDocShell(panel.viewFrame).setOriginAttributes(attrs);
+
+      swapFrameLoaders(backgroundFrame, panel.viewFrame);
+    }
+  }
+
+  function onPopupHiding({type, target}) {
+    if (target === this) {
+      swapFrameLoaders(backgroundFrame, panel.viewFrame);
+
+      panel.viewFrame.remove();
+      panel.viewFrame = null;
+    }
+  }
+
+  function onContentReady({target, type}) {
+    if (target === getContentDocument(panel)) {
+      style(panel);
+      events.emit(type, { subject: panel });
+    }
+  }
+
+  function onContentLoad({target, type}) {
+    if (target === getContentDocument(panel))
+      events.emit(type, { subject: panel });
+  }
+
+  function onContentChange({subject: document, type}) {
+    if (document === getContentDocument(panel) && document.defaultView)
+      events.emit(type, { subject: panel });
+  }
+
+  function onPanelStateChange({target, type}) {
+    if (target === this)
+      events.emit(type, { subject: panel })
+  }
+
+  panel.addEventListener("popupshowing", onPopupShowing);
+  panel.addEventListener("popuphiding", onPopupHiding);
+  for (let event of ["popupshowing", "popuphiding", "popupshown", "popuphidden"])
+    panel.addEventListener(event, onPanelStateChange);
+
+  panel.addEventListener("click", onPanelClick, false);
+
+  // Panel content document can be either in panel `viewFrame` or in
+  // a `backgroundFrame` depending on panel state. Listeners are set
+  // on both to avoid setting and removing listeners on panel state changes.
+
+  panel.addEventListener("DOMContentLoaded", onContentReady, true);
+  backgroundFrame.addEventListener("DOMContentLoaded", onContentReady, true);
+
+  panel.addEventListener("load", onContentLoad, true);
+  backgroundFrame.addEventListener("load", onContentLoad, true);
+
+  events.on("document-element-inserted", onContentChange);
+
+  panel.backgroundFrame = backgroundFrame;
+  panel.viewFrame = null;
+
+  // Store event listener on the panel instance so that it won't be GC-ed
+  // while panel is alive.
+  panel.onContentChange = onContentChange;
+
+  return panel;
+}
+exports.make = make;
+
+function attach(panel, document) {
+  document = document || getMostRecentBrowserWindow().document;
+  let container = document.getElementById("mainPopupSet");
+  if (container !== panel.parentNode) {
+    detach(panel);
+    document.getElementById("mainPopupSet").appendChild(panel);
+  }
+}
+exports.attach = attach;
+
+function detach(panel) {
+  if (panel.parentNode) panel.parentNode.removeChild(panel);
+}
+exports.detach = detach;
+
+function dispose(panel) {
+  panel.backgroundFrame.remove();
+  panel.backgroundFrame = null;
+  events.off("document-element-inserted", panel.onContentChange);
+  panel.onContentChange = null;
+  detach(panel);
+}
+exports.dispose = dispose;
+
+function style(panel) {
+  /**
+  Injects default OS specific panel styles into content document that is loaded
+  into given panel. Optionally `document` of the browser window can be
+  given to inherit styles from it, by default it will use either panel owner
+  document or an active browser's document. It should not matter though unless
+  Firefox decides to style windows differently base on profile or mode like
+  chrome for example.
+  **/
+
+  try {
+    let document = panel.ownerDocument;
+    let contentDocument = getContentDocument(panel);
+    let window = document.defaultView;
+    let node = document.getAnonymousElementByAttribute(panel, "class",
+                                                       "panel-arrowcontent");
+
+    let { color, fontFamily, fontSize, fontWeight } = window.getComputedStyle(node);
+
+    let style = contentDocument.createElement("style");
+    style.id = "sdk-panel-style";
+    style.textContent = "body { " +
+      "color: " + color + ";" +
+      "font-family: " + fontFamily + ";" +
+      "font-weight: " + fontWeight + ";" +
+      "font-size: " + fontSize + ";" +
+    "}";
+
+    let container = contentDocument.head ? contentDocument.head :
+                    contentDocument.documentElement;
+
+    if (container.firstChild)
+      container.insertBefore(style, container.firstChild);
+    else
+      container.appendChild(style);
+  }
+  catch (error) {
+    console.error("Unable to apply panel style");
+    console.exception(error);
+  }
+}
+exports.style = style;
+
+var getContentFrame = panel => panel.viewFrame || panel.backgroundFrame;
+exports.getContentFrame = getContentFrame;
+
+function getContentDocument(panel) {
+  return getContentFrame(panel).contentDocument;
+}
+exports.getContentDocument = getContentDocument;
+
+function setURL(panel, url) {
+  let frame = getContentFrame(panel);
+  let webNav = getDocShell(frame).QueryInterface(Ci.nsIWebNavigation);
+
+  webNav.loadURI(url ? data.url(url) : "about:blank", 0, null, null, null);
+}
+
+exports.setURL = setURL;
+
+function allowContextMenu(panel, allow) {
+  if (allow) {
+    panel.setAttribute("context", "contentAreaContextMenu");
+  }
+  else {
+    panel.removeAttribute("context");
+  }
+}
+exports.allowContextMenu = allowContextMenu;
diff --git a/toolkit/jetpack/sdk/passwords.js b/toolkit/jetpack/sdk/passwords.js
new file mode 100644
index 000000000..70f0aa4da
--- /dev/null
+++ b/toolkit/jetpack/sdk/passwords.js
@@ -0,0 +1,61 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { search, remove, store } = require("./passwords/utils");
+const { defer, delay } = require("./lang/functional");
+
+/**
+ * Utility function that returns `onComplete` and `onError` callbacks form the
+ * given `options` objects. Also properties are removed from the passed
+ * `options` objects.
+ * @param {Object} options
+ *    Object that is passed to the exported functions of this module.
+ * @returns {Function[]}
+ *    Array with two elements `onComplete` and `onError` functions.
+ */
+function getCallbacks(options) {
+  let value = [
+    'onComplete' in options ? options.onComplete : null,
+    'onError' in options ? defer(options.onError) : console.exception
+  ];
+
+  delete options.onComplete;
+  delete options.onError;
+
+  return value;
+};
+
+/**
+ * Creates a wrapper function that tries to call `onComplete` with a return
+ * value of the wrapped function or falls back to `onError` if wrapped function
+ * throws an exception.
+ */
+function createWrapperMethod(wrapped) {
+  return function (options) {
+    let [ onComplete, onError ] = getCallbacks(options);
+    try {
+      let value = wrapped(options);
+      if (onComplete) {
+        delay(function() {
+          try {
+            onComplete(value);
+          } catch (exception) {
+            onError(exception);
+          }
+        });
+      }
+    } catch (exception) {
+      onError(exception);
+    }
+  };
+}
+
+exports.search = createWrapperMethod(search);
+exports.store = createWrapperMethod(store);
+exports.remove = createWrapperMethod(remove);
diff --git a/toolkit/jetpack/sdk/passwords/utils.js b/toolkit/jetpack/sdk/passwords/utils.js
new file mode 100644
index 000000000..334efa490
--- /dev/null
+++ b/toolkit/jetpack/sdk/passwords/utils.js
@@ -0,0 +1,107 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci, CC } = require("chrome");
+const { uri: ADDON_URI } = require("../self");
+const loginManager = Cc["@mozilla.org/login-manager;1"].
+                     getService(Ci.nsILoginManager);
+const { URL: parseURL } = require("../url");
+const LoginInfo = CC("@mozilla.org/login-manager/loginInfo;1",
+                     "nsILoginInfo", "init");
+
+function filterMatchingLogins(loginInfo) {
+  return Object.keys(this).every(key => loginInfo[key] === this[key], this);
+}
+
+/**
+ * Removes `user`, `password` and `path` fields from the given `url` if it's
+ * 'http', 'https' or 'ftp'. All other URLs are returned unchanged.
+ * @example
+ * http://user:pass@www.site.com/foo/?bar=baz#bang -> http://www.site.com
+ */
+function normalizeURL(url) {
+  let { scheme, host, port } = parseURL(url);
+  // We normalize URL only if it's `http`, `https` or `ftp`. All other types of
+  // URLs (`resource`, `chrome`, etc..) should not be normalized as they are
+  // used with add-on associated credentials path.
+  return scheme === "http" || scheme === "https" || scheme === "ftp" ?
+         scheme + "://" + (host || "") + (port ? ":" + port : "") :
+         url
+}
+
+function Login(options) {
+  let login = Object.create(Login.prototype);
+  Object.keys(options || {}).forEach(function(key) {
+    if (key === 'url')
+      login.hostname = normalizeURL(options.url);
+    else if (key === 'formSubmitURL')
+      login.formSubmitURL = options.formSubmitURL ?
+                            normalizeURL(options.formSubmitURL) : null;
+    else if (key === 'realm')
+      login.httpRealm = options.realm;
+    else 
+      login[key] = options[key];
+  });
+
+  return login;
+}
+Login.prototype.toJSON = function toJSON() {
+  return {
+    url: this.hostname || ADDON_URI,
+    realm: this.httpRealm || null,
+    formSubmitURL: this.formSubmitURL || null,
+    username: this.username || null,
+    password: this.password || null,
+    usernameField: this.usernameField || '',
+    passwordField: this.passwordField || '',
+  }
+};
+Login.prototype.toLoginInfo = function toLoginInfo() {
+  let { url, realm, formSubmitURL, username, password, usernameField,
+        passwordField } = this.toJSON();
+
+  return new LoginInfo(url, formSubmitURL, realm, username, password,
+                       usernameField, passwordField);
+};
+
+function loginToJSON(value) {
+  return Login(value).toJSON();
+}
+
+/**
+ * Returns array of `nsILoginInfo` objects that are stored in the login manager
+ * and have all the properties with matching values as a given `options` object.
+ * @param {Object} options
+ * @returns {nsILoginInfo[]}
+ */
+exports.search = function search(options) {
+  return loginManager.getAllLogins()
+                     .filter(filterMatchingLogins, Login(options))
+                     .map(loginToJSON);
+};
+
+/**
+ * Stores login info created from the given `options` to the applications
+ * built-in login management system.
+ * @param {Object} options.
+ */
+exports.store = function store(options) {
+  loginManager.addLogin(Login(options).toLoginInfo());
+};
+
+/**
+ * Removes login info from the applications built-in login management system.
+ * _Please note: When removing a login info the specified properties must
+ * exactly match to the one that is already stored or exception will be thrown._
+ * @param {Object} options.
+ */
+exports.remove = function remove(options) {
+  loginManager.removeLogin(Login(options).toLoginInfo());
+};
diff --git a/toolkit/jetpack/sdk/places/bookmarks.js b/toolkit/jetpack/sdk/places/bookmarks.js
new file mode 100644
index 000000000..c4f9528f1
--- /dev/null
+++ b/toolkit/jetpack/sdk/places/bookmarks.js
@@ -0,0 +1,395 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable",
+  "engines": {
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+/*
+ * Requiring hosts so they can subscribe to client messages
+ */
+require('./host/host-bookmarks');
+require('./host/host-tags');
+require('./host/host-query');
+
+const { Cc, Ci } = require('chrome');
+const { Class } = require('../core/heritage');
+const { send } = require('../addon/events');
+const { defer, reject, all, resolve, promised } = require('../core/promise');
+const { EventTarget } = require('../event/target');
+const { emit } = require('../event/core');
+const { identity, defer:async } = require('../lang/functional');
+const { extend, merge } = require('../util/object');
+const { fromIterator } = require('../util/array');
+const {
+  constructTree, fetchItem, createQuery,
+  isRootGroup, createQueryOptions
+} = require('./utils');
+const {
+  bookmarkContract, groupContract, separatorContract
+} = require('./contract');
+const bmsrv = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+                getService(Ci.nsINavBookmarksService);
+
+/*
+ * Mapping of uncreated bookmarks with their created
+ * counterparts
+ */
+const itemMap = new WeakMap();
+
+/*
+ * Constant used by nsIHistoryQuery; 1 is a bookmark query
+ * https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryQueryOptions
+ */
+const BOOKMARK_QUERY = 1;
+
+/*
+ * Bookmark Item classes
+ */
+
+const Bookmark = Class({
+  extends: [
+    bookmarkContract.properties(identity)
+  ],
+  initialize: function initialize (options) {
+    merge(this, bookmarkContract(extend(defaults, options)));
+  },
+  type: 'bookmark',
+  toString: () => '[object Bookmark]'
+});
+exports.Bookmark = Bookmark;
+
+const Group = Class({
+  extends: [
+    groupContract.properties(identity)
+  ],
+  initialize: function initialize (options) {
+    // Don't validate if root group
+    if (isRootGroup(options))
+      merge(this, options);
+    else
+      merge(this, groupContract(extend(defaults, options)));
+  },
+  type: 'group',
+  toString: () => '[object Group]'
+});
+exports.Group = Group;
+
+const Separator = Class({
+  extends: [
+    separatorContract.properties(identity)
+  ],
+  initialize: function initialize (options) {
+    merge(this, separatorContract(extend(defaults, options)));
+  },
+  type: 'separator',
+  toString: () => '[object Separator]'
+});
+exports.Separator = Separator;
+
+/*
+ * Functions
+ */
+
+function save (items, options) {
+  items = [].concat(items);
+  options = options || {};
+  let emitter = EventTarget();
+  let results = [];
+  let errors = [];
+  let root = constructTree(items);
+  let cache = new Map();
+
+  let isExplicitSave = item => !!~items.indexOf(item);
+  // `walk` returns an aggregate promise indicating the completion
+  // of the `commitItem` on each node, not whether or not that
+  // commit was successful
+
+  // Force this to be async, as if a ducktype fails validation,
+  // the promise implementation will fire an error event, which will
+  // not trigger the handler as it's not yet bound
+  //
+  // Can remove after `Promise.jsm` is implemented in Bug 881047,
+  // which will guarantee next tick execution
+  async(() => root.walk(preCommitItem).then(commitComplete))();
+
+  function preCommitItem ({value:item}) {
+    // Do nothing if tree root, default group (unsavable),
+    // or if it's a dependency and not explicitly saved (in the list
+    // of items to be saved), and not needed to be saved
+    if (item === null || // node is the tree root
+        isRootGroup(item) ||
+        (getId(item) && !isExplicitSave(item)))
+      return;
+
+    return promised(validate)(item)
+      .then(() => commitItem(item, options))
+      .then(data => construct(data, cache))
+      .then(savedItem => {
+        // If item was just created, make a map between
+        // the creation object and created object,
+        // so we can reference the item that doesn't have an id
+        if (!getId(item))
+          saveId(item, savedItem.id);
+
+        // Emit both the processed item, and original item
+        // so a mapping can be understood in handler
+        emit(emitter, 'data', savedItem, item);
+       
+        // Push to results iff item was explicitly saved
+        if (isExplicitSave(item))
+          results[items.indexOf(item)] = savedItem;
+      }, reason => {
+        // Force reason to be a string for consistency
+        reason = reason + '';
+        // Emit both the reason, and original item
+        // so a mapping can be understood in handler
+        emit(emitter, 'error', reason + '', item);
+        // Store unsaved item in results list
+        results[items.indexOf(item)] = item;
+        errors.push(reason);
+      });
+  }
+
+  // Called when traversal of the node tree is completed and all
+  // items have been committed
+  function commitComplete () {
+    emit(emitter, 'end', results);
+  }
+
+  return emitter;
+}
+exports.save = save;
+
+function search (queries, options) {
+  queries = [].concat(queries);
+  let emitter = EventTarget();
+  let cache = new Map();
+  let queryObjs = queries.map(createQuery.bind(null, BOOKMARK_QUERY));
+  let optionsObj = createQueryOptions(BOOKMARK_QUERY, options);
+
+  // Can remove after `Promise.jsm` is implemented in Bug 881047,
+  // which will guarantee next tick execution
+  async(() => {
+    send('sdk-places-query', { queries: queryObjs, options: optionsObj })
+      .then(handleQueryResponse);
+  })();
+    
+  function handleQueryResponse (data) {
+    let deferreds = data.map(item => {
+      return construct(item, cache).then(bookmark => {
+        emit(emitter, 'data', bookmark);
+        return bookmark;
+      }, reason => {
+        emit(emitter, 'error', reason);
+        errors.push(reason);
+      });
+    });
+
+    all(deferreds).then(data => {
+      emit(emitter, 'end', data);
+    }, () => emit(emitter, 'end', []));
+  }
+
+  return emitter;
+}
+exports.search = search;
+
+function remove (items) {
+  return [].concat(items).map(item => {
+    item.remove = true;
+    return item;
+  });
+}
+
+exports.remove = remove;
+
+/*
+ * Internal Utilities
+ */
+
+function commitItem (item, options) {
+  // Get the item's ID, or getId it's saved version if it exists
+  let id = getId(item);
+  let data = normalize(item);
+  let promise;
+
+  data.id = id;
+
+  if (!id) {
+    promise = send('sdk-places-bookmarks-create', data);
+  } else if (item.remove) {
+    promise = send('sdk-places-bookmarks-remove', { id: id });
+  } else {
+    promise = send('sdk-places-bookmarks-last-updated', {
+      id: id
+    }).then(function (updated) {
+      // If attempting to save an item that is not the 
+      // latest snapshot of a bookmark item, execute
+      // the resolution function
+      if (updated !== item.updated && options.resolve)
+        return fetchItem(id)
+          .then(options.resolve.bind(null, data));
+      else
+        return data;
+    }).then(send.bind(null, 'sdk-places-bookmarks-save'));
+  }
+
+  return promise;
+}
+
+/*
+ * Turns a bookmark item into a plain object,
+ * converts `tags` from Set to Array, group instance to an id
+ */
+function normalize (item) {
+  let data = merge({}, item);
+  // Circumvent prototype property of `type`
+  delete data.type;
+  data.type = item.type;
+  data.tags = [];
+  if (item.tags) {
+    data.tags = fromIterator(item.tags);
+  }
+  data.group = getId(data.group) || exports.UNSORTED.id;
+
+  return data;
+}
+
+/*
+ * Takes a data object and constructs a BookmarkItem instance
+ * of it, recursively generating parent instances as well.
+ *
+ * Pass in a `cache` Map to reuse instances of
+ * bookmark items to reduce overhead;
+ * The cache object is a map of id to a deferred with a 
+ * promise that resolves to the bookmark item.
+ */
+function construct (object, cache, forced) {
+  let item = instantiate(object);
+  let deferred = defer();
+
+  // Item could not be instantiated
+  if (!item)
+    return resolve(null);
+
+  // Return promise for item if found in the cache,
+  // and not `forced`. `forced` indicates that this is the construct
+  // call that should not read from cache, but should actually perform
+  // the construction, as it was set before several async calls
+  if (cache.has(item.id) && !forced)
+    return cache.get(item.id).promise;
+  else if (cache.has(item.id))
+    deferred = cache.get(item.id);
+  else
+    cache.set(item.id, deferred);
+
+  // When parent group is found in cache, use
+  // the same deferred value
+  if (item.group && cache.has(item.group)) {
+    cache.get(item.group).promise.then(group => {
+      item.group = group;
+      deferred.resolve(item);
+    });
+
+  // If not in the cache, and a root group, return
+  // the premade instance
+  } else if (rootGroups.get(item.group)) {
+    item.group = rootGroups.get(item.group);
+    deferred.resolve(item);
+
+  // If not in the cache or a root group, fetch the parent
+  } else {
+    cache.set(item.group, defer());
+    fetchItem(item.group).then(group => {
+      return construct(group, cache, true);
+    }).then(group => {
+      item.group = group;
+      deferred.resolve(item);
+    }, deferred.reject);
+  }
+
+  return deferred.promise;
+}
+
+function instantiate (object) {
+  if (object.type === 'bookmark')
+    return Bookmark(object);
+  if (object.type === 'group')
+    return Group(object);
+  if (object.type === 'separator')
+    return Separator(object);
+  return null;
+}
+
+/**
+ * Validates a bookmark item; will throw an error if ininvalid,
+ * to be used with `promised`. As bookmark items check on their class,
+ * this only checks ducktypes
+ */
+function validate (object) {
+  if (!isDuckType(object)) return true;
+  let contract = object.type === 'bookmark' ? bookmarkContract :
+                 object.type === 'group' ? groupContract :
+                 object.type === 'separator' ? separatorContract :
+                 null;
+  if (!contract) {
+    throw Error('No type specified');
+  }
+
+  // If object has a property set, and undefined,
+  // manually override with default as it'll fail otherwise
+  let withDefaults = Object.keys(defaults).reduce((obj, prop) => {
+    if (obj[prop] == null) obj[prop] = defaults[prop];
+    return obj;
+  }, extend(object));
+
+  contract(withDefaults);
+}
+
+function isDuckType (item) {
+  return !(item instanceof Bookmark) &&
+    !(item instanceof Group) &&
+    !(item instanceof Separator);
+}
+
+function saveId (unsaved, id) {
+  itemMap.set(unsaved, id);
+}
+
+// Fetches an item's ID from itself, or from the mapped items
+function getId (item) {
+  return typeof item === 'number' ? item :
+    item ? item.id || itemMap.get(item) :
+    null;
+}
+
+/*
+ * Set up the default, root groups
+ */
+
+var defaultGroupMap = {
+  MENU: bmsrv.bookmarksMenuFolder,
+  TOOLBAR: bmsrv.toolbarFolder,
+  UNSORTED: bmsrv.unfiledBookmarksFolder
+};
+
+var rootGroups = new Map();
+
+for (let i in defaultGroupMap) {
+  let group = Object.freeze(Group({ title: i, id: defaultGroupMap[i] }));
+  rootGroups.set(defaultGroupMap[i], group);
+  exports[i] = group;
+}
+
+var defaults = {
+  group: exports.UNSORTED,
+  index: -1
+};
diff --git a/toolkit/jetpack/sdk/places/contract.js b/toolkit/jetpack/sdk/places/contract.js
new file mode 100644
index 000000000..a3541c34d
--- /dev/null
+++ b/toolkit/jetpack/sdk/places/contract.js
@@ -0,0 +1,73 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci } = require('chrome');
+const { isValidURI, URL } = require('../url');
+const { contract } = require('../util/contract');
+const { extend } = require('../util/object');
+
+// map of property validations
+const validItem = {
+  id: {
+    is: ['number', 'undefined', 'null'],
+  },
+  group: {
+    is: ['object', 'number', 'undefined', 'null'],
+    ok: function (value) {
+      return value &&
+        (value.toString && value.toString() === '[object Group]') ||
+        typeof value === 'number' ||
+        value.type === 'group';
+    },
+    msg: 'The `group` property must be a valid Group object'
+  },
+  index: {
+    is: ['undefined', 'null', 'number'],
+    map: value => value == null ? -1 : value,
+    msg: 'The `index` property must be a number.'
+  },
+  updated: {
+    is: ['number', 'undefined']
+  }
+};
+
+const validTitle = {
+  title: {
+    is: ['string'],
+    msg: 'The `title` property must be defined.'
+  }
+};
+
+const validURL = {
+  url: {
+    is: ['string'],
+    ok: isValidURI,
+    msg: 'The `url` property must be a valid URL.'
+  }
+};
+
+const validTags = {
+  tags: {
+    is: ['object'],
+    ok: tags => tags instanceof Set,
+    map: function (tags) {
+      if (Array.isArray(tags))
+        return new Set(tags);
+      if (tags == null)
+        return new Set();
+      return tags;
+    },
+    msg: 'The `tags` property must be a Set, or an array'
+  }
+};
+
+exports.bookmarkContract = contract(
+  extend(validItem, validTitle, validURL, validTags));
+exports.separatorContract = contract(validItem);
+exports.groupContract = contract(extend(validItem, validTitle));
diff --git a/toolkit/jetpack/sdk/places/events.js b/toolkit/jetpack/sdk/places/events.js
new file mode 100644
index 000000000..a3f95ee03
--- /dev/null
+++ b/toolkit/jetpack/sdk/places/events.js
@@ -0,0 +1,128 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental',
+  'engines': {
+    'Firefox': '*',
+    "SeaMonkey": '*'
+  }
+};
+
+const { Cc, Ci } = require('chrome');
+const { Unknown } = require('../platform/xpcom');
+const { Class } = require('../core/heritage');
+const { merge } = require('../util/object');
+const bookmarkService = Cc['@mozilla.org/browser/nav-bookmarks-service;1']
+                        .getService(Ci.nsINavBookmarksService);
+const historyService = Cc['@mozilla.org/browser/nav-history-service;1']
+                       .getService(Ci.nsINavHistoryService);
+const { mapBookmarkItemType } = require('./utils');
+const { EventTarget } = require('../event/target');
+const { emit } = require('../event/core');
+const { when } = require('../system/unload');
+
+const emitter = EventTarget();
+
+var HISTORY_ARGS = {
+  onBeginUpdateBatch: [],
+  onEndUpdateBatch: [],
+  onClearHistory: [],
+  onDeleteURI: ['url'],
+  onDeleteVisits: ['url', 'visitTime'],
+  onPageChanged: ['url', 'property', 'value'],
+  onTitleChanged: ['url', 'title'],
+  onVisit: [
+    'url', 'visitId', 'time', 'sessionId', 'referringId', 'transitionType'
+  ]
+};
+
+var HISTORY_EVENTS = {
+  onBeginUpdateBatch: 'history-start-batch',
+  onEndUpdateBatch: 'history-end-batch',
+  onClearHistory: 'history-start-clear',
+  onDeleteURI: 'history-delete-url',
+  onDeleteVisits: 'history-delete-visits',
+  onPageChanged: 'history-page-changed',
+  onTitleChanged: 'history-title-changed',
+  onVisit: 'history-visit'
+};
+
+var BOOKMARK_ARGS = {
+  onItemAdded: [
+    'id', 'parentId', 'index', 'type', 'url', 'title', 'dateAdded'
+  ],
+  onItemChanged: [
+    'id', 'property', null, 'value', 'lastModified', 'type', 'parentId'
+  ],
+  onItemMoved: [
+    'id', 'previousParentId', 'previousIndex', 'currentParentId',
+    'currentIndex', 'type'
+  ],
+  onItemRemoved: ['id', 'parentId', 'index', 'type', 'url'],
+  onItemVisited: ['id', 'visitId', 'time', 'transitionType', 'url', 'parentId']
+};
+
+var BOOKMARK_EVENTS = {
+  onItemAdded: 'bookmark-item-added',
+  onItemChanged: 'bookmark-item-changed',
+  onItemMoved: 'bookmark-item-moved',
+  onItemRemoved: 'bookmark-item-removed',
+  onItemVisited: 'bookmark-item-visited',
+};
+
+function createHandler (type, propNames) {
+  propNames = propNames || [];
+  return function (...args) {
+    let data = propNames.reduce((acc, prop, i) => {
+      if (prop)
+        acc[prop] = formatValue(prop, args[i]);
+      return acc;
+    }, {});
+
+    emit(emitter, 'data', {
+      type: type,
+      data: data
+    });
+  };
+}
+
+/*
+ * Creates an observer, creating handlers based off of
+ * the `events` names, and ordering arguments from `propNames` hash
+ */
+function createObserverInstance (events, propNames) {
+  let definition = Object.keys(events).reduce((prototype, eventName) => {
+    prototype[eventName] = createHandler(events[eventName], propNames[eventName]);
+    return prototype;
+  }, {});
+
+  return Class(merge(definition, { extends: Unknown }))();
+}
+
+/*
+ * Formats `data` based off of the value of `type`
+ */
+function formatValue (type, data) {
+  if (type === 'type')
+    return mapBookmarkItemType(data);
+  if (type === 'url' && data)
+    return data.spec;
+  return data;
+}
+
+var historyObserver = createObserverInstance(HISTORY_EVENTS, HISTORY_ARGS);
+historyService.addObserver(historyObserver, false);
+
+var bookmarkObserver = createObserverInstance(BOOKMARK_EVENTS, BOOKMARK_ARGS);
+bookmarkService.addObserver(bookmarkObserver, false);
+
+when(() => {
+  historyService.removeObserver(historyObserver);
+  bookmarkService.removeObserver(bookmarkObserver);
+});
+
+exports.events = emitter;
diff --git a/toolkit/jetpack/sdk/places/favicon.js b/toolkit/jetpack/sdk/places/favicon.js
new file mode 100644
index 000000000..05b057db1
--- /dev/null
+++ b/toolkit/jetpack/sdk/places/favicon.js
@@ -0,0 +1,49 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable",
+  "engines": {
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+const { Cc, Ci, Cu } = require("chrome");
+const { defer, reject } = require("../core/promise");
+const FaviconService = Cc["@mozilla.org/browser/favicon-service;1"].
+                          getService(Ci.nsIFaviconService);
+const AsyncFavicons = FaviconService.QueryInterface(Ci.mozIAsyncFavicons);
+const { isValidURI } = require("../url");
+const { newURI, getURL } = require("../url/utils");
+
+/**
+ * Takes an object of several possible types and
+ * returns a promise that resolves to the page's favicon URI.
+ * @param {String|Tab} object
+ * @param {Function} (callback)
+ * @returns {Promise}
+ */
+
+function getFavicon (object, callback) {
+  let url = getURL(object);
+  let deferred = defer();
+
+  if (url && isValidURI(url)) {
+    AsyncFavicons.getFaviconURLForPage(newURI(url), function (aURI) {
+      if (aURI && aURI.spec)
+        deferred.resolve(aURI.spec.toString());
+      else
+        deferred.reject(null);
+    });
+  } else {
+    deferred.reject(null);
+  }
+
+  if (callback) deferred.promise.then(callback, callback);
+  return deferred.promise;
+}
+exports.getFavicon = getFavicon;
diff --git a/toolkit/jetpack/sdk/places/history.js b/toolkit/jetpack/sdk/places/history.js
new file mode 100644
index 000000000..b243b024c
--- /dev/null
+++ b/toolkit/jetpack/sdk/places/history.js
@@ -0,0 +1,65 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable",
+  "engines": {
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+/*
+ * Requiring hosts so they can subscribe to client messages
+ */
+require('./host/host-bookmarks');
+require('./host/host-tags');
+require('./host/host-query');
+
+const { Cc, Ci } = require('chrome');
+const { Class } = require('../core/heritage');
+const { events, send } = require('../addon/events');
+const { defer, reject, all } = require('../core/promise');
+const { uuid } = require('../util/uuid');
+const { flatten } = require('../util/array');
+const { has, extend, merge, pick } = require('../util/object');
+const { emit } = require('../event/core');
+const { defer: async } = require('../lang/functional');
+const { EventTarget } = require('../event/target');
+const {
+  urlQueryParser, createQuery, createQueryOptions
+} = require('./utils');
+
+/*
+ * Constant used by nsIHistoryQuery; 0 is a history query
+ * https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryQueryOptions
+ */
+const HISTORY_QUERY = 0;
+
+var search = function query (queries, options) {
+  queries = [].concat(queries);
+  let emitter = EventTarget();
+  let queryObjs = queries.map(createQuery.bind(null, HISTORY_QUERY));
+  let optionsObj = createQueryOptions(HISTORY_QUERY, options);
+
+  // Can remove after `Promise.jsm` is implemented in Bug 881047,
+  // which will guarantee next tick execution
+  async(() => {
+    send('sdk-places-query', {
+      query: queryObjs,
+      options: optionsObj
+    }).then(results => {
+      results.map(item => emit(emitter, 'data', item));
+      emit(emitter, 'end', results);
+    }, reason => {
+      emit(emitter, 'error', reason);
+      emit(emitter, 'end', []);
+    });
+  })();
+
+  return emitter;
+};
+exports.search = search;
diff --git a/toolkit/jetpack/sdk/places/host/host-bookmarks.js b/toolkit/jetpack/sdk/places/host/host-bookmarks.js
new file mode 100644
index 000000000..3245c4070
--- /dev/null
+++ b/toolkit/jetpack/sdk/places/host/host-bookmarks.js
@@ -0,0 +1,238 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+const { Cc, Ci } = require('chrome');
+const browserHistory = Cc["@mozilla.org/browser/nav-history-service;1"].
+                       getService(Ci.nsIBrowserHistory);
+const asyncHistory = Cc["@mozilla.org/browser/history;1"].
+                     getService(Ci.mozIAsyncHistory);
+const bmsrv = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+                        getService(Ci.nsINavBookmarksService);
+const taggingService = Cc["@mozilla.org/browser/tagging-service;1"].
+                       getService(Ci.nsITaggingService);
+const ios = Cc['@mozilla.org/network/io-service;1'].
+            getService(Ci.nsIIOService);
+const { query } = require('./host-query');
+const {
+  defer, all, resolve, promised, reject
+} = require('../../core/promise');
+const { request, response } = require('../../addon/host');
+const { send } = require('../../addon/events');
+const { on, emit } = require('../../event/core');
+const { filter } = require('../../event/utils');
+const { URL, isValidURI } = require('../../url');
+const { newURI } = require('../../url/utils');
+
+const DEFAULT_INDEX = bmsrv.DEFAULT_INDEX;
+const UNSORTED_ID = bmsrv.unfiledBookmarksFolder;
+const ROOT_FOLDERS = [
+  bmsrv.unfiledBookmarksFolder, bmsrv.toolbarFolder,
+  bmsrv.tagsFolder, bmsrv.bookmarksMenuFolder
+];
+
+const EVENT_MAP = {
+  'sdk-places-bookmarks-create': createBookmarkItem,
+  'sdk-places-bookmarks-save': saveBookmarkItem,
+  'sdk-places-bookmarks-last-updated': getBookmarkLastUpdated,
+  'sdk-places-bookmarks-get': getBookmarkItem,
+  'sdk-places-bookmarks-remove': removeBookmarkItem,
+  'sdk-places-bookmarks-get-all': getAllBookmarks,
+  'sdk-places-bookmarks-get-children': getChildren
+};
+
+function typeMap (type) {
+  if (typeof type === 'number') {
+    if (bmsrv.TYPE_BOOKMARK === type) return 'bookmark';
+    if (bmsrv.TYPE_FOLDER === type) return 'group';
+    if (bmsrv.TYPE_SEPARATOR === type) return 'separator';
+  } else {
+    if ('bookmark' === type) return bmsrv.TYPE_BOOKMARK;
+    if ('group' === type) return bmsrv.TYPE_FOLDER;
+    if ('separator' === type) return bmsrv.TYPE_SEPARATOR;
+  }
+}
+
+function getBookmarkLastUpdated ({id}) {
+  return resolve(bmsrv.getItemLastModified(id));
+}
+exports.getBookmarkLastUpdated;
+
+function createBookmarkItem (data) {
+  let error;
+
+  if (data.group == null) data.group = UNSORTED_ID;
+  if (data.index == null) data.index = DEFAULT_INDEX;
+
+  if (data.type === 'group')
+    data.id = bmsrv.createFolder(
+      data.group, data.title, data.index
+    );
+  else if (data.type === 'separator')
+    data.id = bmsrv.insertSeparator(
+      data.group, data.index
+    );
+  else
+    data.id = bmsrv.insertBookmark(
+      data.group, newURI(data.url), data.index, data.title
+    );
+
+  // In the event where default or no index is provided (-1),
+  // query the actual index for the response
+  if (data.index === -1)
+    data.index = bmsrv.getItemIndex(data.id);
+
+  try {
+    data.updated = bmsrv.getItemLastModified(data.id);
+  }
+  catch (e) {
+    console.exception(e);
+  }
+
+  return tag(data, true).then(() => data);
+}
+exports.createBookmarkItem = createBookmarkItem;
+
+function saveBookmarkItem (data) {
+  let id = data.id;
+  if (!id)
+    reject('Item is missing id');
+
+  let group = bmsrv.getFolderIdForItem(id);
+  let index = bmsrv.getItemIndex(id);
+  let type = bmsrv.getItemType(id);
+  let title = typeMap(type) !== 'separator' ?
+    bmsrv.getItemTitle(id) :
+    undefined;
+  let url = typeMap(type) === 'bookmark' ?
+    bmsrv.getBookmarkURI(id).spec :
+    undefined;
+
+  if (url != data.url)
+    bmsrv.changeBookmarkURI(id, newURI(data.url));
+  else if (typeMap(type) === 'bookmark')
+    data.url = url;
+
+  if (title != data.title)
+    bmsrv.setItemTitle(id, data.title);
+  else if (typeMap(type) !== 'separator')
+    data.title = title;
+
+  if (data.group && data.group !== group)
+    bmsrv.moveItem(id, data.group, data.index || -1);
+  else if (data.index != null && data.index !== index) {
+    // We use moveItem here instead of setItemIndex
+    // so we don't have to manage the indicies of the siblings
+    bmsrv.moveItem(id, group, data.index);
+  } else if (data.index == null)
+    data.index = index;
+
+  data.updated = bmsrv.getItemLastModified(data.id);
+
+  return tag(data).then(() => data);
+}
+exports.saveBookmarkItem = saveBookmarkItem;
+
+function removeBookmarkItem (data) {
+  let id = data.id;
+
+  if (!id)
+    reject('Item is missing id');
+
+  bmsrv.removeItem(id);
+  return resolve(null);
+}
+exports.removeBookmarkItem = removeBookmarkItem;
+
+function getBookmarkItem (data) {
+  let id = data.id;
+
+  if (!id)
+    reject('Item is missing id');
+
+  let type = bmsrv.getItemType(id);
+
+  data.type = typeMap(type);
+
+  if (type === bmsrv.TYPE_BOOKMARK || type === bmsrv.TYPE_FOLDER)
+    data.title = bmsrv.getItemTitle(id);
+
+  if (type === bmsrv.TYPE_BOOKMARK) {
+    data.url = bmsrv.getBookmarkURI(id).spec;
+    // Should be moved into host-tags as a method
+    data.tags = taggingService.getTagsForURI(newURI(data.url), {});
+  }
+
+  data.group = bmsrv.getFolderIdForItem(id);
+  data.index = bmsrv.getItemIndex(id);
+  data.updated = bmsrv.getItemLastModified(data.id);
+
+  return resolve(data);
+}
+exports.getBookmarkItem = getBookmarkItem;
+
+function getAllBookmarks () {
+  return query({}, { queryType: 1 }).then(bookmarks =>
+    all(bookmarks.map(getBookmarkItem)));
+}
+exports.getAllBookmarks = getAllBookmarks;
+
+function getChildren ({ id }) {
+  if (typeMap(bmsrv.getItemType(id)) !== 'group') return [];
+  let ids = [];
+  for (let i = 0; ids[ids.length - 1] !== -1; i++)
+    ids.push(bmsrv.getIdForItemAt(id, i));
+  ids.pop();
+  return all(ids.map(id => getBookmarkItem({ id: id })));
+}
+exports.getChildren = getChildren;
+
+/*
+ * Hook into host
+ */
+
+var reqStream = filter(request, (data) => /sdk-places-bookmarks/.test(data.event));
+on(reqStream, 'data', ({ event, id, data }) => {
+  if (!EVENT_MAP[event]) return;
+
+  let resData = { id: id, event: event };
+
+  promised(EVENT_MAP[event])(data).
+  then(res => resData.data = res, e => resData.error = e).
+  then(() => emit(response, 'data', resData));
+});
+
+function tag (data, isNew) {
+  // If a new item, we can skip checking what other tags
+  // are on the item
+  if (data.type !== 'bookmark') {
+    return resolve();
+  }
+  else if (!isNew) {
+    return send('sdk-places-tags-get-tags-by-url', { url: data.url })
+      .then(tags => {
+        return send('sdk-places-tags-untag', {
+          tags: tags.filter(tag => !~data.tags.indexOf(tag)),
+          url: data.url
+        });
+      }).then(() => send('sdk-places-tags-tag', {
+        url: data.url, tags: data.tags
+      }));
+  }
+  else if (data.tags && data.tags.length) {
+    return send('sdk-places-tags-tag', { url: data.url, tags: data.tags });
+  }
+  else
+    return resolve();
+}
+
diff --git a/toolkit/jetpack/sdk/places/host/host-query.js b/toolkit/jetpack/sdk/places/host/host-query.js
new file mode 100644
index 000000000..f2dbd6550
--- /dev/null
+++ b/toolkit/jetpack/sdk/places/host/host-query.js
@@ -0,0 +1,179 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+const { Cc, Ci } = require('chrome');
+const { all } = require('../../core/promise');
+const { safeMerge, omit } = require('../../util/object');
+const historyService = Cc['@mozilla.org/browser/nav-history-service;1']
+                     .getService(Ci.nsINavHistoryService);
+const bookmarksService = Cc['@mozilla.org/browser/nav-bookmarks-service;1']
+                         .getService(Ci.nsINavBookmarksService);
+const { request, response } = require('../../addon/host');
+const { newURI } = require('../../url/utils');
+const { send } = require('../../addon/events');
+const { on, emit } = require('../../event/core');
+const { filter } = require('../../event/utils');
+
+const ROOT_FOLDERS = [
+  bookmarksService.unfiledBookmarksFolder, bookmarksService.toolbarFolder,
+  bookmarksService.bookmarksMenuFolder
+];
+
+const EVENT_MAP = {
+  'sdk-places-query': queryReceiver
+};
+
+// Properties that need to be manually
+// copied into a nsINavHistoryQuery object
+const MANUAL_QUERY_PROPERTIES = [
+  'uri', 'folder', 'tags', 'url', 'folder'
+];
+
+const PLACES_PROPERTIES = [
+  'uri', 'title', 'accessCount', 'time'
+];
+
+function execute (queries, options) {
+  return new Promise(resolve => {
+    let root = historyService
+        .executeQueries(queries, queries.length, options).root;
+    // Let's extract an eventual uri wildcard, if both domain and uri are set.
+    // See utils.js::urlQueryParser() for more details.
+    // In case of multiple queries, we only retain the first found wildcard.
+    let uriWildcard = queries.reduce((prev, query) => {
+      if (query.uri && query.domain) {
+        if (!prev)
+          prev = query.uri.spec;
+        query.uri = null;
+      }
+      return prev;
+    }, "");
+    resolve(collect([], root, uriWildcard));
+  });
+}
+
+function collect (acc, node, uriWildcard) {
+  node.containerOpen = true;
+  for (let i = 0; i < node.childCount; i++) {
+    let child = node.getChild(i);
+
+    if (!uriWildcard || child.uri.startsWith(uriWildcard)) {
+      acc.push(child);
+    }
+    if (child.type === child.RESULT_TYPE_FOLDER) {
+      let container = child.QueryInterface(Ci.nsINavHistoryContainerResultNode);
+      collect(acc, container, uriWildcard);
+    }
+  }
+  node.containerOpen = false;
+  return acc;
+}
+
+function query (queries, options) {
+  return new Promise((resolve, reject) => {
+    queries = queries || [];
+    options = options || {};
+    let optionsObj, queryObjs;
+
+    optionsObj = historyService.getNewQueryOptions();
+    queryObjs = [].concat(queries).map(createQuery);
+    if (!queryObjs.length) {
+      queryObjs = [historyService.getNewQuery()];
+    }
+    safeMerge(optionsObj, options);
+
+    /*
+     * Currently `places:` queries are not supported
+     */
+    optionsObj.excludeQueries = true;
+
+    execute(queryObjs, optionsObj).then((results) => {
+      if (optionsObj.queryType === 0) {
+        return results.map(normalize);
+      }
+      else if (optionsObj.queryType === 1) {
+        // Formats query results into more standard
+        // data structures for returning
+        return all(results.map(({itemId}) =>
+          send('sdk-places-bookmarks-get', { id: itemId })));
+      }
+    }).then(resolve, reject);
+  });
+}
+exports.query = query;
+
+function createQuery (query) {
+  query = query || {};
+  let queryObj = historyService.getNewQuery();
+
+  safeMerge(queryObj, omit(query, MANUAL_QUERY_PROPERTIES));
+
+  if (query.tags && Array.isArray(query.tags))
+    queryObj.tags = query.tags;
+  if (query.uri || query.url)
+    queryObj.uri = newURI(query.uri || query.url);
+  if (query.folder)
+    queryObj.setFolders([query.folder], 1);
+  return queryObj;
+}
+
+function queryReceiver (message) {
+  let queries = message.data.queries || message.data.query;
+  let options = message.data.options;
+  let resData = {
+    id: message.id,
+    event: message.event
+  };
+
+  query(queries, options).then(results => {
+    resData.data = results;
+    respond(resData);
+  }, reason => {
+    resData.error = reason;
+    respond(resData);
+  });
+}
+
+/*
+ * Converts a nsINavHistoryResultNode into a plain object
+ *
+ * https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryResultNode
+ */
+function normalize (historyObj) {
+  return PLACES_PROPERTIES.reduce((obj, prop) => {
+    if (prop === 'uri')
+      obj.url = historyObj.uri;
+    else if (prop === 'time') {
+      // Cast from microseconds to milliseconds
+      obj.time = Math.floor(historyObj.time / 1000)
+    }
+    else if (prop === 'accessCount')
+      obj.visitCount = historyObj[prop];
+    else
+      obj[prop] = historyObj[prop];
+    return obj;
+  }, {});
+}
+
+/*
+ * Hook into host
+ */
+
+var reqStream = filter(request, data => /sdk-places-query/.test(data.event));
+on(reqStream, 'data', function (e) {
+  if (EVENT_MAP[e.event]) EVENT_MAP[e.event](e);
+});
+
+function respond (data) {
+  emit(response, 'data', data);
+}
diff --git a/toolkit/jetpack/sdk/places/host/host-tags.js b/toolkit/jetpack/sdk/places/host/host-tags.js
new file mode 100644
index 000000000..929a5d5af
--- /dev/null
+++ b/toolkit/jetpack/sdk/places/host/host-tags.js
@@ -0,0 +1,92 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+const { Cc, Ci } = require('chrome');
+const taggingService = Cc["@mozilla.org/browser/tagging-service;1"].
+                       getService(Ci.nsITaggingService);
+const ios = Cc['@mozilla.org/network/io-service;1'].
+            getService(Ci.nsIIOService);
+const { URL } = require('../../url');
+const { newURI } = require('../../url/utils');
+const { request, response } = require('../../addon/host');
+const { on, emit } = require('../../event/core');
+const { filter } = require('../../event/utils');
+
+const EVENT_MAP = {
+  'sdk-places-tags-tag': tag,
+  'sdk-places-tags-untag': untag,
+  'sdk-places-tags-get-tags-by-url': getTagsByURL,
+  'sdk-places-tags-get-urls-by-tag': getURLsByTag
+};
+
+function tag (message) {
+  let data = message.data;
+  let resData = {
+    id: message.id,
+    event: message.event
+  };
+
+  resData.data = taggingService.tagURI(newURI(data.url), data.tags);
+  respond(resData);
+}
+
+function untag (message) {
+  let data = message.data;
+  let resData = {
+    id: message.id,
+    event: message.event
+  };
+
+  resData.data = taggingService.untagURI(newURI(data.url), data.tags);
+  respond(resData);
+}
+
+function getURLsByTag (message) {
+  let data = message.data;
+  let resData = {
+    id: message.id,
+    event: message.event
+  };
+
+  resData.data = taggingService
+    .getURIsForTag(data.tag).map(uri => uri.spec);
+  respond(resData);
+}
+
+function getTagsByURL (message) {
+  let data = message.data;
+  let resData = {
+    id: message.id,
+    event: message.event
+  };
+
+  resData.data = taggingService.getTagsForURI(newURI(data.url), {});
+  respond(resData);
+}
+
+/*
+ * Hook into host
+ */
+
+var reqStream = filter(request, function (data) {
+  return /sdk-places-tags/.test(data.event);
+});
+
+on(reqStream, 'data', function (e) {
+  if (EVENT_MAP[e.event]) EVENT_MAP[e.event](e);
+});
+
+function respond (data) {
+  emit(response, 'data', data);
+}
diff --git a/toolkit/jetpack/sdk/places/utils.js b/toolkit/jetpack/sdk/places/utils.js
new file mode 100644
index 000000000..44366d2aa
--- /dev/null
+++ b/toolkit/jetpack/sdk/places/utils.js
@@ -0,0 +1,268 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+const { Cc, Ci, Cu } = require('chrome');
+const { Class } = require('../core/heritage');
+const { method } = require('../lang/functional');
+const { defer, promised, all } = require('../core/promise');
+const { send } = require('../addon/events');
+const { EventTarget } = require('../event/target');
+const { merge } = require('../util/object');
+const bmsrv = Cc["@mozilla.org/browser/nav-bookmarks-service;1"].
+                getService(Ci.nsINavBookmarksService);
+
+Cu.importGlobalProperties(["URL"]);
+
+/*
+ * TreeNodes are used to construct dependency trees
+ * for BookmarkItems
+ */
+var TreeNode = Class({
+  initialize: function (value) {
+    this.value = value;
+    this.children = [];
+  },
+  add: function (values) {
+    [].concat(values).forEach(value => {
+      this.children.push(value instanceof TreeNode ? value : TreeNode(value));
+    });
+  },
+  get length () {
+    let count = 0;
+    this.walk(() => count++);
+    // Do not count the current node
+    return --count;
+  },
+  get: method(get),
+  walk: method(walk),
+  toString: () => '[object TreeNode]'
+});
+exports.TreeNode = TreeNode;
+
+/*
+ * Descends down from `node` applying `fn` to each in order.
+ * `fn` can return values or promises -- if promise returned,
+ * children are not processed until resolved. `fn` is passed
+ * one argument, the current node, `curr`.
+ */
+function walk (curr, fn) {
+  return promised(fn)(curr).then(val => {
+    return all(curr.children.map(child => walk(child, fn)));
+  });
+}
+
+/*
+ * Descends from the TreeNode `node`, returning
+ * the node with value `value` if found or `null`
+ * otherwise
+ */
+function get (node, value) {
+  if (node.value === value) return node;
+  for (let child of node.children) {
+    let found = get(child, value);
+    if (found) return found;
+  }
+  return null;
+}
+
+/*
+ * Constructs a tree of bookmark nodes
+ * returning the root (value: null);
+ */
+
+function constructTree (items) {
+  let root = TreeNode(null);
+  items.forEach(treeify.bind(null, root));
+
+  function treeify (root, item) {
+    // If node already exists, skip
+    let node = root.get(item);
+    if (node) return node;
+    node = TreeNode(item);
+
+    let parentNode = item.group ? treeify(root, item.group) : root;
+    parentNode.add(node);
+
+    return node;
+  }
+
+  return root;
+}
+exports.constructTree = constructTree;
+
+/*
+ * Shortcut for converting an id, or an object with an id, into
+ * an object with corresponding bookmark data
+ */
+function fetchItem (item) {
+  return send('sdk-places-bookmarks-get', { id: item.id || item });
+}
+exports.fetchItem = fetchItem;
+
+/*
+ * Takes an ID or an object with ID and checks it against
+ * the root bookmark folders
+ */
+function isRootGroup (id) {
+  id = id && id.id;
+  return ~[bmsrv.bookmarksMenuFolder, bmsrv.toolbarFolder,
+    bmsrv.unfiledBookmarksFolder
+  ].indexOf(id);
+}
+exports.isRootGroup = isRootGroup;
+
+/*
+ * Merges appropriate options into query based off of url
+ * 4 scenarios:
+ *
+ * 'moz.com' // domain: moz.com, domainIsHost: true
+ *    --> 'http://moz.com', 'http://moz.com/thunderbird'
+ * '*.moz.com' // domain: moz.com, domainIsHost: false
+ *    --> 'http://moz.com', 'http://moz.com/index', 'http://ff.moz.com/test'
+ * 'http://moz.com' // uri: http://moz.com/
+ *    --> 'http://moz.com/'
+ * 'http://moz.com/*' // uri: http://moz.com/, domain: moz.com, domainIsHost: true
+ *    --> 'http://moz.com/', 'http://moz.com/thunderbird'
+ */
+
+function urlQueryParser (query, url) {
+  if (!url) return;
+  if (/^https?:\/\//.test(url)) {
+    query.uri = url.charAt(url.length - 1) === '/' ? url : url + '/';
+    if (/\*$/.test(url)) {
+      // Wildcard searches on URIs are not supported, so try to extract a
+      // domain and filter the data later.
+      url = url.replace(/\*$/, '');
+      try {
+        query.domain = new URL(url).hostname;
+        query.domainIsHost = true;
+        // Unfortunately here we cannot use an expando to store the wildcard,
+        // cause the query is a wrapped native XPCOM object, so we reuse uri.
+        // We clearly don't want to query for both uri and domain, thus we'll
+        // have to handle this in host-query.js::execute()
+        query.uri = url;
+      } catch (ex) {
+        // Cannot extract an host cause it's not a valid uri, the query will
+        // just return nothing.
+      }
+    }
+  } else {
+    if (/^\*/.test(url)) {
+      query.domain = url.replace(/^\*\./, '');
+      query.domainIsHost = false;
+    } else {
+      query.domain = url;
+      query.domainIsHost = true;
+    }
+  }
+}
+exports.urlQueryParser = urlQueryParser;
+
+/*
+ * Takes an EventEmitter and returns a promise that
+ * aggregates results and handles a bulk resolve and reject
+ */
+
+function promisedEmitter (emitter) {
+  let { promise, resolve, reject } = defer();
+  let errors = [];
+  emitter.on('error', error => errors.push(error));
+  emitter.on('end', (items) => {
+    if (errors.length) reject(errors[0]);
+    else resolve(items);
+  });
+  return promise;
+}
+exports.promisedEmitter = promisedEmitter;
+
+
+// https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryQueryOptions
+function createQuery (type, query) {
+  query = query || {};
+  let qObj = {
+    searchTerms: query.query
+  };
+
+  urlQueryParser(qObj, query.url);
+
+  // 0 === history
+  if (type === 0) {
+    // PRTime used by query is in microseconds, not milliseconds
+    qObj.beginTime = (query.from || 0) * 1000;
+    qObj.endTime = (query.to || new Date()) * 1000;
+
+    // Set reference time to Epoch
+    qObj.beginTimeReference = 0;
+    qObj.endTimeReference = 0;
+  }
+  // 1 === bookmarks
+  else if (type === 1) {
+    qObj.tags = query.tags;
+    qObj.folder = query.group && query.group.id;
+  }
+  // 2 === unified (not implemented on platform)
+  else if (type === 2) {
+
+  }
+
+  return qObj;
+}
+exports.createQuery = createQuery;
+
+// https://developer.mozilla.org/en-US/docs/XPCOM_Interface_Reference/nsINavHistoryQueryOptions
+
+const SORT_MAP = {
+  title: 1,
+  date: 3, // sort by visit date
+  url: 5,
+  visitCount: 7,
+  // keywords currently unsupported
+  // keyword: 9,
+  dateAdded: 11, // bookmarks only
+  lastModified: 13 // bookmarks only
+};
+
+function createQueryOptions (type, options) {
+  options = options || {};
+  let oObj = {};
+  oObj.sortingMode = SORT_MAP[options.sort] || 0;
+  if (options.descending && options.sort)
+    oObj.sortingMode++;
+
+  // Resolve to default sort if ineligible based on query type
+  if (type === 0 && // history
+      (options.sort === 'dateAdded' || options.sort === 'lastModified'))
+    oObj.sortingMode = 0;
+
+  oObj.maxResults = typeof options.count === 'number' ? options.count : 0;
+
+  oObj.queryType = type;
+
+  return oObj;
+}
+exports.createQueryOptions = createQueryOptions;
+
+
+function mapBookmarkItemType (type) {
+  if (typeof type === 'number') {
+    if (bmsrv.TYPE_BOOKMARK === type) return 'bookmark';
+    if (bmsrv.TYPE_FOLDER === type) return 'group';
+    if (bmsrv.TYPE_SEPARATOR === type) return 'separator';
+  } else {
+    if ('bookmark' === type) return bmsrv.TYPE_BOOKMARK;
+    if ('group' === type) return bmsrv.TYPE_FOLDER;
+    if ('separator' === type) return bmsrv.TYPE_SEPARATOR;
+  }
+}
+exports.mapBookmarkItemType = mapBookmarkItemType;
diff --git a/toolkit/jetpack/sdk/platform/xpcom.js b/toolkit/jetpack/sdk/platform/xpcom.js
new file mode 100644
index 000000000..383baf67a
--- /dev/null
+++ b/toolkit/jetpack/sdk/platform/xpcom.js
@@ -0,0 +1,241 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci, Cr, Cm, components: { classesByID } } = require('chrome');
+const { registerFactory, unregisterFactory, isCIDRegistered } =
+      Cm.QueryInterface(Ci.nsIComponentRegistrar);
+
+const { merge } = require('../util/object');
+const { Class, extend, mix } = require('../core/heritage');
+const { uuid } = require('../util/uuid');
+
+// This is a base prototype, that provides bare bones of XPCOM. JS based
+// components can be easily implement by extending it.
+const Unknown = new function() {
+  function hasInterface(component, iid) {
+    return component && component.interfaces &&
+      ( component.interfaces.some(id => iid.equals(Ci[id])) ||
+        component.implements.some($ => hasInterface($, iid)) ||
+        hasInterface(Object.getPrototypeOf(component), iid));
+  }
+
+  return Class({
+    /**
+     * The `QueryInterface` method provides runtime type discovery used by XPCOM.
+     * This method return queried instance of `this` if given `iid` is listed in
+     * the `interfaces` property or in equivalent properties of objects in it's
+     * prototype chain. In addition it will look up in the prototypes under
+     * `implements` array property, this ways compositions made via `Class`
+     * utility will carry interfaces implemented by composition components.
+     */
+    QueryInterface: function QueryInterface(iid) {
+      // For some reason there are cases when `iid` is `null`. In such cases we
+      // just return `this`. Otherwise we verify that component implements given
+      // `iid` interface. This will be no longer necessary once Bug 748003 is
+      // fixed.
+      if (iid && !hasInterface(this, iid))
+        throw Cr.NS_ERROR_NO_INTERFACE;
+
+      return this;
+    },
+    /**
+     * Array of `XPCOM` interfaces (as strings) implemented by this component.
+     * All components implement `nsISupports` by default which is default value
+     * here. Provide array of interfaces implemented by an object when
+     * extending, to append them to this list (Please note that there is no
+     * need to repeat interfaces implemented by super as they will be added
+     * automatically).
+     */
+    interfaces: Object.freeze([ 'nsISupports' ])
+  });
+}
+exports.Unknown = Unknown;
+
+// Base exemplar for creating instances implementing `nsIFactory` interface,
+// that maybe registered into runtime via `register` function. Instances of
+// this factory create instances of enclosed component on `createInstance`.
+const Factory = Class({
+  extends: Unknown,
+  interfaces: [ 'nsIFactory' ],
+  /**
+   * All the descendants will get auto generated `id` (also known as `classID`
+   * in XPCOM world) unless one is manually provided.
+   */
+  get id() { throw Error('Factory must implement `id` property') },
+  /**
+   * XPCOM `contractID` may optionally  be provided to associate this factory
+   * with it. `contract` is a unique string that has a following format:
+   * '@vendor.com/unique/id;1'.
+   */
+  contract: null,
+  /**
+   * Class description that is being registered. This value is intended as a
+   * human-readable description for the given class and does not needs to be
+   * globally unique.
+   */
+  description: 'Jetpack generated factory',
+  /**
+   * This method is required by `nsIFactory` interfaces, but as in most
+   * implementations it does nothing interesting.
+   */
+  lockFactory: function lockFactory(lock) {
+    return undefined;
+  },
+  /**
+   * If property is `true` XPCOM service / factory will be registered
+   * automatically on creation.
+   */
+  register: true,
+  /**
+   * If property is `true` XPCOM factory will be unregistered prior to add-on
+   * unload.
+   */
+  unregister: true,
+  /**
+   * Method is called on `Service.new(options)` passing given `options` to
+   * it. Options is expected to have `component` property holding XPCOM
+   * component implementation typically decedent of `Unknown` or any custom
+   * implementation with a `new` method and optional `register`, `unregister`
+   * flags. Unless `register` is `false` Service / Factory will be
+   * automatically registered. Unless `unregister` is `false` component will
+   * be automatically unregistered on add-on unload.
+   */
+  initialize: function initialize(options) {
+    merge(this, {
+      id: 'id' in options ? options.id : uuid(),
+      register: 'register' in options ? options.register : this.register,
+      unregister: 'unregister' in options ? options.unregister : this.unregister,
+      contract: 'contract' in options ? options.contract : null,
+      Component: options.Component
+    });
+
+    // If service / factory has auto registration enabled then register.
+    if (this.register)
+      register(this);
+  },
+  /**
+   * Creates an instance of the class associated with this factory.
+   */
+  createInstance: function createInstance(outer, iid) {
+    try {
+      if (outer)
+        throw Cr.NS_ERROR_NO_AGGREGATION;
+      return this.create().QueryInterface(iid);
+    }
+    catch (error) {
+      throw error instanceof Ci.nsIException ? error : Cr.NS_ERROR_FAILURE;
+    }
+  },
+  create: function create() {
+    return this.Component();
+  }
+});
+exports.Factory = Factory;
+
+// Exemplar for creating services that implement `nsIFactory` interface, that
+// can be registered into runtime via call to `register`. This services return
+// enclosed `component` on `getService`.
+const Service = Class({
+  extends: Factory,
+  initialize: function initialize(options) {
+    this.component = options.Component();
+    Factory.prototype.initialize.call(this, options);
+  },
+  description: 'Jetpack generated service',
+  /**
+   * Creates an instance of the class associated with this factory.
+   */
+  create: function create() {
+    return this.component;
+  }
+});
+exports.Service = Service;
+
+function isRegistered({ id }) {
+  return isCIDRegistered(id);
+}
+exports.isRegistered = isRegistered;
+
+/**
+ * Registers given `component` object to be used to instantiate a particular
+ * class identified by `component.id`, and creates an association of class
+ * name and `component.contract` with the class.
+ */
+function register(factory) {
+  if (!(factory instanceof Factory)) {
+    throw new Error("xpcom.register() expect a Factory instance.\n" +
+                    "Please refactor your code to new xpcom module if you" +
+                    " are repacking an addon from SDK <= 1.5:\n" +
+                    "https://developer.mozilla.org/en-US/Add-ons/SDK/Low-Level_APIs/platform_xpcom");
+  }
+
+  registerFactory(factory.id, factory.description, factory.contract, factory);
+
+  if (factory.unregister)
+    require('../system/unload').when(unregister.bind(null, factory));
+}
+exports.register = register;
+
+/**
+ * Unregister a factory associated with a particular class identified by
+ * `factory.classID`.
+ */
+function unregister(factory) {
+  if (isRegistered(factory))
+    unregisterFactory(factory.id, factory);
+}
+exports.unregister = unregister;
+
+function autoRegister(path) {
+  // TODO: This assumes that the url points to a directory
+  // that contains subdirectories corresponding to OS/ABI and then
+  // further subdirectories corresponding to Gecko platform version.
+  // we should probably either behave intelligently here or allow
+  // the caller to pass-in more options if e.g. there aren't
+  // Gecko-specific binaries for a component (which will be the case
+  // if only frozen interfaces are used).
+
+  var runtime = require("../system/runtime");
+  var osDirName = runtime.OS + "_" + runtime.XPCOMABI;
+  var platformVersion = require("../system/xul-app").platformVersion.substring(0, 5);
+
+  var file = Cc['@mozilla.org/file/local;1']
+             .createInstance(Ci.nsILocalFile);
+  file.initWithPath(path);
+  file.append(osDirName);
+  file.append(platformVersion);
+
+  if (!(file.exists() && file.isDirectory()))
+    throw new Error("component not available for OS/ABI " +
+                    osDirName + " and platform " + platformVersion);
+
+  Cm.QueryInterface(Ci.nsIComponentRegistrar);
+  Cm.autoRegister(file);
+}
+exports.autoRegister = autoRegister;
+
+/**
+ * Returns registered factory that has a given `id` or `null` if not found.
+ */
+function factoryByID(id) {
+  return classesByID[id] || null;
+}
+exports.factoryByID = factoryByID;
+
+/**
+ * Returns factory registered with a given `contract` or `null` if not found.
+ * In contrast to `Cc[contract]` that does ignores new factory registration
+ * with a given `contract` this will return a factory currently associated
+ * with a `contract`.
+ */
+function factoryByContract(contract) {
+  return factoryByID(Cm.contractIDToCID(contract));
+}
+exports.factoryByContract = factoryByContract;
diff --git a/toolkit/jetpack/sdk/preferences/event-target.js b/toolkit/jetpack/sdk/preferences/event-target.js
new file mode 100644
index 000000000..b64ba303c
--- /dev/null
+++ b/toolkit/jetpack/sdk/preferences/event-target.js
@@ -0,0 +1,61 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci } = require('chrome');
+const { Class } = require('../core/heritage');
+const { EventTarget } = require('../event/target');
+const { Branch } = require('./service');
+const { emit, off } = require('../event/core');
+const { when: unload } = require('../system/unload');
+
+const prefTargetNS = require('../core/namespace').ns();
+
+const PrefsTarget = Class({
+  extends: EventTarget,
+  initialize: function(options) {
+    options = options || {};
+    EventTarget.prototype.initialize.call(this, options);
+
+    let branchName = options.branchName || '';
+    let branch = Cc["@mozilla.org/preferences-service;1"].
+        getService(Ci.nsIPrefService).
+        getBranch(branchName).
+        QueryInterface(Ci.nsIPrefBranch2);
+    prefTargetNS(this).branch = branch;
+
+    // provides easy access to preference values
+    this.prefs = Branch(branchName);
+
+    // start listening to preference changes
+    let observer = prefTargetNS(this).observer = onChange.bind(this);
+    branch.addObserver('', observer, false);
+
+    // Make sure to destroy this on unload
+    unload(destroy.bind(this));
+  }
+});
+exports.PrefsTarget = PrefsTarget;
+
+/* HELPERS */
+
+function onChange(subject, topic, name) {
+  if (topic === 'nsPref:changed') {
+    emit(this, name, name);
+    emit(this, '', name);
+  }
+}
+
+function destroy() {
+  off(this);
+
+  // stop listening to preference changes
+  let branch = prefTargetNS(this).branch;
+  branch.removeObserver('', prefTargetNS(this).observer, false);
+  prefTargetNS(this).observer = null;
+}
diff --git a/toolkit/jetpack/sdk/preferences/native-options.js b/toolkit/jetpack/sdk/preferences/native-options.js
new file mode 100644
index 000000000..840997df9
--- /dev/null
+++ b/toolkit/jetpack/sdk/preferences/native-options.js
@@ -0,0 +1,193 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci, Cu } = require('chrome');
+const { on } = require('../system/events');
+const { id, preferencesBranch } = require('../self');
+const { localizeInlineOptions } = require('../l10n/prefs');
+const { Services } = require("resource://gre/modules/Services.jsm");
+const { AddonManager } = Cu.import("resource://gre/modules/AddonManager.jsm");
+const { defer } = require("sdk/core/promise");
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";;
+const DEFAULT_OPTIONS_URL = 'data:text/xml,<placeholder/>';
+
+const VALID_PREF_TYPES = ['bool', 'boolint', 'integer', 'string', 'color',
+                          'file', 'directory', 'control', 'menulist', 'radio'];
+
+const isFennec = require("sdk/system/xul-app").is("Fennec");
+
+function enable({ preferences, id }) {
+  let enabled = defer();
+
+  validate(preferences);
+
+  setDefaults(preferences, preferencesBranch);
+
+  // allow the use of custom options.xul
+  AddonManager.getAddonByID(id, (addon) => {
+    on('addon-options-displayed', onAddonOptionsDisplayed, true);
+    enabled.resolve({ id: id });
+  });
+
+  function onAddonOptionsDisplayed({ subject: doc, data }) {
+    if (data === id) {
+      let parent;
+
+      if (isFennec) {
+        parent = doc.querySelector('.options-box');
+
+        // NOTE: This disable the CSS rule that makes the options invisible
+        let item = doc.querySelector('#addons-details .addon-item');
+        item.removeAttribute("optionsURL");
+      } else {
+        parent = doc.getElementById('detail-downloads').parentNode;
+      }
+
+      if (parent) {
+        injectOptions({
+          preferences: preferences,
+          preferencesBranch: preferencesBranch,
+          document: doc,
+          parent: parent,
+          id: id
+        });
+        localizeInlineOptions(doc);
+      } else {
+        throw Error("Preferences parent node not found in Addon Details. The configured custom preferences will not be visible.");
+      }
+    }
+  }
+
+  return enabled.promise;
+}
+exports.enable = enable;
+
+// centralized sanity checks
+function validate(preferences) {
+  for (let { name, title, type, label, options } of preferences) {
+    // make sure the title is set and non-empty
+    if (!title)
+      throw Error("The '" + name + "' pref requires a title");
+
+    // make sure that pref type is a valid inline option type
+    if (!~VALID_PREF_TYPES.indexOf(type))
+      throw Error("The '" + name + "' pref must be of valid type");
+
+    // if it's a control, make sure it has a label
+    if (type === 'control' && !label)
+      throw Error("The '" + name + "' control requires a label");
+
+    // if it's a menulist or radio, make sure it has options
+    if (type === 'menulist' || type === 'radio') {
+      if (!options)
+        throw Error("The '" + name + "' pref requires options");
+
+      // make sure each option has a value and a label
+      for (let item of options) {
+        if (!('value' in item) || !('label' in item))
+          throw Error("Each option requires both a value and a label");
+      }
+    }
+
+    // TODO: check that pref type matches default value type
+  }
+}
+exports.validate = validate;
+
+// initializes default preferences, emulates defaults/prefs.js
+function setDefaults(preferences, preferencesBranch) {
+  const branch = Cc['@mozilla.org/preferences-service;1'].
+                 getService(Ci.nsIPrefService).
+                 getDefaultBranch('extensions.' + preferencesBranch + '.');
+  for (let { name, value } of preferences) {
+    switch (typeof value) {
+      case 'boolean':
+        branch.setBoolPref(name, value);
+        break;
+      case 'number':
+        // must be integer, ignore otherwise
+        if (value % 1 === 0) {
+          branch.setIntPref(name, value);
+        }
+        break;
+      case 'string':
+        let str = Cc["@mozilla.org/supports-string;1"].
+                  createInstance(Ci.nsISupportsString);
+        str.data = value;
+        branch.setComplexValue(name, Ci.nsISupportsString, str);
+        break;
+    }
+  }
+}
+exports.setDefaults = setDefaults;
+
+// dynamically injects inline options into about:addons page at runtime
+// NOTE: on Firefox Desktop the about:addons page is a xul page document,
+// on Firefox for Android the about:addons page is an xhtml page, to support both
+// the XUL xml namespace have to be enforced.
+function injectOptions({ preferences, preferencesBranch, document, parent, id }) {
+  preferences.forEach(({name, type, hidden, title, description, label, options, on, off}) => {
+    if (hidden) {
+      return;
+    }
+
+    let setting = document.createElementNS(XUL_NS, 'setting');
+    setting.setAttribute('pref-name', name);
+    setting.setAttribute('data-jetpack-id', id);
+    setting.setAttribute('pref', 'extensions.' + preferencesBranch + '.' + name);
+    setting.setAttribute('type', type);
+    setting.setAttribute('title', title);
+    if (description)
+      setting.setAttribute('desc', description);
+
+    if (type === 'file' || type === 'directory') {
+      setting.setAttribute('fullpath', 'true');
+    }
+    else if (type === 'control') {
+      let button = document.createElementNS(XUL_NS, 'button');
+      button.setAttribute('pref-name', name);
+      button.setAttribute('data-jetpack-id', id);
+      button.setAttribute('label', label);
+      button.addEventListener('command', function() {
+        Services.obs.notifyObservers(null, `${id}-cmdPressed`, name);
+      }, true);
+      setting.appendChild(button);
+    }
+    else if (type === 'boolint') {
+      setting.setAttribute('on', on);
+      setting.setAttribute('off', off);
+    }
+    else if (type === 'menulist') {
+      let menulist = document.createElementNS(XUL_NS, 'menulist');
+      let menupopup = document.createElementNS(XUL_NS, 'menupopup');
+      for (let { value, label } of options) {
+        let menuitem = document.createElementNS(XUL_NS, 'menuitem');
+        menuitem.setAttribute('value', value);
+        menuitem.setAttribute('label', label);
+        menupopup.appendChild(menuitem);
+      }
+      menulist.appendChild(menupopup);
+      setting.appendChild(menulist);
+    }
+    else if (type === 'radio') {
+      let radiogroup = document.createElementNS(XUL_NS, 'radiogroup');
+      for (let { value, label } of options) {
+        let radio = document.createElementNS(XUL_NS, 'radio');
+        radio.setAttribute('value', value);
+        radio.setAttribute('label', label);
+        radiogroup.appendChild(radio);
+      }
+      setting.appendChild(radiogroup);
+    }
+
+    parent.appendChild(setting);
+  });
+}
+exports.injectOptions = injectOptions;
diff --git a/toolkit/jetpack/sdk/preferences/service.js b/toolkit/jetpack/sdk/preferences/service.js
new file mode 100644
index 000000000..231cd8e14
--- /dev/null
+++ b/toolkit/jetpack/sdk/preferences/service.js
@@ -0,0 +1,137 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+// The minimum and maximum integers that can be set as preferences.
+// The range of valid values is narrower than the range of valid JS values
+// because the native preferences code treats integers as NSPR PRInt32s,
+// which are 32-bit signed integers on all platforms.
+const MAX_INT = 0x7FFFFFFF;
+const MIN_INT = -0x80000000;
+
+const {Cc,Ci,Cr} = require("chrome");
+
+const prefService = Cc["@mozilla.org/preferences-service;1"].
+                getService(Ci.nsIPrefService);
+const prefSvc = prefService.getBranch(null);
+const defaultBranch = prefService.getDefaultBranch(null);
+
+const { Preferences } = require("resource://gre/modules/Preferences.jsm");
+const prefs = new Preferences({});
+
+const branchKeys = branchName =>
+  keys(branchName).map($ => $.replace(branchName, ""));
+
+const Branch = function(branchName) {
+  return new Proxy(Branch.prototype, {
+    getOwnPropertyDescriptor(target, name, receiver) {
+      return {
+        configurable: true,
+        enumerable: true,
+        writable: false,
+        value: this.get(target, name, receiver)
+      };
+    },
+    ownKeys(target) {
+      return branchKeys(branchName);
+    },
+    get(target, name, receiver) {
+      return get(`${branchName}${name}`);
+    },
+    set(target, name, value, receiver) {
+      set(`${branchName}${name}`, value);
+      return true;
+    },
+    has(target, name) {
+      return this.hasOwn(target, name);
+    },
+    hasOwn(target, name) {
+      return has(`${branchName}${name}`);
+    },
+    deleteProperty(target, name) {
+      reset(`${branchName}${name}`);
+      return true;
+    }
+  });
+}
+
+
+function get(name, defaultValue) {
+  return prefs.get(name, defaultValue);
+}
+exports.get = get;
+
+
+function set(name, value) {
+  var prefType;
+  if (typeof value != "undefined" && value != null)
+    prefType = value.constructor.name;
+
+  switch (prefType) {
+  case "Number":
+    if (value % 1 != 0)
+      throw new Error("cannot store non-integer number: " + value);
+  }
+
+  prefs.set(name, value);
+}
+exports.set = set;
+
+const has = prefs.has.bind(prefs)
+exports.has = has;
+
+function keys(root) {
+  return prefSvc.getChildList(root);
+}
+exports.keys = keys;
+
+const isSet = prefs.isSet.bind(prefs);
+exports.isSet = isSet;
+
+function reset(name) {
+  try {
+    prefSvc.clearUserPref(name);
+  }
+  catch (e) {
+    // The pref service throws NS_ERROR_UNEXPECTED when the caller tries
+    // to reset a pref that doesn't exist or is already set to its default
+    // value.  This interface fails silently in those cases, so callers
+    // can unconditionally reset a pref without having to check if it needs
+    // resetting first or trap exceptions after the fact.  It passes through
+    // other exceptions, however, so callers know about them, since we don't
+    // know what other exceptions might be thrown and what they might mean.
+    if (e.result != Cr.NS_ERROR_UNEXPECTED) {
+      throw e;
+    }
+  }
+}
+exports.reset = reset;
+
+function getLocalized(name, defaultValue) {
+  let value = null;
+  try {
+    value = prefSvc.getComplexValue(name, Ci.nsIPrefLocalizedString).data;
+  }
+  finally {
+    return value || defaultValue;
+  }
+}
+exports.getLocalized = getLocalized;
+
+function setLocalized(name, value) {
+  // We can't use `prefs.set` here as we have to use `getDefaultBranch`
+  // (instead of `getBranch`) in order to have `mIsDefault` set to true, here:
+  // http://mxr.mozilla.org/mozilla-central/source/modules/libpref/src/nsPrefBranch.cpp#233
+  // Otherwise, we do not enter into this expected condition:
+  // http://mxr.mozilla.org/mozilla-central/source/modules/libpref/src/nsPrefBranch.cpp#244
+  defaultBranch.setCharPref(name, value);
+}
+exports.setLocalized = setLocalized;
+
+exports.Branch = Branch;
+
diff --git a/toolkit/jetpack/sdk/preferences/utils.js b/toolkit/jetpack/sdk/preferences/utils.js
new file mode 100644
index 000000000..1d5769c37
--- /dev/null
+++ b/toolkit/jetpack/sdk/preferences/utils.js
@@ -0,0 +1,42 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { openTab, getBrowserForTab, getTabId } = require("sdk/tabs/utils");
+const { on, off } = require("sdk/system/events");
+const { getMostRecentBrowserWindow } = require('../window/utils');
+
+// Opens about:addons in a new tab, then displays the inline
+// preferences of the provided add-on
+const open = ({ id }) => new Promise((resolve, reject) => {
+  // opening the about:addons page in a new tab
+  let tab = openTab(getMostRecentBrowserWindow(), "about:addons");
+  let browser = getBrowserForTab(tab);
+
+  // waiting for the about:addons page to load
+  browser.addEventListener("load", function onPageLoad() {
+    browser.removeEventListener("load", onPageLoad, true);
+    let window = browser.contentWindow;
+
+    // wait for the add-on's "addon-options-displayed"
+    on("addon-options-displayed", function onPrefDisplayed({ subject: doc, data }) {
+      if (data === id) {
+        off("addon-options-displayed", onPrefDisplayed);
+        resolve({
+          id: id,
+          tabId: getTabId(tab),
+          "document": doc
+        });
+      }
+    }, true);
+
+    // display the add-on inline preferences page
+    window.gViewController.commands.cmd_showItemDetails.doCommand({ id: id }, true);
+  }, true);
+});
+exports.open = open;
diff --git a/toolkit/jetpack/sdk/private-browsing.js b/toolkit/jetpack/sdk/private-browsing.js
new file mode 100644
index 000000000..29ca16185
--- /dev/null
+++ b/toolkit/jetpack/sdk/private-browsing.js
@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { isPrivate } = require('./private-browsing/utils');
+
+exports.isPrivate = isPrivate;
diff --git a/toolkit/jetpack/sdk/private-browsing/utils.js b/toolkit/jetpack/sdk/private-browsing/utils.js
new file mode 100644
index 000000000..8b012f0ce
--- /dev/null
+++ b/toolkit/jetpack/sdk/private-browsing/utils.js
@@ -0,0 +1,54 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci, Cu } = require('chrome');
+const { is } = require('../system/xul-app');
+const { isWindowPrivate } = require('../window/utils');
+const { isPrivateBrowsingSupported } = require('../self');
+const { dispatcher } = require("../util/dispatcher");
+
+var PrivateBrowsingUtils;
+
+// Private browsing is only supported in Fx
+try {
+  PrivateBrowsingUtils = Cu.import('resource://gre/modules/PrivateBrowsingUtils.jsm', {}).PrivateBrowsingUtils;
+}
+catch (e) {}
+
+exports.isGlobalPBSupported = false;
+
+// checks that per-window private browsing is implemented
+var isWindowPBSupported = exports.isWindowPBSupported =
+                          !!PrivateBrowsingUtils && is('Firefox');
+
+// checks that per-tab private browsing is implemented
+var isTabPBSupported = exports.isTabPBSupported =
+                       !!PrivateBrowsingUtils && is('Fennec');
+
+function isPermanentPrivateBrowsing() {
+ return !!(PrivateBrowsingUtils && PrivateBrowsingUtils.permanentPrivateBrowsing);
+}
+exports.isPermanentPrivateBrowsing = isPermanentPrivateBrowsing;
+
+function ignoreWindow(window) {
+  return !isPrivateBrowsingSupported && isWindowPrivate(window);
+}
+exports.ignoreWindow = ignoreWindow;
+
+var getMode = function getMode(chromeWin) {
+  return (chromeWin !== undefined && isWindowPrivate(chromeWin));
+};
+exports.getMode = getMode;
+
+const isPrivate = dispatcher("isPrivate");
+isPrivate.when(isPermanentPrivateBrowsing, _ => true);
+isPrivate.when(x => x instanceof Ci.nsIDOMWindow, isWindowPrivate);
+isPrivate.when(x => Ci.nsIPrivateBrowsingChannel && x instanceof Ci.nsIPrivateBrowsingChannel, x => x.isChannelPrivate);
+isPrivate.define(() => false);
+exports.isPrivate = isPrivate;
diff --git a/toolkit/jetpack/sdk/querystring.js b/toolkit/jetpack/sdk/querystring.js
new file mode 100644
index 000000000..9982a00ab
--- /dev/null
+++ b/toolkit/jetpack/sdk/querystring.js
@@ -0,0 +1,121 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+var unescape = decodeURIComponent;
+exports.unescape = unescape;
+
+// encodes a string safely for application/x-www-form-urlencoded
+// adheres to RFC 3986
+// see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/encodeURIComponent
+function escape(query) {
+  return encodeURIComponent(query).
+    replace(/%20/g, '+').
+    replace(/!/g, '%21').
+    replace(/'/g, '%27').
+    replace(/\(/g, '%28').
+    replace(/\)/g, '%29').
+    replace(/\*/g, '%2A');
+}
+exports.escape = escape;
+
+// Converts an object of unordered key-vals to a string that can be passed
+// as part of a request
+function stringify(options, separator, assigner) {
+  separator = separator || '&';
+  assigner = assigner || '=';
+  // Explicitly return null if we have null, and empty string, or empty object.
+  if (!options)
+    return '';
+
+  // If content is already a string, just return it as is.
+  if (typeof(options) == 'string')
+    return options;
+
+  // At this point we have a k:v object. Iterate over it and encode each value.
+  // Arrays and nested objects will get encoded as needed. For example...
+  //
+  //   { foo: [1, 2, { omg: 'bbq', 'all your base!': 'are belong to us' }], bar: 'baz' }
+  //
+  // will be encoded as
+  //
+  //   foo[0]=1&foo[1]=2&foo[2][omg]=bbq&foo[2][all+your+base!]=are+belong+to+us&bar=baz
+  //
+  // Keys (including '[' and ']') and values will be encoded with
+  // `escape` before returning.
+  //
+  // Execution was inspired by jQuery, but some details have changed and numeric
+  // array keys are included (whereas they are not in jQuery).
+
+  let encodedContent = [];
+  function add(key, val) {
+    encodedContent.push(escape(key) + assigner + escape(val));
+  }
+
+  function make(key, value) {
+    if (value && typeof(value) === 'object')
+      Object.keys(value).forEach(function(name) {
+        make(key + '[' + name + ']', value[name]);
+      });
+    else
+      add(key, value);
+  }
+
+  Object.keys(options).forEach(function(name) { make(name, options[name]); });
+  return encodedContent.join(separator);
+
+  //XXXzpao In theory, we can just use a FormData object on 1.9.3, but I had
+  //        trouble getting that working. It would also be nice to stay
+  //        backwards-compat as long as possible. Keeping this in for now...
+  // let formData = Cc['@mozilla.org/files/formdata;1'].
+  //                createInstance(Ci.nsIDOMFormData);
+  // for ([k, v] in Iterator(content)) {
+  //   formData.append(k, v);
+  // }
+  // return formData;
+}
+exports.stringify = stringify;
+
+// Exporting aliases that nodejs implements just for the sake of
+// interoperability.
+exports.encode = stringify;
+exports.serialize = stringify;
+
+// Note: That `stringify` and `parse` aren't bijective as we use `stringify`
+// as it was implement in request module, but implement `parse` to match nodejs
+// behavior.
+// TODO: Make `stringify` implement API as in nodejs and figure out backwards
+// compatibility.
+function parse(query, separator, assigner) {
+  separator = separator || '&';
+  assigner = assigner || '=';
+  let result = {};
+
+  if (typeof query !== 'string' || query.length === 0)
+    return result;
+
+  query.split(separator).forEach(function(chunk) {
+    let pair = chunk.split(assigner);
+    let key = unescape(pair[0]);
+    let value = unescape(pair.slice(1).join(assigner));
+
+    if (!(key in result))
+      result[key] = value;
+    else if (Array.isArray(result[key]))
+      result[key].push(value);
+    else
+      result[key] = [result[key], value];
+  });
+
+  return result;
+};
+exports.parse = parse;
+// Exporting aliases that nodejs implements just for the sake of
+// interoperability.
+exports.decode = parse;
diff --git a/toolkit/jetpack/sdk/remote/child.js b/toolkit/jetpack/sdk/remote/child.js
new file mode 100644
index 000000000..4ccfa661a
--- /dev/null
+++ b/toolkit/jetpack/sdk/remote/child.js
@@ -0,0 +1,284 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { isChildLoader } = require('./core');
+if (!isChildLoader)
+  throw new Error("Cannot load sdk/remote/child in a main process loader.");
+
+const { Ci, Cc, Cu } = require('chrome');
+const runtime = require('../system/runtime');
+const { Class } = require('../core/heritage');
+const { Namespace } = require('../core/namespace');
+const { omit } = require('../util/object');
+const { when } = require('../system/unload');
+const { EventTarget } = require('../event/target');
+const { emit } = require('../event/core');
+const { Disposable } = require('../core/disposable');
+const { EventParent } = require('./utils');
+const { addListItem, removeListItem } = require('../util/list');
+
+const loaderID = require('@loader/options').loaderID;
+
+const MAIN_PROCESS = Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
+
+const mm = Cc['@mozilla.org/childprocessmessagemanager;1'].
+           getService(Ci.nsISyncMessageSender);
+
+const ns = Namespace();
+
+const process = {
+  port: new EventTarget(),
+  get id() {
+    return runtime.processID;
+  },
+  get isRemote() {
+    return runtime.processType != MAIN_PROCESS;
+  }
+};
+exports.process = process;
+
+function definePort(obj, name) {
+  obj.port.emit = (event, ...args) => {
+    let manager = ns(obj).messageManager;
+    if (!manager)
+      return;
+
+    manager.sendAsyncMessage(name, { loaderID, event, args });
+  };
+}
+
+function messageReceived({ data, objects }) {
+  // Ignore messages from other loaders
+  if (data.loaderID != loaderID)
+    return;
+
+  let keys = Object.keys(objects);
+  if (keys.length) {
+    // If any objects are CPOWs then ignore this message. We don't want child
+    // processes interracting with CPOWs
+    if (!keys.every(name => !Cu.isCrossProcessWrapper(objects[name])))
+      return;
+
+    data.args.push(objects);
+  }
+
+  emit(this.port, data.event, this, ...data.args);
+}
+
+ns(process).messageManager = mm;
+definePort(process, 'sdk/remote/process/message');
+let processMessageReceived = messageReceived.bind(process);
+mm.addMessageListener('sdk/remote/process/message', processMessageReceived);
+
+when(() => {
+  mm.removeMessageListener('sdk/remote/process/message', processMessageReceived);
+  frames = null;
+});
+
+process.port.on('sdk/remote/require', (process, uri) => {
+  require(uri);
+});
+
+function listenerEquals(a, b) {
+  for (let prop of ["type", "callback", "isCapturing"]) {
+    if (a[prop] != b[prop])
+      return false;
+  }
+  return true;
+}
+
+function listenerFor(type, callback, isCapturing = false) {
+  return {
+    type,
+    callback,
+    isCapturing,
+    registeredCallback: undefined,
+    get args() {
+      return [
+        this.type,
+        this.registeredCallback ? this.registeredCallback : this.callback,
+        this.isCapturing
+      ];
+    }
+  };
+}
+
+function removeListenerFromArray(array, listener) {
+  let index = array.findIndex(l => listenerEquals(l, listener));
+  if (index < 0)
+    return;
+  array.splice(index, 1);
+}
+
+function getListenerFromArray(array, listener) {
+  return array.find(l => listenerEquals(l, listener));
+}
+
+function arrayContainsListener(array, listener) {
+  return !!getListenerFromArray(array, listener);
+}
+
+function makeFrameEventListener(frame, callback) {
+  return callback.bind(frame);
+}
+
+var FRAME_ID = 0;
+var tabMap = new Map();
+
+const Frame = Class({
+  implements: [ Disposable ],
+  extends: EventTarget,
+  setup: function(contentFrame) {
+    // This ID should be unique for this loader across all processes
+    let priv = ns(this);
+
+    priv.id = runtime.processID + ":" + FRAME_ID++;
+
+    priv.contentFrame = contentFrame;
+    priv.messageManager = contentFrame;
+    priv.domListeners = [];
+
+    tabMap.set(contentFrame.docShell, this);
+
+    priv.messageReceived = messageReceived.bind(this);
+    priv.messageManager.addMessageListener('sdk/remote/frame/message', priv.messageReceived);
+
+    this.port = new EventTarget();
+    definePort(this, 'sdk/remote/frame/message');
+
+    priv.messageManager.sendAsyncMessage('sdk/remote/frame/attach', {
+      loaderID,
+      frameID: priv.id,
+      processID: runtime.processID
+    });
+
+    frames.attachItem(this);
+  },
+
+  dispose: function() {
+    let priv = ns(this);
+
+    emit(this, 'detach', this);
+
+    for (let listener of priv.domListeners)
+      priv.contentFrame.removeEventListener(...listener.args);
+
+    priv.messageManager.removeMessageListener('sdk/remote/frame/message', priv.messageReceived);
+    tabMap.delete(priv.contentFrame.docShell);
+    priv.contentFrame = null;
+  },
+
+  get content() {
+    return ns(this).contentFrame.content;
+  },
+
+  get isTab() {
+    let docShell = ns(this).contentFrame.docShell;
+    if (process.isRemote) {
+      // We don't want to roundtrip to the main process to get this property.
+      // This hack relies on the host app having defined webBrowserChrome only
+      // in frames that are part of the tabs. Since only Firefox has remote
+      // processes right now and does this this works.
+      let tabchild = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+                             .getInterface(Ci.nsITabChild);
+      return !!tabchild.webBrowserChrome;
+    }
+    else {
+      // This is running in the main process so we can break out to the browser
+      // And check we can find a tab for the browser element directly.
+      let browser = docShell.chromeEventHandler;
+      let tab = require('../tabs/utils').getTabForBrowser(browser);
+      return !!tab;
+    }
+  },
+
+  addEventListener: function(...args) {
+    let priv = ns(this);
+
+    let listener = listenerFor(...args);
+    if (arrayContainsListener(priv.domListeners, listener))
+      return;
+
+    listener.registeredCallback = makeFrameEventListener(this, listener.callback);
+
+    priv.domListeners.push(listener);
+    priv.contentFrame.addEventListener(...listener.args);
+  },
+
+  removeEventListener: function(...args) {
+    let priv = ns(this);
+
+    let listener = getListenerFromArray(priv.domListeners, listenerFor(...args));
+    if (!listener)
+      return;
+
+    removeListenerFromArray(priv.domListeners, listener);
+    priv.contentFrame.removeEventListener(...listener.args);
+  }
+});
+
+const FrameList = Class({
+  implements: [ EventParent, Disposable ],
+  extends: EventTarget,
+  setup: function() {
+    EventParent.prototype.initialize.call(this);
+
+    this.port = new EventTarget();
+    ns(this).domListeners = [];
+
+    this.on('attach', frame => {
+      for (let listener of ns(this).domListeners)
+        frame.addEventListener(...listener.args);
+    });
+  },
+
+  dispose: function() {
+    // The only case where we get destroyed is when the loader is unloaded in
+    // which case each frame will clean up its own event listeners.
+    ns(this).domListeners = null;
+  },
+
+  getFrameForWindow: function(window) {
+    let docShell = window.QueryInterface(Ci.nsIInterfaceRequestor)
+                         .getInterface(Ci.nsIDocShell);
+
+    return tabMap.get(docShell) || null;
+  },
+
+  addEventListener: function(...args) {
+    let listener = listenerFor(...args);
+    if (arrayContainsListener(ns(this).domListeners, listener))
+      return;
+
+    ns(this).domListeners.push(listener);
+    for (let frame of this)
+      frame.addEventListener(...listener.args);
+  },
+
+  removeEventListener: function(...args) {
+    let listener = listenerFor(...args);
+    if (!arrayContainsListener(ns(this).domListeners, listener))
+      return;
+
+    removeListenerFromArray(ns(this).domListeners, listener);
+    for (let frame of this)
+      frame.removeEventListener(...listener.args);
+  }
+});
+var frames = exports.frames = new FrameList();
+
+function registerContentFrame(contentFrame) {
+  let frame = new Frame(contentFrame);
+}
+exports.registerContentFrame = registerContentFrame;
+
+function unregisterContentFrame(contentFrame) {
+  let frame = tabMap.get(contentFrame.docShell);
+  if (!frame)
+    return;
+
+  frame.destroy();
+}
+exports.unregisterContentFrame = unregisterContentFrame;
diff --git a/toolkit/jetpack/sdk/remote/core.js b/toolkit/jetpack/sdk/remote/core.js
new file mode 100644
index 000000000..78bb673fd
--- /dev/null
+++ b/toolkit/jetpack/sdk/remote/core.js
@@ -0,0 +1,8 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const options = require("@loader/options");
+
+exports.isChildLoader = options.childLoader;
diff --git a/toolkit/jetpack/sdk/remote/parent.js b/toolkit/jetpack/sdk/remote/parent.js
new file mode 100644
index 000000000..f110fe3f6
--- /dev/null
+++ b/toolkit/jetpack/sdk/remote/parent.js
@@ -0,0 +1,338 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { isChildLoader } = require('./core');
+if (isChildLoader)
+  throw new Error("Cannot load sdk/remote/parent in a child loader.");
+
+const { Cu, Ci, Cc } = require('chrome');
+const runtime = require('../system/runtime');
+
+const MAIN_PROCESS = Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
+
+if (runtime.processType != MAIN_PROCESS) {
+  throw new Error('Cannot use sdk/remote/parent in a child process.');
+}
+
+const { Class } = require('../core/heritage');
+const { Namespace } = require('../core/namespace');
+const { Disposable } = require('../core/disposable');
+const { omit } = require('../util/object');
+const { when } = require('../system/unload');
+const { EventTarget } = require('../event/target');
+const { emit } = require('../event/core');
+const system = require('../system/events');
+const { EventParent } = require('./utils');
+const options = require('@loader/options');
+const loaderModule = require('toolkit/loader');
+const { getTabForBrowser } = require('../tabs/utils');
+
+const appInfo = Cc["@mozilla.org/xre/app-info;1"].
+                getService(Ci.nsIXULRuntime);
+
+exports.useRemoteProcesses = appInfo.browserTabsRemoteAutostart;
+
+// Chose the right function for resolving relative a module id
+var moduleResolve;
+if (options.isNative) {
+  moduleResolve = (id, requirer) => loaderModule.nodeResolve(id, requirer, { rootURI: options.rootURI });
+}
+else {
+  moduleResolve = loaderModule.resolve;
+}
+// Build the sorted path mapping structure that resolveURI requires
+var pathMapping = Object.keys(options.paths)
+                        .sort((a, b) => b.length - a.length)
+                        .map(p => [p, options.paths[p]]);
+
+// Load the scripts in the child processes
+var { getNewLoaderID } = require('../../framescript/FrameScriptManager.jsm');
+var PATH = options.paths[''];
+
+const childOptions = omit(options, ['modules', 'globals', 'resolve', 'load']);
+childOptions.modules = {};
+// @l10n/data is just JSON data and can be safely sent across to the child loader
+try {
+  childOptions.modules["@l10n/data"] = require("@l10n/data");
+}
+catch (e) {
+  // There may be no l10n data
+}
+const loaderID = getNewLoaderID();
+childOptions.loaderID = loaderID;
+childOptions.childLoader = true;
+
+const ppmm = Cc['@mozilla.org/parentprocessmessagemanager;1'].
+             getService(Ci.nsIMessageBroadcaster);
+const gmm = Cc['@mozilla.org/globalmessagemanager;1'].
+            getService(Ci.nsIMessageBroadcaster);
+
+const ns = Namespace();
+
+var processMap = new Map();
+
+function definePort(obj, name) {
+  obj.port.emitCPOW = (event, args, cpows = {}) => {
+    let manager = ns(obj).messageManager;
+    if (!manager)
+      return;
+
+    let method = manager instanceof Ci.nsIMessageBroadcaster ?
+                 "broadcastAsyncMessage" : "sendAsyncMessage";
+
+    manager[method](name, { loaderID, event, args }, cpows);
+  };
+
+  obj.port.emit = (event, ...args) => obj.port.emitCPOW(event, args);
+}
+
+function messageReceived({ target, data }) {
+  // Ignore messages from other loaders
+  if (data.loaderID != loaderID)
+    return;
+
+  emit(this.port, data.event, this, ...data.args);
+}
+
+// Process represents a gecko process that can load webpages. Each process
+// contains a number of Frames. This class is used to send and receive messages
+// from a single process.
+const Process = Class({
+  implements: [ Disposable ],
+  extends: EventTarget,
+  setup: function(id, messageManager, isRemote) {
+    ns(this).id = id;
+    ns(this).isRemote = isRemote;
+    ns(this).messageManager = messageManager;
+    ns(this).messageReceived = messageReceived.bind(this);
+    this.destroy = this.destroy.bind(this);
+    ns(this).messageManager.addMessageListener('sdk/remote/process/message', ns(this).messageReceived);
+    ns(this).messageManager.addMessageListener('child-process-shutdown', this.destroy);
+
+    this.port = new EventTarget();
+    definePort(this, 'sdk/remote/process/message');
+
+    // Load any remote modules
+    for (let module of remoteModules.values())
+      this.port.emit('sdk/remote/require', module);
+
+    processMap.set(ns(this).id, this);
+    processes.attachItem(this);
+  },
+
+  dispose: function() {
+    emit(this, 'detach', this);
+    processMap.delete(ns(this).id);
+    ns(this).messageManager.removeMessageListener('sdk/remote/process/message', ns(this).messageReceived);
+    ns(this).messageManager.removeMessageListener('child-process-shutdown', this.destroy);
+    ns(this).messageManager = null;
+  },
+
+  // Returns true if this process is a child process
+  get isRemote() {
+    return ns(this).isRemote;
+  }
+});
+
+// Processes gives an API for enumerating an sending and receiving messages from
+// all processes as well as detecting when a new process starts.
+const Processes = Class({
+  implements: [ EventParent ],
+  extends: EventTarget,
+  initialize: function() {
+    EventParent.prototype.initialize.call(this);
+    ns(this).messageManager = ppmm;
+
+    this.port = new EventTarget();
+    definePort(this, 'sdk/remote/process/message');
+  },
+
+  getById: function(id) {
+    return processMap.get(id);
+  }
+});
+var processes = exports.processes = new Processes();
+
+var frameMap = new Map();
+
+function setFrameProcess(frame, process) {
+  ns(frame).process = process;
+  frames.attachItem(frame);
+}
+
+// Frames display webpages in a process. In the main process every Frame is
+// linked with a <browser> or <iframe> element. 
+const Frame = Class({
+  implements: [ Disposable ],
+  extends: EventTarget,
+  setup: function(id, node) {
+    ns(this).id = id;
+    ns(this).node = node;
+
+    let frameLoader = node.QueryInterface(Ci.nsIFrameLoaderOwner).frameLoader;
+    ns(this).messageManager = frameLoader.messageManager;
+
+    ns(this).messageReceived = messageReceived.bind(this);
+    ns(this).messageManager.addMessageListener('sdk/remote/frame/message', ns(this).messageReceived);
+
+    this.port = new EventTarget();
+    definePort(this, 'sdk/remote/frame/message');
+
+    frameMap.set(ns(this).messageManager, this);
+  },
+
+  dispose: function() {
+    emit(this, 'detach', this);
+    ns(this).messageManager.removeMessageListener('sdk/remote/frame/message', ns(this).messageReceived);
+
+    frameMap.delete(ns(this).messageManager);
+    ns(this).messageManager = null;
+  },
+
+  // Returns the browser or iframe element this frame displays in
+  get frameElement() {
+    return ns(this).node;
+  },
+
+  // Returns the process that this frame loads in
+  get process() {
+    return ns(this).process;
+  },
+
+  // Returns true if this frame is a tab in a main browser window
+  get isTab() {
+    let tab = getTabForBrowser(ns(this).node);
+    return !!tab;
+  }
+});
+
+function managerDisconnected({ subject: manager }) {
+  let frame = frameMap.get(manager);
+  if (frame)
+    frame.destroy();
+}
+system.on('message-manager-disconnect', managerDisconnected);
+
+// Provides an API for enumerating and sending and receiving messages from all
+// Frames
+const FrameList = Class({
+  implements: [ EventParent ],
+  extends: EventTarget,
+  initialize: function() {
+    EventParent.prototype.initialize.call(this);
+    ns(this).messageManager = gmm;
+
+    this.port = new EventTarget();
+    definePort(this, 'sdk/remote/frame/message');
+  },
+
+  // Returns the frame for a browser element
+  getFrameForBrowser: function(browser) {
+    for (let frame of this) {
+      if (frame.frameElement == browser)
+        return frame;
+    }
+    return null;
+  },
+});
+var frames = exports.frames = new FrameList();
+
+// Create the module loader in any existing processes
+ppmm.broadcastAsyncMessage('sdk/remote/process/load', {
+  modulePath: PATH,
+  loaderID,
+  options: childOptions,
+  reason: "broadcast"
+});
+
+// A loader has started in a remote process
+function processLoaderStarted({ target, data }) {
+  if (data.loaderID != loaderID)
+    return;
+
+  if (processMap.has(data.processID)) {
+    console.error("Saw the same process load the same loader twice. This is a bug in the SDK.");
+    return;
+  }
+
+  let process = new Process(data.processID, target, data.isRemote);
+
+  if (pendingFrames.has(data.processID)) {
+    for (let frame of pendingFrames.get(data.processID))
+      setFrameProcess(frame, process);
+    pendingFrames.delete(data.processID);
+  }
+}
+
+// A new process has started
+function processStarted({ target, data: { modulePath } }) {
+  if (modulePath != PATH)
+    return;
+
+  // Have it load a loader if it hasn't already
+  target.sendAsyncMessage('sdk/remote/process/load', {
+    modulePath,
+    loaderID,
+    options: childOptions,
+    reason: "response"
+  });
+}
+
+var pendingFrames = new Map();
+
+// A new frame has been created in the remote process
+function frameAttached({ target, data }) {
+  if (data.loaderID != loaderID)
+    return;
+
+  let frame = new Frame(data.frameID, target);
+
+  let process = processMap.get(data.processID);
+  if (process) {
+    setFrameProcess(frame, process);
+    return;
+  }
+
+  // In some cases frame messages can arrive earlier than process messages
+  // causing us to see a new frame appear before its process. In this case
+  // cache the frame data until we see the process. See bug 1131375.
+  if (!pendingFrames.has(data.processID))
+    pendingFrames.set(data.processID, [frame]);
+  else
+    pendingFrames.get(data.processID).push(frame);
+}
+
+// Wait for new processes and frames
+ppmm.addMessageListener('sdk/remote/process/attach', processLoaderStarted);
+ppmm.addMessageListener('sdk/remote/process/start', processStarted);
+gmm.addMessageListener('sdk/remote/frame/attach', frameAttached);
+
+when(reason => {
+  ppmm.removeMessageListener('sdk/remote/process/attach', processLoaderStarted);
+  ppmm.removeMessageListener('sdk/remote/process/start', processStarted);
+  gmm.removeMessageListener('sdk/remote/frame/attach', frameAttached);
+
+  ppmm.broadcastAsyncMessage('sdk/remote/process/unload', { loaderID, reason });
+});
+
+var remoteModules = new Set();
+
+// Ensures a module is loaded in every child process. It is safe to send 
+// messages to this module immediately after calling this.
+// Pass a module to resolve the id relatively.
+function remoteRequire(id, module = null) {
+  // Resolve relative to calling module if passed
+  if (module)
+    id = moduleResolve(id, module.id);
+  let uri = loaderModule.resolveURI(id, pathMapping);
+
+  // Don't reload the same module
+  if (remoteModules.has(uri))
+    return;
+
+  remoteModules.add(uri);
+  processes.port.emit('sdk/remote/require', uri);
+}
+exports.remoteRequire = remoteRequire;
diff --git a/toolkit/jetpack/sdk/remote/utils.js b/toolkit/jetpack/sdk/remote/utils.js
new file mode 100644
index 000000000..5a5e39198
--- /dev/null
+++ b/toolkit/jetpack/sdk/remote/utils.js
@@ -0,0 +1,39 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Class } = require('../core/heritage');
+const { List, addListItem, removeListItem } = require('../util/list');
+const { emit } = require('../event/core');
+const { pipe } = require('../event/utils');
+
+// A helper class that maintains a list of EventTargets. Any events emitted
+// to an EventTarget are also emitted by the EventParent. Likewise for an
+// EventTarget's port property.
+const EventParent = Class({
+  implements: [ List ],
+
+  attachItem: function(item) {
+    addListItem(this, item);
+
+    pipe(item.port, this.port);
+    pipe(item, this);
+
+    item.once('detach', () => {
+      removeListItem(this, item);
+    })
+
+    emit(this, 'attach', item);
+  },
+
+  // Calls listener for every object already in the list and every object
+  // subsequently added to the list.
+  forEvery: function(listener) {
+    for (let item of this)
+      listener(item);
+
+    this.on('attach', listener);
+  }
+});
+exports.EventParent = EventParent;
diff --git a/toolkit/jetpack/sdk/request.js b/toolkit/jetpack/sdk/request.js
new file mode 100644
index 000000000..96bb1e6d7
--- /dev/null
+++ b/toolkit/jetpack/sdk/request.js
@@ -0,0 +1,248 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { ns } = require("./core/namespace");
+const { emit } = require("./event/core");
+const { merge } = require("./util/object");
+const { stringify } = require("./querystring");
+const { EventTarget } = require("./event/target");
+const { Class } = require("./core/heritage");
+const { XMLHttpRequest, forceAllowThirdPartyCookie } = require("./net/xhr");
+const apiUtils = require("./deprecated/api-utils");
+const { isValidURI } = require("./url.js");
+
+const response = ns();
+const request = ns();
+
+// Instead of creating a new validator for each request, just make one and
+// reuse it.
+const { validateOptions, validateSingleOption } = new OptionsValidator({
+  url: {
+    // Also converts a URL instance to string, bug 857902
+    map: url => url.toString(),
+    ok: isValidURI
+  },
+  headers: {
+    map: v => v || {},
+    is:  ["object"],
+  },
+  content: {
+    map: v => v || null,
+    is:  ["string", "object", "null"],
+  },
+  contentType: {
+    map: v => v || "application/x-www-form-urlencoded",
+    is:  ["string"],
+  },
+  overrideMimeType: {
+    map: v => v || null,
+    is: ["string", "null"],
+  },
+  anonymous: {
+    map: v => v || false,
+    is: ["boolean", "null"],
+  }
+});
+
+const REUSE_ERROR = "This request object has been used already. You must " +
+                    "create a new one to make a new request."
+
+// Utility function to prep the request since it's the same between
+// request types
+function runRequest(mode, target) {
+  let source = request(target)
+  let { xhr, url, content, contentType, headers, overrideMimeType, anonymous } = source;
+
+  let isGetOrHead = (mode == "GET" || mode == "HEAD");
+
+  // If this request has already been used, then we can't reuse it.
+  // Throw an error.
+  if (xhr)
+    throw new Error(REUSE_ERROR);
+
+  xhr = source.xhr = new XMLHttpRequest({
+    mozAnon: anonymous
+  });
+
+  // Build the data to be set. For GET or HEAD requests, we want to append that
+  // to the URL before opening the request.
+  let data = stringify(content);
+  // If the URL already has ? in it, then we want to just use &
+  if (isGetOrHead && data)
+    url = url + (/\?/.test(url) ? "&" : "?") + data;
+
+  // open the request
+  xhr.open(mode, url);
+
+
+  forceAllowThirdPartyCookie(xhr);
+
+  // request header must be set after open, but before send
+  xhr.setRequestHeader("Content-Type", contentType);
+
+  // set other headers
+  Object.keys(headers).forEach(function(name) {
+    xhr.setRequestHeader(name, headers[name]);
+  });
+
+  // set overrideMimeType
+  if (overrideMimeType)
+    xhr.overrideMimeType(overrideMimeType);
+
+  // handle the readystate, create the response, and call the callback
+  xhr.onreadystatechange = function onreadystatechange() {
+    if (xhr.readyState === 4) {
+      let response = Response(xhr);
+      source.response = response;
+      emit(target, 'complete', response);
+    }
+  };
+
+  // actually send the request.
+  // We don't want to send data on GET or HEAD requests.
+  xhr.send(!isGetOrHead ? data : null);
+}
+
+const Request = Class({
+  extends: EventTarget,
+  initialize: function initialize(options) {
+    // `EventTarget.initialize` will set event listeners that are named
+    // like `onEvent` in this case `onComplete` listener will be set to
+    // `complete` event.
+    EventTarget.prototype.initialize.call(this, options);
+
+    // Copy normalized options.
+    merge(request(this), validateOptions(options));
+  },
+  get url() { return request(this).url; },
+  set url(value) { request(this).url = validateSingleOption('url', value); },
+  get headers() { return request(this).headers; },
+  set headers(value) {
+    return request(this).headers = validateSingleOption('headers', value);
+  },
+  get content() { return request(this).content; },
+  set content(value) {
+    request(this).content = validateSingleOption('content', value);
+  },
+  get contentType() { return request(this).contentType; },
+  set contentType(value) {
+    request(this).contentType = validateSingleOption('contentType', value);
+  },
+  get anonymous() { return request(this).anonymous; },
+  get response() { return request(this).response; },
+  delete: function() {
+    runRequest('DELETE', this);
+    return this;
+  },
+  get: function() {
+    runRequest('GET', this);
+    return this;
+  },
+  post: function() {
+    runRequest('POST', this);
+    return this;
+  },
+  put: function() {
+    runRequest('PUT', this);
+    return this;
+  },
+  head: function() {
+    runRequest('HEAD', this);
+    return this;
+  }
+});
+exports.Request = Request;
+
+const Response = Class({
+  initialize: function initialize(request) {
+    response(this).request = request;
+  },
+  // more about responseURL: https://bugzilla.mozilla.org/show_bug.cgi?id=998076
+  get url() {
+    return response(this).request.responseURL;
+  },
+  get text() {
+    return response(this).request.responseText;
+  },
+  get xml() {
+    throw new Error("Sorry, the 'xml' property is no longer available. " +
+                    "see bug 611042 for more information.");
+  },
+  get status() {
+    return response(this).request.status;
+  },
+  get statusText() {
+    return response(this).request.statusText;
+  },
+  get json() {
+    try {
+      return JSON.parse(this.text);
+    } catch(error) {
+      return null;
+    }
+  },
+  get headers() {
+    let headers = {}, lastKey;
+    // Since getAllResponseHeaders() will return null if there are no headers,
+    // defend against it by defaulting to ""
+    let rawHeaders = response(this).request.getAllResponseHeaders() || "";
+    rawHeaders.split("\n").forEach(function (h) {
+      // According to the HTTP spec, the header string is terminated by an empty
+      // line, so we can just skip it.
+      if (!h.length) {
+        return;
+      }
+
+      let index = h.indexOf(":");
+      // The spec allows for leading spaces, so instead of assuming a single
+      // leading space, just trim the values.
+      let key = h.substring(0, index).trim(),
+          val = h.substring(index + 1).trim();
+
+      // For empty keys, that means that the header value spanned multiple lines.
+      // In that case we should append the value to the value of lastKey with a
+      // new line. We'll assume lastKey will be set because there should never
+      // be an empty key on the first pass.
+      if (key) {
+        headers[key] = val;
+        lastKey = key;
+      }
+      else {
+        headers[lastKey] += "\n" + val;
+      }
+    });
+    return headers;
+  },
+  get anonymous() {
+    return response(this).request.mozAnon;
+  }
+});
+
+// apiUtils.validateOptions doesn't give the ability to easily validate single
+// options, so this is a wrapper that provides that ability.
+function OptionsValidator(rules) {
+  return {
+    validateOptions: function (options) {
+      return apiUtils.validateOptions(options, rules);
+    },
+    validateSingleOption: function (field, value) {
+      // We need to create a single rule object from our listed rules. To avoid
+      // JavaScript String warnings, check for the field & default to an empty object.
+      let singleRule = {};
+      if (field in rules) {
+        singleRule[field] = rules[field];
+      }
+      let singleOption = {};
+      singleOption[field] = value;
+      // This should throw if it's invalid, which will bubble up & out.
+      return apiUtils.validateOptions(singleOption, singleRule)[field];
+    }
+  };
+}
diff --git a/toolkit/jetpack/sdk/selection.js b/toolkit/jetpack/sdk/selection.js
new file mode 100644
index 000000000..8682e8c6d
--- /dev/null
+++ b/toolkit/jetpack/sdk/selection.js
@@ -0,0 +1,470 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "stable",
+  "engines": {
+    "Firefox": "*",
+    "SeaMonkey": "*"
+  }
+};
+
+const { Ci, Cc } = require("chrome"),
+    { setTimeout } = require("./timers"),
+    { emit, off } = require("./event/core"),
+    { Class, obscure } = require("./core/heritage"),
+    { EventTarget } = require("./event/target"),
+    { ns } = require("./core/namespace"),
+    { when: unload } = require("./system/unload"),
+    { ignoreWindow } = require('./private-browsing/utils'),
+    { getTabs, getTabForContentWindow,
+      getAllTabContentWindows } = require('./tabs/utils'),
+    winUtils = require("./window/utils"),
+    events = require("./system/events");
+
+// The selection types
+const HTML = 0x01,
+      TEXT = 0x02,
+      DOM  = 0x03; // internal use only
+
+// A more developer-friendly message than the caught exception when is not
+// possible change a selection.
+const ERR_CANNOT_CHANGE_SELECTION =
+  "It isn't possible to change the selection, as there isn't currently a selection";
+
+const selections = ns();
+
+const Selection = Class({
+  /**
+   * Creates an object from which a selection can be set, get, etc. Each
+   * object has an associated with a range number. Range numbers are the
+   * 0-indexed counter of selection ranges as explained at
+   * https://developer.mozilla.org/en/DOM/Selection.
+   *
+   * @param rangeNumber
+   *        The zero-based range index into the selection
+   */
+  initialize: function initialize(rangeNumber) {
+    // In order to hide the private `rangeNumber` argument from API consumers
+    // while still enabling Selection getters/setters to access it, we define
+    // it as non enumerable, non configurable property. While consumers still
+    // may discover it they won't be able to do any harm which is good enough
+    // in this case.
+    Object.defineProperties(this, {
+      rangeNumber: {
+        enumerable: false,
+        configurable: false,
+        value: rangeNumber
+      }
+    });
+  },
+  get text() { return getSelection(TEXT, this.rangeNumber); },
+  set text(value) { setSelection(TEXT, value, this.rangeNumber); },
+  get html() { return getSelection(HTML, this.rangeNumber); },
+  set html(value) { setSelection(HTML, value, this.rangeNumber); },
+  get isContiguous() {
+
+    // If there are multiple non empty ranges, the selection is definitely
+    // discontiguous. It returns `false` also if there are no valid selection.
+    let count = 0;
+    for (let sel in selectionIterator)
+      if (++count > 1)
+        break;
+
+    return count === 1;
+  }
+});
+
+const selectionListener = {
+  notifySelectionChanged: function (document, selection, reason) {
+    if (!["SELECTALL", "KEYPRESS", "MOUSEUP"].some(type => reason &
+      Ci.nsISelectionListener[type + "_REASON"]) || selection.toString() == "")
+        return;
+
+    this.onSelect();
+  },
+
+  onSelect: function() {
+    emit(module.exports, "select");
+  }
+}
+
+/**
+ * Defines iterators so that discontiguous selections can be iterated.
+ * Empty selections are skipped - see `safeGetRange` for further details.
+ *
+ * If discontiguous selections are in a text field, only the first one
+ * is returned because the text field selection APIs doesn't support
+ * multiple selections.
+ */
+function* forOfIterator() {
+  let selection = getSelection(DOM);
+  let count = 0;
+
+  if (selection)
+    count = selection.rangeCount || (getElementWithSelection() ? 1 : 0);
+
+  for (let i = 0; i < count; i++) {
+    let sel = Selection(i);
+
+    if (sel.text)
+      yield Selection(i);
+  }
+}
+
+const selectionIteratorOptions = {
+  __iterator__: function() {
+      for (let item of this)
+          yield item;
+  }
+}
+selectionIteratorOptions[Symbol.iterator] = forOfIterator;
+const selectionIterator = obscure(selectionIteratorOptions);
+
+/**
+ * Returns the most recent focused window.
+ * if private browsing window is most recent and not supported,
+ * then ignore it and return `null`, because the focused window
+ * can't be targeted.
+ */
+function getFocusedWindow() {
+  let window = winUtils.getFocusedWindow();
+
+  return ignoreWindow(window) ? null : window;
+}
+
+/**
+ * Returns the focused element in the most recent focused window
+ * if private browsing window is most recent and not supported,
+ * then ignore it and return `null`, because the focused element
+ * can't be targeted.
+ */
+function getFocusedElement() {
+  let element = winUtils.getFocusedElement();
+
+  if (!element || ignoreWindow(element.ownerDocument.defaultView))
+    return null;
+
+  return element;
+}
+
+/**
+ * Returns the current selection from most recent content window. Depending on
+ * the specified |type|, the value returned can be a string of text, stringified
+ * HTML, or a DOM selection object as described at
+ * https://developer.mozilla.org/en/DOM/Selection.
+ *
+ * @param type
+ *        Specifies the return type of the selection. Valid values are the one
+ *        of the constants HTML, TEXT, or DOM.
+ *
+ * @param rangeNumber
+ *        Specifies the zero-based range index of the returned selection.
+ */
+function getSelection(type, rangeNumber) {
+  let window, selection;
+  try {
+    window = getFocusedWindow();
+    selection = window.getSelection();
+  }
+  catch (e) {
+    return null;
+  }
+
+  // Get the selected content as the specified type
+  if (type == DOM) {
+    return selection;
+  }
+  else if (type == TEXT) {
+    let range = safeGetRange(selection, rangeNumber);
+
+    if (range)
+      return range.toString();
+
+    let node = getElementWithSelection();
+
+    if (!node)
+      return null;
+
+    return node.value.substring(node.selectionStart, node.selectionEnd);
+  }
+  else if (type == HTML) {
+    let range = safeGetRange(selection, rangeNumber);
+    // Another way, but this includes the xmlns attribute for all elements in
+    // Gecko 1.9.2+ :
+    // return Cc["@mozilla.org/xmlextras/xmlserializer;1"].
+    //   createInstance(Ci.nsIDOMSerializer).serializeToSTring(range.
+    //     cloneContents());
+    if (!range)
+      return null;
+
+    let node = window.document.createElement("span");
+    node.appendChild(range.cloneContents());
+    return node.innerHTML;
+  }
+
+  throw new Error("Type " + type + " is unrecognized.");
+}
+
+/**
+ * Sets the current selection of the most recent content document by changing
+ * the existing selected text/HTML range to the specified value.
+ *
+ * @param val
+ *        The value for the new selection
+ *
+ * @param rangeNumber
+ *        The zero-based range index of the selection to be set
+ *
+ */
+function setSelection(type, val, rangeNumber) {
+  // Make sure we have a window context & that there is a current selection.
+  // Selection cannot be set unless there is an existing selection.
+  let window, selection;
+
+  try {
+    window = getFocusedWindow();
+    selection = window.getSelection();
+  }
+  catch (e) {
+    throw new Error(ERR_CANNOT_CHANGE_SELECTION);
+  }
+
+  let range = safeGetRange(selection, rangeNumber);
+
+  if (range) {
+    let fragment;
+
+    if (type === HTML)
+      fragment = range.createContextualFragment(val);
+    else {
+      fragment = range.createContextualFragment("");
+      fragment.textContent = val;
+    }
+
+    range.deleteContents();
+    range.insertNode(fragment);
+  }
+  else {
+    let node = getElementWithSelection();
+
+    if (!node)
+      throw new Error(ERR_CANNOT_CHANGE_SELECTION);
+
+    let { value, selectionStart, selectionEnd } = node;
+
+    let newSelectionEnd = selectionStart + val.length;
+
+    node.value = value.substring(0, selectionStart) +
+                  val +
+                  value.substring(selectionEnd, value.length);
+
+    node.setSelectionRange(selectionStart, newSelectionEnd);
+  }
+}
+
+/**
+ * Returns the specified range in a selection without throwing an exception.
+ *
+ * @param selection
+ *        A selection object as described at
+ *         https://developer.mozilla.org/en/DOM/Selection
+ *
+ * @param [rangeNumber]
+ *        Specifies the zero-based range index of the returned selection.
+ *        If it's not provided the function will return the first non empty
+ *        range, if any.
+ */
+function safeGetRange(selection, rangeNumber) {
+  try {
+    let { rangeCount } = selection;
+    let range = null;
+
+    if (typeof rangeNumber === "undefined")
+      rangeNumber = 0;
+    else
+      rangeCount = rangeNumber + 1;
+
+    for (; rangeNumber < rangeCount; rangeNumber++ ) {
+      range = selection.getRangeAt(rangeNumber);
+
+      if (range && range.toString())
+        break;
+
+      range = null;
+    }
+
+    return range;
+  }
+  catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Returns a reference of the DOM's active element for the window given, if it
+ * supports the text field selection API and has a text selected.
+ *
+ * Note:
+ *   we need this method because window.getSelection doesn't return a selection
+ *   for text selected in a form field (see bug 85686)
+ */
+function getElementWithSelection() {
+  let element = getFocusedElement();
+
+  if (!element)
+    return null;
+
+  try {
+    // Accessing selectionStart and selectionEnd on e.g. a button
+    // results in an exception thrown as per the HTML5 spec.  See
+    // http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#textFieldSelection
+
+    let { value, selectionStart, selectionEnd } = element;
+
+    let hasSelection = typeof value === "string" &&
+                      !isNaN(selectionStart) &&
+                      !isNaN(selectionEnd) &&
+                      selectionStart !== selectionEnd;
+
+    return hasSelection ? element : null;
+  }
+  catch (err) {
+    return null;
+  }
+
+}
+
+/**
+ * Adds the Selection Listener to the content's window given
+ */
+function addSelectionListener(window) {
+  let selection = window.getSelection();
+
+  // Don't add the selection's listener more than once to the same window,
+  // if the selection object is the same
+  if ("selection" in selections(window) && selections(window).selection === selection)
+    return;
+
+  // We ensure that the current selection is an instance of
+  // `nsISelectionPrivate` before working on it, in case is `null`.
+  //
+  // If it's `null` it's likely too early to add the listener, and we demand
+  // that operation to `document-shown` - it can easily happens for frames
+  if (selection instanceof Ci.nsISelectionPrivate)
+    selection.addSelectionListener(selectionListener);
+
+  // nsISelectionListener implementation seems not fire a notification if
+  // a selection is in a text field, therefore we need to add a listener to
+  // window.onselect, that is fired only for text fields.
+  // For consistency, we add it only when the nsISelectionListener is added.
+  //
+  // https://developer.mozilla.org/en/DOM/window.onselect
+  window.addEventListener("select", selectionListener.onSelect, true);
+
+  selections(window).selection = selection;
+};
+
+/**
+ * Removes the Selection Listener to the content's window given
+ */
+function removeSelectionListener(window) {
+  // Don't remove the selection's listener to a window that wasn't handled.
+  if (!("selection" in selections(window)))
+    return;
+
+  let selection = window.getSelection();
+  let isSameSelection = selection === selections(window).selection;
+
+  // Before remove the listener, we ensure that the current selection is an
+  // instance of `nsISelectionPrivate` (it could be `null`), and that is still
+  // the selection we managed for this window (it could be detached).
+  if (selection instanceof Ci.nsISelectionPrivate && isSameSelection)
+    selection.removeSelectionListener(selectionListener);
+
+  window.removeEventListener("select", selectionListener.onSelect, true);
+
+  delete selections(window).selection;
+};
+
+function onContent(event) {
+  let window = event.subject.defaultView;
+
+  // We are not interested in documents without valid defaultView (e.g. XML)
+  // that aren't in a tab (e.g. Panel); or in private windows
+   if (window && getTabForContentWindow(window) && !ignoreWindow(window)) {
+    addSelectionListener(window);
+  }
+}
+
+// Adds Selection listener to new documents
+// Note that strong reference is needed for documents that are loading slowly or
+// where the server didn't close the connection (e.g. "comet").
+events.on("document-element-inserted", onContent, true);
+
+// Adds Selection listeners to existing documents
+getAllTabContentWindows().forEach(addSelectionListener);
+
+// When a document is not visible anymore the selection object is detached, and
+// a new selection object is created when it becomes visible again.
+// That makes the previous selection's listeners added previously totally
+// useless – the listeners are not notified anymore.
+// To fix that we're listening for `document-shown` event in order to add
+// the listeners to the new selection object created.
+//
+// See bug 665386 for further details.
+
+function onShown(event) {
+  let window = event.subject.defaultView;
+
+  // We are not interested in documents without valid defaultView.
+  // For example XML documents don't have windows and we don't yet support them.
+  if (!window)
+    return;
+
+  // We want to handle only the windows where we added selection's listeners
+  if ("selection" in selections(window)) {
+    let currentSelection = window.getSelection();
+    let { selection } = selections(window);
+
+    // If the current selection for the window given is different from the one
+    // stored in the namespace, we need to add the listeners again, and replace
+    // the previous selection in our list with the new one.
+    //
+    // Notice that we don't have to remove the listeners from the old selection,
+    // because is detached. An attempt to remove the listener, will raise an
+    // error (see http://mxr.mozilla.org/mozilla-central/source/layout/generic/nsSelection.cpp#5343 )
+    //
+    // We ensure that the current selection is an instance of
+    // `nsISelectionPrivate` before working on it, in case is `null`.
+    if (currentSelection instanceof Ci.nsISelectionPrivate &&
+      currentSelection !== selection) {
+
+      window.addEventListener("select", selectionListener.onSelect, true);
+      currentSelection.addSelectionListener(selectionListener);
+      selections(window).selection = currentSelection;
+    }
+  }
+}
+
+events.on("document-shown", onShown, true);
+
+// Removes Selection listeners when the add-on is unloaded
+unload(function(){
+  getAllTabContentWindows().forEach(removeSelectionListener);
+
+  events.off("document-element-inserted", onContent);
+  events.off("document-shown", onShown);
+
+  off(exports);
+});
+
+const selection = Class({
+  extends: EventTarget,
+  implements: [ Selection, selectionIterator ]
+})();
+
+module.exports = selection;
diff --git a/toolkit/jetpack/sdk/self.js b/toolkit/jetpack/sdk/self.js
new file mode 100644
index 000000000..c2114a926
--- /dev/null
+++ b/toolkit/jetpack/sdk/self.js
@@ -0,0 +1,61 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { CC } = require('chrome');
+const options = require('@loader/options');
+
+const { get } = require("./preferences/service");
+const { readURISync } = require('./net/url');
+
+const id = options.id;
+
+const readPref = key => get("extensions." + id + ".sdk." + key);
+
+const name = readPref("name") || options.name;
+const version = readPref("version") || options.version;
+const loadReason = readPref("load.reason") || options.loadReason;
+const rootURI = readPref("rootURI") || options.rootURI || "";
+const baseURI = readPref("baseURI") || options.prefixURI + name + "/"
+const addonDataURI = baseURI + "data/";
+const metadata = options.metadata || {};
+const permissions = metadata.permissions || {};
+const isPacked = rootURI && rootURI.indexOf("jar:") === 0;
+
+const isPrivateBrowsingSupported = 'private-browsing' in permissions &&
+                                   permissions['private-browsing'] === true;
+
+const uri = (path="") =>
+  path.includes(":") ? path : addonDataURI + path.replace(/^\.\//, "");
+
+var preferencesBranch = ("preferences-branch" in metadata)
+                            ? metadata["preferences-branch"]
+                            : options.preferencesBranch
+
+if (/[^\w{@}.-]/.test(preferencesBranch)) {
+  preferencesBranch = id;
+  console.warn("Ignoring preferences-branch (not a valid branch name)");
+}
+
+// Some XPCOM APIs require valid URIs as an argument for certain operations
+// (see `nsILoginManager` for example). This property represents add-on
+// associated unique URI string that can be used for that.
+exports.uri = 'addon:' + id;
+exports.id = id;
+exports.preferencesBranch = preferencesBranch || id;
+exports.name = name;
+exports.loadReason = loadReason;
+exports.version = version;
+exports.packed = isPacked;
+exports.data = Object.freeze({
+  url: uri,
+  load: function read(path) {
+    return readURISync(uri(path));
+  }
+});
+exports.isPrivateBrowsingSupported = isPrivateBrowsingSupported;
diff --git a/toolkit/jetpack/sdk/simple-prefs.js b/toolkit/jetpack/sdk/simple-prefs.js
new file mode 100644
index 000000000..3472f4418
--- /dev/null
+++ b/toolkit/jetpack/sdk/simple-prefs.js
@@ -0,0 +1,26 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { emit, off } = require("./event/core");
+const { PrefsTarget } = require("./preferences/event-target");
+const { preferencesBranch, id } = require("./self");
+const { on } = require("./system/events");
+
+const ADDON_BRANCH = "extensions." + preferencesBranch + ".";
+const BUTTON_PRESSED = id + "-cmdPressed";
+
+const target = PrefsTarget({ branchName: ADDON_BRANCH });
+
+// Listen to clicks on buttons
+function buttonClick({ data }) {
+  emit(target, data);
+}
+on(BUTTON_PRESSED, buttonClick);
+
+module.exports = target;
diff --git a/toolkit/jetpack/sdk/simple-storage.js b/toolkit/jetpack/sdk/simple-storage.js
new file mode 100644
index 000000000..bcf9b1cb9
--- /dev/null
+++ b/toolkit/jetpack/sdk/simple-storage.js
@@ -0,0 +1,235 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { Cc, Ci } = require("chrome");
+const file = require("./io/file");
+const prefs = require("./preferences/service");
+const jpSelf = require("./self");
+const timer = require("./timers");
+const unload = require("./system/unload");
+const { emit, on, off } = require("./event/core");
+
+const WRITE_PERIOD_PREF = "extensions.addon-sdk.simple-storage.writePeriod";
+const WRITE_PERIOD_DEFAULT = 300000; // 5 minutes
+
+const QUOTA_PREF = "extensions.addon-sdk.simple-storage.quota";
+const QUOTA_DEFAULT = 5242880; // 5 MiB
+
+const JETPACK_DIR_BASENAME = "jetpack";
+
+Object.defineProperties(exports, {
+  storage: {
+    enumerable: true,
+    get: function() { return manager.root; },
+    set: function(value) { manager.root = value; }
+  },
+  quotaUsage: {
+    get: function() { return manager.quotaUsage; }
+  }
+});
+
+// A generic JSON store backed by a file on disk.  This should be isolated
+// enough to move to its own module if need be...
+function JsonStore(options) {
+  this.filename = options.filename;
+  this.quota = options.quota;
+  this.writePeriod = options.writePeriod;
+  this.onOverQuota = options.onOverQuota;
+  this.onWrite = options.onWrite;
+
+  unload.ensure(this);
+
+  this.writeTimer = timer.setInterval(this.write.bind(this),
+                                      this.writePeriod);
+}
+
+JsonStore.prototype = {
+  // The store's root.
+  get root() {
+    return this.isRootInited ? this._root : {};
+  },
+
+  // Performs some type checking.
+  set root(val) {
+    let types = ["array", "boolean", "null", "number", "object", "string"];
+    if (types.indexOf(typeof(val)) < 0) {
+      throw new Error("storage must be one of the following types: " +
+                      types.join(", "));
+    }
+    this._root = val;
+    return val;
+  },
+
+  // True if the root has ever been set (either via the root setter or by the
+  // backing file's having been read).
+  get isRootInited() {
+    return this._root !== undefined;
+  },
+
+  // Percentage of quota used, as a number [0, Inf).  > 1 implies over quota.
+  // Undefined if there is no quota.
+  get quotaUsage() {
+    return this.quota > 0 ?
+           JSON.stringify(this.root).length / this.quota :
+           undefined;
+  },
+
+  // Removes the backing file and all empty subdirectories.
+  purge: function JsonStore_purge() {
+    try {
+      // This'll throw if the file doesn't exist.
+      file.remove(this.filename);
+      let parentPath = this.filename;
+      do {
+        parentPath = file.dirname(parentPath);
+        // This'll throw if the dir isn't empty.
+        file.rmdir(parentPath);
+      } while (file.basename(parentPath) !== JETPACK_DIR_BASENAME);
+    }
+    catch (err) {}
+  },
+
+  // Initializes the root by reading the backing file.
+  read: function JsonStore_read() {
+    try {
+      let str = file.read(this.filename);
+
+      // Ideally we'd log the parse error with console.error(), but logged
+      // errors cause tests to fail.  Supporting "known" errors in the test
+      // harness appears to be non-trivial.  Maybe later.
+      this.root = JSON.parse(str);
+    }
+    catch (err) {
+      this.root = {};
+    }
+  },
+
+  // If the store is under quota, writes the root to the backing file.
+  // Otherwise quota observers are notified and nothing is written.
+  write: function JsonStore_write() {
+    if (this.quotaUsage > 1)
+      this.onOverQuota(this);
+    else
+      this._write();
+  },
+
+  // Cleans up on unload.  If unloading because of uninstall, the store is
+  // purged; otherwise it's written.
+  unload: function JsonStore_unload(reason) {
+    timer.clearInterval(this.writeTimer);
+    this.writeTimer = null;
+
+    if (reason === "uninstall")
+      this.purge();
+    else
+      this._write();
+  },
+
+  // True if the root is an empty object.
+  get _isEmpty() {
+    if (this.root && typeof(this.root) === "object") {
+      let empty = true;
+      for (let key in this.root) {
+        empty = false;
+        break;
+      }
+      return empty;
+    }
+    return false;
+  },
+
+  // Writes the root to the backing file, notifying write observers when
+  // complete.  If the store is over quota or if it's empty and the store has
+  // never been written, nothing is written and write observers aren't notified.
+  _write: function JsonStore__write() {
+    // Don't write if the root is uninitialized or if the store is empty and the
+    // backing file doesn't yet exist.
+    if (!this.isRootInited || (this._isEmpty && !file.exists(this.filename)))
+      return;
+
+    // If the store is over quota, don't write.  The current under-quota state
+    // should persist.
+    if (this.quotaUsage > 1)
+      return;
+
+    // Finally, write.
+    let stream = file.open(this.filename, "w");
+    try {
+      stream.writeAsync(JSON.stringify(this.root), function writeAsync(err) {
+        if (err)
+          console.error("Error writing simple storage file: " + this.filename);
+        else if (this.onWrite)
+          this.onWrite(this);
+      }.bind(this));
+    }
+    catch (err) {
+      // writeAsync closes the stream after it's done, so only close on error.
+      stream.close();
+    }
+  }
+};
+
+
+// This manages a JsonStore singleton and tailors its use to simple storage.
+// The root of the JsonStore is lazy-loaded:  The backing file is only read the
+// first time the root's gotten.
+var manager = ({
+  jsonStore: null,
+
+  // The filename of the store, based on the profile dir and extension ID.
+  get filename() {
+    let storeFile = Cc["@mozilla.org/file/directory_service;1"].
+                    getService(Ci.nsIProperties).
+                    get("ProfD", Ci.nsIFile);
+    storeFile.append(JETPACK_DIR_BASENAME);
+    storeFile.append(jpSelf.id);
+    storeFile.append("simple-storage");
+    file.mkpath(storeFile.path);
+    storeFile.append("store.json");
+    return storeFile.path;
+  },
+
+  get quotaUsage() {
+    return this.jsonStore.quotaUsage;
+  },
+
+  get root() {
+    if (!this.jsonStore.isRootInited)
+      this.jsonStore.read();
+    return this.jsonStore.root;
+  },
+
+  set root(val) {
+    return this.jsonStore.root = val;
+  },
+
+  unload: function manager_unload() {
+    off(this);
+  },
+
+  new: function manager_constructor() {
+    let manager = Object.create(this);
+    unload.ensure(manager);
+
+    manager.jsonStore = new JsonStore({
+      filename: manager.filename,
+      writePeriod: prefs.get(WRITE_PERIOD_PREF, WRITE_PERIOD_DEFAULT),
+      quota: prefs.get(QUOTA_PREF, QUOTA_DEFAULT),
+      onOverQuota: emit.bind(null, exports, "OverQuota")
+    });
+
+    return manager;
+  }
+}).new();
+
+exports.on = on.bind(null, exports);
+exports.removeListener = function(type, listener) {
+  off(exports, type, listener);
+};
diff --git a/toolkit/jetpack/sdk/stylesheet/style.js b/toolkit/jetpack/sdk/stylesheet/style.js
new file mode 100644
index 000000000..7ec0787e1
--- /dev/null
+++ b/toolkit/jetpack/sdk/stylesheet/style.js
@@ -0,0 +1,71 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci } = require("chrome");
+const { Class } = require("../core/heritage");
+const { URL, isLocalURL } = require('../url');
+const events = require("../system/events");
+const { loadSheet, removeSheet, isTypeValid } = require("./utils");
+const { isString } = require("../lang/type");
+const { attachTo, detachFrom } = require("../content/mod");
+const { data } = require('../self');
+
+const { freeze, create } = Object;
+
+function Style({ source, uri, type }) {
+  source = source == null ? null : freeze([].concat(source));
+  uri = uri == null ? null : freeze([].concat(uri));
+  type = type == null ? "author" : type;
+
+  if (source && !source.every(isString))
+    throw new Error('Style.source must be a string or an array of strings.');
+
+  if (uri && !uri.every(isLocalURL))
+    throw new Error('Style.uri must be a local URL or an array of local URLs');
+
+  if (type && !isTypeValid(type))
+    throw new Error('Style.type must be "agent", "user" or "author"');
+
+  return freeze(create(Style.prototype, {
+    "source": { value: source, enumerable: true },
+    "uri": { value: uri, enumerable: true },
+    "type": { value: type, enumerable: true }
+  }));
+};
+
+exports.Style = Style;
+
+attachTo.define(Style, function (style, window) {
+  if (style.uri) {
+    for (let uri of style.uri)
+      loadSheet(window, data.url(uri), style.type);
+  }
+
+  if (style.source) {
+    let uri = "data:text/css;charset=utf-8,";
+
+    uri += encodeURIComponent(style.source.join(""));
+
+    loadSheet(window, uri, style.type);
+  }
+});
+
+detachFrom.define(Style, function (style, window) {
+  if (style.uri)
+    for (let uri of style.uri)
+      removeSheet(window, data.url(uri));
+
+  if (style.source) {
+    let uri = "data:text/css;charset=utf-8,";
+
+    uri += encodeURIComponent(style.source.join(""));
+
+    removeSheet(window, uri, style.type);
+  }
+});
diff --git a/toolkit/jetpack/sdk/stylesheet/utils.js b/toolkit/jetpack/sdk/stylesheet/utils.js
new file mode 100644
index 000000000..844996bf3
--- /dev/null
+++ b/toolkit/jetpack/sdk/stylesheet/utils.js
@@ -0,0 +1,75 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata =  {
+  "stability": "experimental"
+};
+
+const { Ci } = require("chrome");
+
+const SHEET_TYPE = {
+  "agent": "AGENT_SHEET",
+  "user": "USER_SHEET",
+  "author": "AUTHOR_SHEET"
+};
+
+function getDOMWindowUtils(window) {
+  return window.QueryInterface(Ci.nsIInterfaceRequestor).
+                getInterface(Ci.nsIDOMWindowUtils);
+};
+
+/**
+ * Synchronously loads a style sheet from `uri` and adds it to the list of
+ * additional style sheets of the document.
+ * The sheets added takes effect immediately, and only on the document of the
+ * `window` given.
+ */
+function loadSheet(window, url, type) {
+  if (!(type && type in SHEET_TYPE))
+    type = "author";
+
+  type = SHEET_TYPE[type];
+
+  if (url instanceof Ci.nsIURI)
+    url = url.spec;
+
+  let winUtils = getDOMWindowUtils(window);
+  try {
+    winUtils.loadSheetUsingURIString(url, winUtils[type]);
+  }
+  catch (e) {};
+};
+exports.loadSheet = loadSheet;
+
+/**
+ * Remove the document style sheet at `sheetURI` from the list of additional
+ * style sheets of the document.  The removal takes effect immediately.
+ */
+function removeSheet(window, url, type) {
+  if (!(type && type in SHEET_TYPE))
+    type = "author";
+
+  type = SHEET_TYPE[type];
+
+  if (url instanceof Ci.nsIURI)
+    url = url.spec;
+
+  let winUtils = getDOMWindowUtils(window);
+
+  try {
+    winUtils.removeSheetUsingURIString(url, winUtils[type]);
+  }
+  catch (e) {};
+};
+exports.removeSheet = removeSheet;
+
+/**
+ * Returns `true` if the `type` given is valid, otherwise `false`.
+ * The values currently accepted are: "agent", "user" and "author".
+ */
+function isTypeValid(type) {
+  return type in SHEET_TYPE;
+}
+exports.isTypeValid = isTypeValid;
diff --git a/toolkit/jetpack/sdk/system.js b/toolkit/jetpack/sdk/system.js
new file mode 100644
index 000000000..1acfe8c8c
--- /dev/null
+++ b/toolkit/jetpack/sdk/system.js
@@ -0,0 +1,172 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci, CC } = require('chrome');
+const options = require('@loader/options');
+const runtime = require("./system/runtime");
+const { when: unload } = require("./system/unload");
+
+const appStartup = Cc['@mozilla.org/toolkit/app-startup;1'].
+                   getService(Ci.nsIAppStartup);
+const appInfo = Cc["@mozilla.org/xre/app-info;1"].
+                getService(Ci.nsIXULAppInfo);
+const directoryService = Cc['@mozilla.org/file/directory_service;1'].
+                         getService(Ci.nsIProperties);
+
+const PR_WRONLY = parseInt("0x02");
+const PR_CREATE_FILE = parseInt("0x08");
+const PR_APPEND = parseInt("0x10");
+const PR_TRUNCATE = parseInt("0x20");
+
+function openFile(path, mode) {
+  let file = Cc["@mozilla.org/file/local;1"].
+             createInstance(Ci.nsILocalFile);
+  file.initWithPath(path);
+  let stream = Cc["@mozilla.org/network/file-output-stream;1"].
+               createInstance(Ci.nsIFileOutputStream);
+  stream.init(file, mode, -1, 0);
+  return stream
+}
+
+const { eAttemptQuit: E_ATTEMPT, eForceQuit: E_FORCE } = appStartup;
+
+/**
+ * Parsed JSON object that was passed via `cfx --static-args "{ foo: 'bar' }"`
+ */
+exports.staticArgs = options.staticArgs;
+
+/**
+ * Environment variables. Environment variables are non-enumerable properties
+ * of this object (key is name and value is value).
+ */
+exports.env = require('./system/environment').env;
+
+/**
+ * Ends the process with the specified `code`. If omitted, exit uses the
+ * 'success' code 0. To exit with failure use `1`.
+ * TODO: Improve platform to actually quit with an exit code.
+ */
+var forcedExit = false;
+exports.exit = function exit(code) {
+  if (forcedExit) {
+    // a forced exit was already tried
+    // NOTE: exit(0) is called twice sometimes (ex when using cfx testaddons)
+    return;
+  }
+
+  let resultsFile = 'resultFile' in options && options.resultFile;
+  function unloader() {
+    if (!options.resultFile) {
+      return;
+    }
+
+    // This is used by 'cfx' to find out exit code.
+    let mode = PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE;
+    let stream = openFile(options.resultFile, mode);
+    let status = code ? 'FAIL' : 'OK';
+    stream.write(status, status.length);
+    stream.flush();
+    stream.close();
+    return;
+  }
+
+  if (code == 0) {
+    forcedExit = true;
+  }
+
+  // Bug 856999: Prevent automatic kill of Firefox when running tests
+  if (options.noQuit) {
+    return unload(unloader);
+  }
+
+  unloader();
+  appStartup.quit(code ? E_ATTEMPT : E_FORCE);
+};
+
+// Adapter for nodejs's stdout & stderr:
+// http://nodejs.org/api/process.html#process_process_stdout
+var stdout = Object.freeze({ write: dump, end: dump });
+exports.stdout = stdout;
+exports.stderr = stdout;
+
+/**
+ * Returns a path of the system's or application's special directory / file
+ * associated with a given `id`. For list of possible `id`s please see:
+ * https://developer.mozilla.org/en-US/docs/Code_snippets/File_I_O#Getting_files_in_special_directories
+ * http://dxr.mozilla.org/mozilla-central/source/xpcom/io/nsAppDirectoryServiceDefs.h
+ * @example
+ *
+ *    // get firefox profile path
+ *    let profilePath = require('system').pathFor('ProfD');
+ *    // get OS temp files directory (/tmp)
+ *    let temps = require('system').pathFor('TmpD');
+ *    // get OS desktop path for an active user (~/Desktop on linux
+ *    // or C:\Documents and Settings\username\Desktop on windows).
+ *    let desktopPath = require('system').pathFor('Desk');
+ */
+exports.pathFor = function pathFor(id) {
+  return directoryService.get(id, Ci.nsIFile).path;
+};
+
+/**
+ * What platform you're running on (all lower case string).
+ * For possible values see:
+ * https://developer.mozilla.org/en/OS_TARGET
+ */
+exports.platform = runtime.OS.toLowerCase();
+
+const [, architecture, compiler] = runtime.XPCOMABI ?
+                                   runtime.XPCOMABI.match(/^([^-]*)-(.*)$/) :
+                                   [, null, null];
+
+/**
+ * What processor architecture you're running on:
+ * `'arm', 'ia32', or 'x64'`.
+ */
+exports.architecture = architecture;
+
+/**
+ * What compiler used for build:
+ * `'msvc', 'n32', 'gcc2', 'gcc3', 'sunc', 'ibmc'...`
+ */
+exports.compiler = compiler;
+
+/**
+ * The application's build ID/date, for example "2004051604".
+ */
+exports.build = appInfo.appBuildID;
+
+/**
+ * The XUL application's UUID.
+ * This has traditionally been in the form
+ * `{AAAAAAAA-BBBB-CCCC-DDDD-EEEEEEEEEEEE}` but for some applications it may
+ * be: "appname@vendor.tld".
+ */
+exports.id = appInfo.ID;
+
+/**
+ * The name of the application.
+ */
+exports.name = appInfo.name;
+
+/**
+ * The XUL application's version, for example "0.8.0+" or "3.7a1pre".
+ */
+exports.version = appInfo.version;
+
+/**
+ * XULRunner version.
+ */
+exports.platformVersion = appInfo.platformVersion;
+
+
+/**
+ * The name of the application vendor, for example "Mozilla".
+ */
+exports.vendor = appInfo.vendor;
diff --git a/toolkit/jetpack/sdk/system/child_process.js b/toolkit/jetpack/sdk/system/child_process.js
new file mode 100644
index 000000000..8ea1f4f80
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/child_process.js
@@ -0,0 +1,332 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental'
+};
+
+var { Ci } = require('chrome');
+var subprocess = require('./child_process/subprocess');
+var { EventTarget } = require('../event/target');
+var { Stream } = require('../io/stream');
+var { on, emit, off } = require('../event/core');
+var { Class } = require('../core/heritage');
+var { platform } = require('../system');
+var { isFunction, isArray } = require('../lang/type');
+var { delay } = require('../lang/functional');
+var { merge } = require('../util/object');
+var { setTimeout, clearTimeout } = require('../timers');
+var isWindows = platform.indexOf('win') === 0;
+
+var processes = new WeakMap();
+
+
+/**
+ * The `Child` class wraps a subprocess command, exposes
+ * the stdio streams, and methods to manipulate the subprocess
+ */
+var Child = Class({
+  implements: [EventTarget],
+  initialize: function initialize (options) {
+    let child = this;
+    let proc;
+
+    this.killed = false;
+    this.exitCode = undefined;
+    this.signalCode = undefined;
+
+    this.stdin = Stream();
+    this.stdout = Stream();
+    this.stderr = Stream();
+
+    try {
+      proc = subprocess.call({
+        command: options.file,
+        arguments: options.cmdArgs,
+        environment: serializeEnv(options.env),
+        workdir: options.cwd,
+        charset: options.encoding,
+        stdout: data => emit(child.stdout, 'data', data),
+        stderr: data => emit(child.stderr, 'data', data),
+        stdin: stream => {
+          child.stdin.on('data', pumpStdin);
+          child.stdin.on('end', function closeStdin () {
+            child.stdin.off('data', pumpStdin);
+            child.stdin.off('end', closeStdin);
+            stream.close();
+          });
+          function pumpStdin (data) {
+            stream.write(data);
+          }
+        },
+        done: function (result, error) {
+          if (error)
+            return handleError(error);
+
+          // Only emit if child is not killed; otherwise,
+          // the `kill` method will handle this
+          if (!child.killed) {
+            child.exitCode = result.exitCode;
+            child.signalCode = null;
+
+            // If process exits with < 0, there was an error
+            if (child.exitCode < 0) {
+              handleError(new Error('Process exited with exit code ' + child.exitCode));
+            }
+            else {
+              // Also do 'exit' event as there's not much of
+              // a difference in our implementation as we're not using
+              // node streams
+              emit(child, 'exit', child.exitCode, child.signalCode);
+            }
+
+            // Emit 'close' event with exit code and signal,
+            // which is `null`, as it was not a killed process
+            emit(child, 'close', child.exitCode, child.signalCode);
+          }
+        }
+      });
+      processes.set(child, proc);
+    } catch (e) {
+      // Delay the error handling so an error handler can be set
+      // during the same tick that the Child was created
+      delay(() => handleError(e));
+    }
+
+    // `handleError` is called when process could not even
+    // be spawned
+    function handleError (e) {
+      // If error is an nsIObject, make a fresh error object
+      // so we're not exposing nsIObjects, and we can modify it
+      // with additional process information, like node
+      let error = e;
+      if (e instanceof Ci.nsISupports) {
+        error = new Error(e.message, e.filename, e.lineNumber);
+      }
+      emit(child, 'error', error);
+      child.exitCode = -1;
+      child.signalCode = null;
+      emit(child, 'close', child.exitCode, child.signalCode);
+    }
+  },
+  kill: function kill (signal) {
+    let proc = processes.get(this);
+    proc.kill(signal);
+    this.killed = true;
+    this.exitCode = null;
+    this.signalCode = signal;
+    emit(this, 'exit', this.exitCode, this.signalCode);
+    emit(this, 'close', this.exitCode, this.signalCode);
+  },
+  get pid() { return processes.get(this, {}).pid || -1; }
+});
+
+function spawn (file, ...args) {
+  let cmdArgs = [];
+  // Default options
+  let options = {
+    cwd: null,
+    env: null,
+    encoding: 'UTF-8'
+  };
+
+  if (args[1]) {
+    merge(options, args[1]);
+    cmdArgs = args[0];
+  }
+  else {
+    if (isArray(args[0]))
+      cmdArgs = args[0];
+    else
+      merge(options, args[0]);
+  }
+
+  if ('gid' in options)
+    console.warn('`gid` option is not yet supported for `child_process`');
+  if ('uid' in options)
+    console.warn('`uid` option is not yet supported for `child_process`');
+  if ('detached' in options)
+    console.warn('`detached` option is not yet supported for `child_process`');
+
+  options.file = file;
+  options.cmdArgs = cmdArgs;
+
+  return Child(options);
+}
+
+exports.spawn = spawn;
+
+/**
+ * exec(command, options, callback)
+ */
+function exec (cmd, ...args) {
+  let file, cmdArgs, callback, options = {};
+
+  if (isFunction(args[0]))
+    callback = args[0];
+  else {
+    merge(options, args[0]);
+    callback = args[1];
+  }
+
+  if (isWindows) {
+    file = 'C:\\Windows\\System32\\cmd.exe';
+    cmdArgs = ['/S/C', cmd || ''];
+  }
+  else {
+    file = '/bin/sh';
+    cmdArgs = ['-c', cmd];
+  }
+
+  // Undocumented option from node being able to specify shell
+  if (options && options.shell)
+    file = options.shell;
+
+  return execFile(file, cmdArgs, options, callback);
+}
+exports.exec = exec;
+/**
+ * execFile (file, args, options, callback)
+ */
+function execFile (file, ...args) {
+  let cmdArgs = [], callback;
+  // Default options
+  let options = {
+    cwd: null,
+    env: null,
+    encoding: 'utf8',
+    timeout: 0,
+    maxBuffer: 204800,    //200 KB (200*1024 bytes)
+    killSignal: 'SIGTERM'
+  };
+
+  if (isFunction(args[args.length - 1]))
+    callback = args[args.length - 1];
+
+  if (isArray(args[0])) {
+    cmdArgs = args[0];
+    merge(options, args[1]);
+  } else if (!isFunction(args[0]))
+    merge(options, args[0]);
+
+  let child = spawn(file, cmdArgs, options);
+  let exited = false;
+  let stdout = '';
+  let stderr = '';
+  let error = null;
+  let timeoutId = null;
+
+  child.stdout.setEncoding(options.encoding);
+  child.stderr.setEncoding(options.encoding);
+
+  on(child.stdout, 'data', pumpStdout);
+  on(child.stderr, 'data', pumpStderr);
+  on(child, 'close', exitHandler);
+  on(child, 'error', errorHandler);
+
+  if (options.timeout > 0) {
+    setTimeout(() => {
+      kill();
+      timeoutId = null;
+    }, options.timeout);
+  }
+
+  function exitHandler (code, signal) {
+
+    // Return if exitHandler called previously, occurs
+    // when multiple maxBuffer errors thrown and attempt to kill multiple
+    // times
+    if (exited) return;
+    exited = true;
+
+    if (!isFunction(callback)) return;
+
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+
+    if (!error && (code !== 0 || signal !== null))
+      error = createProcessError(new Error('Command failed: ' + stderr), {
+        code: code,
+        signal: signal,
+        killed: !!child.killed
+      });
+
+    callback(error, stdout, stderr);
+
+    off(child.stdout, 'data', pumpStdout);
+    off(child.stderr, 'data', pumpStderr);
+    off(child, 'close', exitHandler);
+    off(child, 'error', errorHandler);
+  }
+
+  function errorHandler (e) {
+    error = e;
+    exitHandler();
+  }
+
+  function kill () {
+    try {
+      child.kill(options.killSignal);
+    } catch (e) {
+      // In the scenario where the kill signal happens when
+      // the process is already closing, just abort the kill fail
+      if (/library is not open/.test(e))
+        return;
+      error = e;
+      exitHandler(-1, options.killSignal);
+    }
+  }
+
+  function pumpStdout (data) {
+    stdout += data;
+    if (stdout.length > options.maxBuffer) {
+      error = new Error('stdout maxBuffer exceeded');
+      kill();
+    }
+  }
+
+  function pumpStderr (data) {
+    stderr += data;
+    if (stderr.length > options.maxBuffer) {
+      error = new Error('stderr maxBuffer exceeded');
+      kill();
+    }
+  }
+
+  return child;
+}
+exports.execFile = execFile;
+
+exports.fork = function fork () {
+  throw new Error("child_process#fork is not currently supported");
+};
+
+function serializeEnv (obj) {
+  return Object.keys(obj || {}).map(prop => prop + '=' + obj[prop]);
+}
+
+function createProcessError (err, options = {}) {
+  // If code and signal look OK, this was probably a failure
+  // attempting to spawn the process (like ENOENT in node) -- use
+  // the code from the error message
+  if (!options.code && !options.signal) {
+    let match = err.message.match(/(NS_ERROR_\w*)/);
+    if (match && match.length > 1)
+      err.code = match[1];
+    else {
+      // If no good error message found, use the passed in exit code;
+      // this occurs when killing a process that's already closing,
+      // where we want both a valid exit code (0) and the error
+      err.code = options.code != null ? options.code : null;
+    }
+  }
+  else
+    err.code = options.code != null ? options.code : null;
+  err.signal = options.signal || null;
+  err.killed = options.killed || false;
+  return err;
+}
diff --git a/toolkit/jetpack/sdk/system/child_process/subprocess.js b/toolkit/jetpack/sdk/system/child_process/subprocess.js
new file mode 100644
index 000000000..e3454e95b
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/child_process/subprocess.js
@@ -0,0 +1,186 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+const { Ci, Cu } = require("chrome");
+
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Subprocess.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+
+const Runtime = require("sdk/system/runtime");
+const Environment = require("sdk/system/environment").env;
+const DEFAULT_ENVIRONMENT = [];
+if (Runtime.OS == "Linux" && "DISPLAY" in Environment) {
+  DEFAULT_ENVIRONMENT.push("DISPLAY=" + Environment.DISPLAY);
+}
+
+function awaitPromise(promise) {
+  let value;
+  let resolved = null;
+  promise.then(val => {
+    resolved = true;
+    value = val;
+  }, val => {
+    resolved = false;
+    value = val;
+  });
+
+  while (resolved === null)
+    Services.tm.mainThread.processNextEvent(true);
+
+  if (resolved === true)
+    return value;
+  throw value;
+}
+
+let readAllData = Task.async(function* (pipe, read, callback) {
+  let string;
+  while (string = yield read(pipe))
+    callback(string);
+});
+
+let write = (pipe, data) => {
+  let buffer = new Uint8Array(Array.from(data, c => c.charCodeAt(0)));
+  return pipe.write(data);
+};
+
+var subprocess = {
+  call: function(options) {
+    var result;
+
+    let procPromise = Task.spawn(function*() {
+      let opts = {};
+
+      if (options.mergeStderr) {
+        opts.stderr = "stdout"
+      } else if (options.stderr) {
+        opts.stderr = "pipe";
+      }
+
+      if (options.command instanceof Ci.nsIFile) {
+        opts.command = options.command.path;
+      } else {
+        opts.command = yield Subprocess.pathSearch(options.command);
+      }
+
+      if (options.workdir) {
+        opts.workdir = options.workdir;
+      }
+
+      opts.arguments = options.arguments || [];
+
+
+      // Set up environment
+
+      let envVars = options.environment || DEFAULT_ENVIRONMENT;
+      if (envVars.length) {
+        let environment = {};
+        for (let val of envVars) {
+          let idx = val.indexOf("=");
+          if (idx >= 0)
+            environment[val.slice(0, idx)] = val.slice(idx + 1);
+        }
+
+        opts.environment = environment;
+      }
+
+
+      let proc = yield Subprocess.call(opts);
+
+      Object.defineProperty(result, "pid", {
+        value: proc.pid,
+        enumerable: true,
+        configurable: true,
+      });
+
+
+      let promises = [];
+
+      // Set up IO handlers.
+
+      let read = pipe => pipe.readString();
+      if (options.charset === null) {
+        read = pipe => {
+          return pipe.read().then(buffer => {
+            return String.fromCharCode(...buffer);
+          });
+        };
+      }
+
+      if (options.stdout)
+        promises.push(readAllData(proc.stdout, read, options.stdout));
+
+      if (options.stderr && proc.stderr)
+        promises.push(readAllData(proc.stderr, read, options.stderr));
+
+      // Process stdin
+
+      if (typeof options.stdin === "string") {
+        write(proc.stdin, options.stdin);
+        proc.stdin.close();
+      }
+
+
+      // Handle process completion
+
+      if (options.done)
+        Promise.all(promises)
+          .then(() => proc.wait())
+          .then(options.done);
+
+      return proc;
+    });
+
+    procPromise.catch(e => {
+      if (options.done)
+        options.done({exitCode: -1}, e);
+      else
+        Cu.reportError(e instanceof Error ? e : e.message || e);
+    });
+
+    if (typeof options.stdin === "function") {
+      // Unfortunately, some callers (child_process.js) depend on this
+      // being called synchronously.
+      options.stdin({
+        write(val) {
+          procPromise.then(proc => {
+            write(proc.stdin, val);
+          });
+        },
+
+        close() {
+          procPromise.then(proc => {
+            proc.stdin.close();
+          });
+        },
+      });
+    }
+
+    result = {
+      get pid() {
+        return awaitPromise(procPromise.then(proc => {
+          return proc.pid;
+        }));
+      },
+
+      wait() {
+        return awaitPromise(procPromise.then(proc => {
+          return proc.wait().then(({exitCode}) => exitCode);
+        }));
+      },
+
+      kill(hard = false) {
+        procPromise.then(proc => {
+          proc.kill(hard ? 0 : undefined);
+        });
+      },
+    };
+
+    return result;
+  },
+};
+
+module.exports = subprocess;
diff --git a/toolkit/jetpack/sdk/system/environment.js b/toolkit/jetpack/sdk/system/environment.js
new file mode 100644
index 000000000..13621a696
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/environment.js
@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { Cc, Ci } = require('chrome');
+const { get, set, exists } = Cc['@mozilla.org/process/environment;1'].
+                             getService(Ci.nsIEnvironment);
+
+exports.env = new Proxy({}, {
+  deleteProperty(target, property) {
+    set(property, null);
+    return true;
+  },
+
+  get(target, property, receiver) {
+    return get(property) || undefined;
+  },
+
+  has(target, property) {
+    return exists(property);
+  },
+
+  set(target, property, value, receiver) {
+    set(property, value);
+    return true;
+  }
+});
diff --git a/toolkit/jetpack/sdk/system/events-shimmed.js b/toolkit/jetpack/sdk/system/events-shimmed.js
new file mode 100644
index 000000000..14496f1f0
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/events-shimmed.js
@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+const events = require('./events.js');
+
+exports.emit = (type, event) => events.emit(type, event, true);
+exports.on = (type, listener, strong) => events.on(type, listener, strong, true);
+exports.once = (type, listener) => events.once(type, listener, true);
+exports.off = (type, listener) => events.off(type, listener, true);
diff --git a/toolkit/jetpack/sdk/system/events.js b/toolkit/jetpack/sdk/system/events.js
new file mode 100644
index 000000000..0cf525aa1
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/events.js
@@ -0,0 +1,181 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+const { Cc, Ci, Cu } = require('chrome');
+const { Unknown } = require('../platform/xpcom');
+const { Class } = require('../core/heritage');
+const { ns } = require('../core/namespace');
+const observerService =
+  Cc['@mozilla.org/observer-service;1'].getService(Ci.nsIObserverService);
+const { addObserver, removeObserver, notifyObservers } = observerService;
+const { ShimWaiver } = Cu.import("resource://gre/modules/ShimWaiver.jsm");
+const addObserverNoShim = ShimWaiver.getProperty(observerService, "addObserver");
+const removeObserverNoShim = ShimWaiver.getProperty(observerService, "removeObserver");
+const notifyObserversNoShim = ShimWaiver.getProperty(observerService, "notifyObservers");
+const unloadSubject = require('@loader/unload');
+
+const Subject = Class({
+  extends: Unknown,
+  initialize: function initialize(object) {
+    // Double-wrap the object and set a property identifying the
+    // wrappedJSObject as one of our wrappers to distinguish between
+    // subjects that are one of our wrappers (which we should unwrap
+    // when notifying our observers) and those that are real JS XPCOM
+    // components (which we should pass through unaltered).
+    this.wrappedJSObject = {
+      observersModuleSubjectWrapper: true,
+      object: object
+    };
+  },
+  getScriptableHelper: function() {},
+  getInterfaces: function() {}
+});
+
+function emit(type, event, shimmed = false) {
+  // From bug 910599
+  // We must test to see if 'subject' or 'data' is a defined property
+  // of the event object, but also allow primitives to be passed in,
+  // which the `in` operator breaks, yet `null` is an object, hence
+  // the long conditional
+  let subject = event && typeof event === 'object' && 'subject' in event ?
+    Subject(event.subject) :
+    null;
+  let data = event && typeof event === 'object' ?
+    // An object either returns its `data` property or null
+    ('data' in event ? event.data : null) :
+    // All other types return themselves (and cast to strings/null
+    // via observer service)
+    event;
+  if (shimmed) {
+    notifyObservers(subject, type, data);
+  } else {
+    notifyObserversNoShim(subject, type, data);
+  }
+}
+exports.emit = emit;
+
+const Observer = Class({
+  extends: Unknown,
+  initialize: function initialize(listener) {
+    this.listener = listener;
+  },
+  interfaces: [ 'nsIObserver', 'nsISupportsWeakReference' ],
+  observe: function(subject, topic, data) {
+    // Extract the wrapped object for subjects that are one of our
+    // wrappers around a JS object.  This way we support both wrapped
+    // subjects created using this module and those that are real
+    // XPCOM components.
+    if (subject && typeof(subject) == 'object' &&
+        ('wrappedJSObject' in subject) &&
+        ('observersModuleSubjectWrapper' in subject.wrappedJSObject))
+      subject = subject.wrappedJSObject.object;
+
+    try {
+      this.listener({
+        type: topic,
+        subject: subject,
+        data: data
+      });
+    }
+    catch (error) {
+      console.exception(error);
+    }
+  }
+});
+
+const subscribers = ns();
+
+function on(type, listener, strong, shimmed = false) {
+  // Unless last optional argument is `true` we use a weak reference to a
+  // listener.
+  let weak = !strong;
+  // Take list of observers associated with given `listener` function.
+  let observers = subscribers(listener);
+  // If `observer` for the given `type` is not registered yet, then
+  // associate an `observer` and register it.
+  if (!(type in observers)) {
+    let observer = Observer(listener);
+    observers[type] = observer;
+    if (shimmed) {
+      addObserver(observer, type, weak);
+    } else {
+      addObserverNoShim(observer, type, weak);
+    }
+    // WeakRef gymnastics to remove all alive observers on unload
+    let ref = Cu.getWeakReference(observer);
+    weakRefs.set(observer, ref);
+    stillAlive.set(ref, type);
+    wasShimmed.set(ref, shimmed);
+  }
+}
+exports.on = on;
+
+function once(type, listener, shimmed = false) {
+  // Note: this code assumes order in which listeners are called, which is fine
+  // as long as dispatch happens in same order as listener registration which
+  // is the case now. That being said we should be aware that this may break
+  // in a future if order will change.
+  on(type, listener, shimmed);
+  on(type, function cleanup() {
+    off(type, listener, shimmed);
+    off(type, cleanup, shimmed);
+  }, true, shimmed);
+}
+exports.once = once;
+
+function off(type, listener, shimmed = false) {
+  // Take list of observers as with the given `listener`.
+  let observers = subscribers(listener);
+  // If `observer` for the given `type` is registered, then
+  // remove it & unregister.
+  if (type in observers) {
+    let observer = observers[type];
+    delete observers[type];
+    if (shimmed) {
+      removeObserver(observer, type);
+    } else {
+      removeObserverNoShim(observer, type);
+    }
+    stillAlive.delete(weakRefs.get(observer));
+    wasShimmed.delete(weakRefs.get(observer));
+  }
+}
+exports.off = off;
+
+// must use WeakMap to keep reference to all the WeakRefs (!), see bug 986115
+var weakRefs = new WeakMap();
+
+// and we're out of beta, we're releasing on time!
+var stillAlive = new Map();
+
+var wasShimmed = new Map();
+
+on('sdk:loader:destroy', function onunload({ subject, data: reason }) {
+  // using logic from ./unload, to avoid a circular module reference
+  if (subject.wrappedJSObject === unloadSubject) {
+    off('sdk:loader:destroy', onunload, false);
+
+    // don't bother
+    if (reason === 'shutdown') 
+      return;
+
+    stillAlive.forEach( (type, ref) => {
+      let observer = ref.get();
+      if (observer) {
+        if (wasShimmed.get(ref)) {
+          removeObserver(observer, type);
+        } else {
+          removeObserverNoShim(observer, type);
+        }
+      }
+    })
+  }
+  // a strong reference
+}, true, false);
diff --git a/toolkit/jetpack/sdk/system/globals.js b/toolkit/jetpack/sdk/system/globals.js
new file mode 100644
index 000000000..a1a6cf9a2
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/globals.js
@@ -0,0 +1,46 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+var { Cc, Ci, CC } = require('chrome');
+var { PlainTextConsole } = require('../console/plain-text');
+var { stdout } = require('../system');
+var ScriptError = CC('@mozilla.org/scripterror;1', 'nsIScriptError');
+var consoleService = Cc['@mozilla.org/consoleservice;1'].getService(Ci.nsIConsoleService);
+
+// On windows dump does not writes into stdout so cfx can't read thous dumps.
+// To workaround this issue we write to a special file from which cfx will
+// read and print to the console.
+// For more details see: bug-673383
+exports.dump = stdout.write;
+
+exports.console = new PlainTextConsole();
+
+// Provide CommonJS `define` to allow authoring modules in a format that can be
+// loaded both into jetpack and into browser via AMD loaders.
+Object.defineProperty(exports, 'define', {
+  // `define` is provided as a lazy getter that binds below defined `define`
+  // function to the module scope, so that require, exports and module
+  // variables remain accessible.
+  configurable: true,
+  get: function() {
+    let sandbox = this;
+    return function define(factory) {
+      factory = Array.slice(arguments).pop();
+      factory.call(sandbox, sandbox.require, sandbox.exports, sandbox.module);
+    }
+  },
+  set: function(value) {
+    Object.defineProperty(this, 'define', {
+      configurable: true,
+      enumerable: true,
+      value,
+    });
+  },
+});
diff --git a/toolkit/jetpack/sdk/system/process.js b/toolkit/jetpack/sdk/system/process.js
new file mode 100644
index 000000000..f44a36658
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/process.js
@@ -0,0 +1,62 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const {
+  exit, version, stdout, stderr, platform, architecture
+} = require("../system");
+
+/**
+ * Supported
+ */
+
+exports.stdout = stdout;
+exports.stderr = stderr;
+exports.version = version;
+exports.versions = {};
+exports.config = {};
+exports.arch = architecture;
+exports.platform = platform;
+exports.exit = exit;
+
+/**
+ * Partial support
+ */
+
+// An alias to `setTimeout(fn, 0)`, which isn't the same as node's `nextTick`,
+// but atleast ensures it'll occur asynchronously
+exports.nextTick = (callback) => setTimeout(callback, 0);
+
+/**
+ * Unsupported
+ */
+
+exports.maxTickDepth = 1000;
+exports.pid = 0;
+exports.title = "";
+exports.stdin = {};
+exports.argv = [];
+exports.execPath = "";
+exports.execArgv = [];
+exports.abort = function () {};
+exports.chdir = function () {};
+exports.cwd = function () {};
+exports.env = {};
+exports.getgid = function () {};
+exports.setgid = function () {};
+exports.getuid = function () {};
+exports.setuid = function () {};
+exports.getgroups = function () {};
+exports.setgroups = function () {};
+exports.initgroups = function () {};
+exports.kill = function () {};
+exports.memoryUsage = function () {};
+exports.umask = function () {};
+exports.uptime = function () {};
+exports.hrtime = function () {};
diff --git a/toolkit/jetpack/sdk/system/runtime.js b/toolkit/jetpack/sdk/system/runtime.js
new file mode 100644
index 000000000..9a70f142d
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/runtime.js
@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci } = require("chrome");
+const runtime = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULRuntime);
+
+exports.inSafeMode = runtime.inSafeMode;
+exports.OS = runtime.OS;
+exports.processType = runtime.processType;
+exports.widgetToolkit = runtime.widgetToolkit;
+exports.processID = runtime.processID;
+
+// Attempt to access `XPCOMABI` may throw exception, in which case exported
+// `XPCOMABI` will be set to `null`.
+// https://mxr.mozilla.org/mozilla-central/source/toolkit/xre/nsAppRunner.cpp#732
+try {
+  exports.XPCOMABI = runtime.XPCOMABI;
+}
+catch (error) {
+  exports.XPCOMABI = null;
+}
diff --git a/toolkit/jetpack/sdk/system/unload.js b/toolkit/jetpack/sdk/system/unload.js
new file mode 100644
index 000000000..98ab5f8f3
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/unload.js
@@ -0,0 +1,104 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Parts of this module were taken from narwhal:
+//
+// http://narwhaljs.org
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cu } = require('chrome');
+const { on, off } = require('./events');
+const unloadSubject = require('@loader/unload');
+
+const observers = [];
+const unloaders = [];
+
+function WeakObserver(inner) {
+  this._inner = Cu.getWeakReference(inner);
+}
+
+Object.defineProperty(WeakObserver.prototype, 'value', {
+  get: function() { this._inner.get() }
+});
+
+var when = exports.when = function when(observer, opts) {
+  opts = opts || {};
+  for (var i = 0; i < observers.length; ++i) {
+    if (observers[i] === observer || observers[i].value === observer) {
+      return;
+    }
+  }
+  if (opts.weak) {
+    observers.unshift(new WeakObserver(observer));
+  } else {
+    observers.unshift(observer);
+  }
+};
+
+var ensure = exports.ensure = function ensure(obj, destructorName) {
+  if (!destructorName)
+    destructorName = "unload";
+  if (!(destructorName in obj))
+    throw new Error("object has no '" + destructorName + "' property");
+
+  let called = false;
+  let originalDestructor = obj[destructorName];
+
+  function unloadWrapper(reason) {
+    if (!called) {
+      called = true;
+      let index = unloaders.indexOf(unloadWrapper);
+      if (index == -1)
+        throw new Error("internal error: unloader not found");
+      unloaders.splice(index, 1);
+      originalDestructor.call(obj, reason);
+      originalDestructor = null;
+      destructorName = null;
+      obj = null;
+    }
+  };
+
+  // TODO: Find out why the order is inverted here. It seems that
+  // it may be causing issues!
+  unloaders.push(unloadWrapper);
+
+  obj[destructorName] = unloadWrapper;
+};
+
+function unload(reason) {
+  observers.forEach(function(observer) {
+    try {
+      if (observer instanceof WeakObserver) {
+        observer = observer.value;
+      }
+      if (typeof observer === 'function') {
+        observer(reason);
+      }
+    }
+    catch (error) {
+      console.exception(error);
+    }
+  });
+}
+
+when(function(reason) {
+  unloaders.slice().forEach(function(unloadWrapper) {
+    unloadWrapper(reason);
+  });
+});
+
+on('sdk:loader:destroy', function onunload({ subject, data: reason }) {
+  // If this loader is unload then `subject.wrappedJSObject` will be
+  // `destructor`.
+  if (subject.wrappedJSObject === unloadSubject) {
+    off('sdk:loader:destroy', onunload);
+    unload(reason);
+  }
+// Note that we use strong reference to listener here to make sure it's not
+// GC-ed, which may happen otherwise since nothing keeps reference to `onunolad`
+// function.
+}, true);
diff --git a/toolkit/jetpack/sdk/system/xul-app.js b/toolkit/jetpack/sdk/system/xul-app.js
new file mode 100644
index 000000000..612386f77
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/xul-app.js
@@ -0,0 +1,12 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { XulApp } = require("./xul-app.jsm");
+
+Object.keys(XulApp).forEach(k => exports[k] = XulApp[k]);
diff --git a/toolkit/jetpack/sdk/system/xul-app.jsm b/toolkit/jetpack/sdk/system/xul-app.jsm
new file mode 100644
index 000000000..90681bb1b
--- /dev/null
+++ b/toolkit/jetpack/sdk/system/xul-app.jsm
@@ -0,0 +1,242 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+this.EXPORTED_SYMBOLS = [ "XulApp" ];
+
+var { classes: Cc, interfaces: Ci } = Components;
+
+var exports = {};
+this.XulApp = exports;
+
+var appInfo;
+
+// NOTE: below is required to avoid failing xpcshell tests,
+//       which do not implement nsIXULAppInfo
+// See Bug 1114752 https://bugzilla.mozilla.org/show_bug.cgi?id=1114752
+try {
+ appInfo = Cc["@mozilla.org/xre/app-info;1"]
+              .getService(Ci.nsIXULAppInfo);
+}
+catch (e) {
+  // xpcshell test case
+  appInfo = {};
+}
+var vc = Cc["@mozilla.org/xpcom/version-comparator;1"]
+         .getService(Ci.nsIVersionComparator);
+
+var ID = exports.ID = appInfo.ID;
+var name = exports.name = appInfo.name;
+var version = exports.version = appInfo.version;
+var platformVersion = exports.platformVersion = appInfo.platformVersion;
+
+// The following mapping of application names to GUIDs was taken from:
+//
+//   https://addons.mozilla.org/en-US/firefox/pages/appversions
+//
+// Using the GUID instead of the app's name is preferable because sometimes
+// re-branded versions of a product have different names: for instance,
+// Firefox, Minefield, Iceweasel, and Shiretoko all have the same
+// GUID.
+
+var ids = exports.ids = {
+  Firefox: "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}",
+  Mozilla: "{86c18b42-e466-45a9-ae7a-9b95ba6f5640}",
+  SeaMonkey: "{92650c4d-4b8e-4d2a-b7eb-24ecf4f6b63a}",
+  Fennec: "{aa3c5121-dab2-40e2-81ca-7ea25febc110}",
+  Thunderbird: "{3550f703-e582-4d05-9a08-453d09bdfdc6}",
+  Instantbird: "{33cb9019-c295-46dd-be21-8c4936574bee}"
+};
+
+function is(name) {
+  if (!(name in ids))
+    throw new Error("Unkown Mozilla Application: " + name);
+  return ID == ids[name];
+};
+exports.is = is;
+
+function isOneOf(names) {
+  for (var i = 0; i < names.length; i++)
+    if (is(names[i]))
+      return true;
+  return false;
+};
+exports.isOneOf = isOneOf;
+
+/**
+ * Use this to check whether the given version (e.g. xulApp.platformVersion)
+ * is in the given range. Versions must be in version comparator-compatible
+ * format. See MDC for details:
+ * https://developer.mozilla.org/en/XPCOM_Interface_Reference/nsIVersionComparator
+ */
+var versionInRange = exports.versionInRange =
+function versionInRange(version, lowInclusive, highExclusive) {
+  return (vc.compare(version, lowInclusive) >= 0) &&
+         (vc.compare(version, highExclusive) < 0);
+}
+
+const reVersionRange = /^((?:<|>)?=?)?\s*((?:\d+[\S]*)|\*)(?:\s+((?:<|>)=?)?(\d+[\S]+))?$/;
+const reOnlyInifinity = /^[<>]?=?\s*[*x]$/;
+const reSubInfinity = /\.[*x]/g;
+const reHyphenRange = /^(\d+.*?)\s*-\s*(\d+.*?)$/;
+const reRangeSeparator = /\s*\|\|\s*/;
+
+const compares = {
+  "=": function (c) { return c === 0 },
+  ">=": function (c) { return c >= 0 },
+  "<=": function (c) { return c <= 0},
+  "<": function (c) { return c < 0 },
+  ">": function (c) { return c > 0 }
+}
+
+function normalizeRange(range) {
+    return range
+        .replace(reOnlyInifinity, "")
+        .replace(reSubInfinity, ".*")
+        .replace(reHyphenRange, ">=$1 <=$2")
+}
+
+/**
+ * Compare the versions given, using the comparison operator provided.
+ * Internal use only.
+ *
+ * @example
+ *  compareVersion("1.2", "<=", "1.*") // true
+ *
+ * @param {String} version
+ *  A version to compare
+ *
+ * @param {String} comparison
+ *  The comparison operator
+ *
+ * @param {String} compareVersion
+ *  A version to compare
+ */
+function compareVersion(version, comparison, compareVersion) {
+  let hasWildcard = compareVersion.indexOf("*") !== -1;
+
+  comparison = comparison || "=";
+
+  if (hasWildcard) {
+    switch (comparison) {
+      case "=":
+        let zeroVersion = compareVersion.replace(reSubInfinity, ".0");
+        return versionInRange(version, zeroVersion, compareVersion);
+      case ">=":
+        compareVersion = compareVersion.replace(reSubInfinity, ".0");
+        break;
+    }
+  }
+
+  let compare = compares[comparison];
+
+  return typeof compare === "function" && compare(vc.compare(version, compareVersion));
+}
+
+/**
+ * Returns `true` if `version` satisfies the `versionRange` given.
+ * If only an argument is passed, is used as `versionRange` and compared against
+ * `xulApp.platformVersion`.
+ *
+ * `versionRange` is either a string which has one or more space-separated
+ * descriptors, or a range like "fromVersion - toVersion".
+ * Version range descriptors may be any of the following styles:
+ *
+ * - "version" Must match `version` exactly
+ * - "=version" Same as just `version`
+ * - ">version" Must be greater than `version`
+ * - ">=version" Must be greater or equal than `version`
+ * - "<version" Must be less than `version`
+ * - "<=version" Must be less or equal than `version`
+ * - "1.2.x" or "1.2.*" See 'X version ranges' below
+ * - "*" or "" (just an empty string) Matches any version
+ * - "version1 - version2" Same as ">=version1 <=version2"
+ * - "range1 || range2" Passes if either `range1` or `range2` are satisfied
+ *
+ * For example, these are all valid:
+ * - "1.0.0 - 2.9999.9999"
+ * - ">=1.0.2 <2.1.2"
+ * - ">1.0.2 <=2.3.4"
+ * - "2.0.1"
+ * - "<1.0.0 || >=2.3.1 <2.4.5 || >=2.5.2 <3.0.0"
+ * - "2.x" (equivalent to "2.*")
+ * - "1.2.x" (equivalent to "1.2.*" and ">=1.2.0 <1.3.0")
+ */
+function satisfiesVersion(version, versionRange) {
+  if (arguments.length === 1) {
+    versionRange = version;
+    version = appInfo.version;
+  }
+
+  let ranges = versionRange.trim().split(reRangeSeparator);
+
+  return ranges.some(function(range) {
+    range = normalizeRange(range);
+
+    // No versions' range specified means that any version satisfies the
+    // requirements.
+    if (range === "")
+      return true;
+
+    let matches = range.match(reVersionRange);
+
+    if (!matches)
+      return false;
+
+    let [, lowMod, lowVer, highMod, highVer] = matches;
+
+    return compareVersion(version, lowMod, lowVer) && (highVer !== undefined
+      ? compareVersion(version, highMod, highVer)
+      : true);
+  });
+}
+exports.satisfiesVersion = satisfiesVersion;
+
+/**
+ * Ensure the current application satisfied the requirements specified in the
+ * module given. If not, an exception related to the incompatibility is
+ * returned; `null` otherwise.
+ *
+ * @param {Object} module
+ *  The module to check
+ * @returns {Error}
+ */
+function incompatibility(module) {
+  let { metadata, id } = module;
+
+  // if metadata or engines are not specified we assume compatibility is not
+  // an issue.
+  if (!metadata || !("engines" in metadata))
+    return null;
+
+  let { engines } = metadata;
+
+  if (engines === null || typeof(engines) !== "object")
+    return new Error("Malformed engines' property in metadata");
+
+  let applications = Object.keys(engines);
+
+  let versionRange;
+  applications.forEach(function(name) {
+    if (is(name)) {
+      versionRange = engines[name];
+      // Continue iteration. We want to ensure the module doesn't
+      // contain a typo in the applications' name or some unknown
+      // application - `is` function throws an exception in that case.
+    }
+  });
+
+  if (typeof(versionRange) === "string") {
+    if (satisfiesVersion(versionRange))
+      return null;
+
+    return new Error("Unsupported Application version: The module " + id +
+            " currently supports only version " + versionRange + " of " +
+            name + ".");
+  }
+
+  return new Error("Unsupported Application: The module " + id +
+            " currently supports only " + applications.join(", ") + ".")
+}
+exports.incompatibility = incompatibility;
diff --git a/toolkit/jetpack/sdk/tab/events.js b/toolkit/jetpack/sdk/tab/events.js
new file mode 100644
index 000000000..e431cc9d2
--- /dev/null
+++ b/toolkit/jetpack/sdk/tab/events.js
@@ -0,0 +1,74 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+// This module provides temporary shim until Bug 843901 is shipped.
+// It basically registers tab event listeners on all windows that get
+// opened and forwards them through observer notifications.
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Ci } = require("chrome");
+const { windows, isInteractive } = require("../window/utils");
+const { events } = require("../browser/events");
+const { open } = require("../event/dom");
+const { filter, map, merge, expand } = require("../event/utils");
+const isFennec = require("sdk/system/xul-app").is("Fennec");
+
+// Module provides event stream (in nodejs style) that emits data events
+// for all the tab events that happen in running firefox. At the moment
+// it does it by registering listeners on all browser windows and then
+// forwarding events when they occur to a stream. This will become obsolete
+// once Bug 843901 is fixed, and we'll just leverage observer notifications.
+
+// Set of tab events that this module going to aggregate and expose.
+const TYPES = ["TabOpen","TabClose","TabSelect","TabMove","TabPinned",
+               "TabUnpinned"];
+
+// Utility function that given a browser `window` returns stream of above
+// defined tab events for all tabs on the given window.
+function tabEventsFor(window) {
+  // Map supported event types to a streams of those events on the given
+  // `window` and than merge these streams into single form stream off
+  // all events.
+  let channels = TYPES.map(type => open(window, type));
+  return merge(channels);
+}
+
+// Create our event channels.  We do this in a separate function to
+// minimize the chance of leaking intermediate objects on the global.
+function makeEvents() {
+  // Filter DOMContentLoaded events from all the browser events.
+  var readyEvents = filter(events, e => e.type === "DOMContentLoaded");
+  // Map DOMContentLoaded events to it's target browser windows.
+  var futureWindows = map(readyEvents, e => e.target);
+  // Expand all browsers that will become interactive to supported tab events
+  // on these windows. Result will be a tab events from all tabs of all windows
+  // that will become interactive.
+  var eventsFromFuture = expand(futureWindows, tabEventsFor);
+
+  // Above covers only windows that will become interactive in a future, but some
+  // windows may already be interactive so we pick those and expand to supported
+  // tab events for them too.
+  var interactiveWindows = windows("navigator:browser", { includePrivate: true }).
+                           filter(isInteractive);
+  var eventsFromInteractive = merge(interactiveWindows.map(tabEventsFor));
+
+
+  // Finally merge stream of tab events from future windows and current windows
+  // to cover all tab events on all windows that will open.
+  return merge([eventsFromInteractive, eventsFromFuture]);
+}
+
+// Map events to Fennec format if necessary
+exports.events = map(makeEvents(), function (event) {
+  return !isFennec ? event : {
+    type: event.type,
+    target: event.target.ownerDocument.defaultView.BrowserApp
+            .getTabForBrowser(event.target)
+  };
+});
diff --git a/toolkit/jetpack/sdk/tabs.js b/toolkit/jetpack/sdk/tabs.js
new file mode 100644
index 000000000..f61cad478
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs.js
@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+if (require("./system/xul-app").is("Fennec")) {
+  module.exports = require("./windows/tabs-fennec").tabs;
+}
+else {
+  module.exports = require("./tabs/tabs-firefox");
+}
+
+const tabs = module.exports;
diff --git a/toolkit/jetpack/sdk/tabs/common.js b/toolkit/jetpack/sdk/tabs/common.js
new file mode 100644
index 000000000..9ee512a7b
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/common.js
@@ -0,0 +1,34 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { validateOptions } = require("../deprecated/api-utils");
+const { data } = require("../self");
+
+function Options(options) {
+  if ('string' === typeof options)
+    options = { url: options };
+
+  return validateOptions(options, {
+    url: {
+      is: ["string"],
+      map: (v) => v ? data.url(v) : v
+    },
+    inBackground: {
+      map: Boolean,
+      is: ["undefined", "boolean"]
+    },
+    isPinned: { is: ["undefined", "boolean"] },
+    isPrivate: { is: ["undefined", "boolean"] },
+    inNewWindow: { is: ["undefined", "boolean"] },
+    onOpen: { is: ["undefined", "function"] },
+    onClose: { is: ["undefined", "function"] },
+    onReady: { is: ["undefined", "function"] },
+    onLoad: { is: ["undefined", "function"] },
+    onPageShow: { is: ["undefined", "function"] },
+    onActivate: { is: ["undefined", "function"] },
+    onDeactivate: { is: ["undefined", "function"] }
+  });
+}
+exports.Options = Options;
diff --git a/toolkit/jetpack/sdk/tabs/events.js b/toolkit/jetpack/sdk/tabs/events.js
new file mode 100644
index 000000000..65650f9dc
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/events.js
@@ -0,0 +1,39 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const ON_PREFIX = "on";
+const TAB_PREFIX = "Tab";
+
+const EVENTS = {
+  ready: "DOMContentLoaded",
+  load: "load", // Used for non-HTML content
+  pageshow: "pageshow", // Used for cached content
+  open: "TabOpen",
+  close: "TabClose",
+  activate: "TabSelect",
+  deactivate: null,
+  pinned: "TabPinned",
+  unpinned: "TabUnpinned"
+}
+exports.EVENTS = EVENTS;
+
+Object.keys(EVENTS).forEach(function(name) {
+  EVENTS[name] = {
+    name: name,
+    listener: createListenerName(name),
+    dom: EVENTS[name]
+  }
+});
+
+function createListenerName (name) {
+  if (name === 'pageshow')
+    return 'onPageShow';
+  else
+    return ON_PREFIX + name.charAt(0).toUpperCase() + name.substr(1);
+}
diff --git a/toolkit/jetpack/sdk/tabs/helpers.js b/toolkit/jetpack/sdk/tabs/helpers.js
new file mode 100644
index 000000000..b2c8aa013
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/helpers.js
@@ -0,0 +1,22 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+
+// NOTE: This file should only export Tab instances
+
+
+const { getTabForBrowser: getRawTabForBrowser } = require('./utils');
+const { modelFor } = require('../model/core');
+
+exports.getTabForRawTab = modelFor;
+
+function getTabForBrowser(browser) {
+  return modelFor(getRawTabForBrowser(browser)) || null;
+}
+exports.getTabForBrowser = getTabForBrowser;
diff --git a/toolkit/jetpack/sdk/tabs/namespace.js b/toolkit/jetpack/sdk/tabs/namespace.js
new file mode 100644
index 000000000..3553b1a99
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/namespace.js
@@ -0,0 +1,10 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+var { ns } = require('../core/namespace');
+
+exports.tabsNS = ns();
+exports.tabNS = ns();
+exports.rawTabNS = ns();
diff --git a/toolkit/jetpack/sdk/tabs/observer.js b/toolkit/jetpack/sdk/tabs/observer.js
new file mode 100644
index 000000000..4e935cd62
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/observer.js
@@ -0,0 +1,113 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { EventTarget } = require("../event/target");
+const { emit } = require("../event/core");
+const { DOMEventAssembler } = require("../deprecated/events/assembler");
+const { Class } = require("../core/heritage");
+const { getActiveTab, getTabs } = require("./utils");
+const { browserWindowIterator } = require("../deprecated/window-utils");
+const { isBrowser, windows, getMostRecentBrowserWindow } = require("../window/utils");
+const { observer: windowObserver } = require("../windows/observer");
+const { when } = require("../system/unload");
+
+const EVENTS = {
+  "TabOpen": "open",
+  "TabClose": "close",
+  "TabSelect": "select",
+  "TabMove": "move",
+  "TabPinned": "pinned",
+  "TabUnpinned": "unpinned"
+};
+
+const selectedTab = Symbol("observer/state/selectedTab");
+
+// Event emitter objects used to register listeners and emit events on them
+// when they occur.
+const Observer = Class({
+  implements: [EventTarget, DOMEventAssembler],
+  initialize() {
+    this[selectedTab] = null;
+    // Currently Gecko does not dispatch any event on the previously selected
+    // tab before / after "TabSelect" is dispatched. In order to work around this
+    // limitation we keep track of selected tab and emit "deactivate" event with
+    // that before emitting "activate" on selected tab.
+    this.on("select", tab => {
+      const selected = this[selectedTab];
+      if (selected !== tab) {
+        if (selected) {
+          emit(this, 'deactivate', selected);
+        }
+
+        if (tab) {
+          this[selectedTab] = tab;
+          emit(this, 'activate', this[selectedTab]);
+        }
+      }
+    });
+
+
+    // We also observe opening / closing windows in order to add / remove it's
+    // containers to the observed list.
+    windowObserver.on("open", chromeWindow => {
+      if (isBrowser(chromeWindow)) {
+        this.observe(chromeWindow);
+      }
+    });
+
+    windowObserver.on("close", chromeWindow => {
+      if (isBrowser(chromeWindow)) {
+        // Bug 751546: Emit `deactivate` event on window close immediatly
+        // Otherwise we are going to face "dead object" exception on `select` event
+        if (getActiveTab(chromeWindow) === this[selectedTab]) {
+          emit(this, "deactivate", this[selectedTab]);
+          this[selectedTab] = null;
+        }
+        this.ignore(chromeWindow);
+      }
+    });
+
+
+    // Currently gecko does not dispatches "TabSelect" events when different
+    // window gets activated. To work around this limitation we emulate "select"
+    // event for this case.
+    windowObserver.on("activate", chromeWindow => {
+      if (isBrowser(chromeWindow)) {
+        emit(this, "select", getActiveTab(chromeWindow));
+      }
+    });
+
+    // We should synchronize state, since probably we already have at least one
+    // window open.
+    for (let chromeWindow of browserWindowIterator()) {
+      this.observe(chromeWindow);
+    }
+
+    when(_ => {
+      // Don't dispatch a deactivate event during unload.
+      this[selectedTab] = null;
+    });
+  },
+  /**
+   * Events that are supported and emitted by the module.
+   */
+  supportedEventsTypes: Object.keys(EVENTS),
+  /**
+   * Function handles all the supported events on all the windows that are
+   * observed. Method is used to proxy events to the listeners registered on
+   * this event emitter.
+   * @param {Event} event
+   *    Keyboard event being emitted.
+   */
+  handleEvent: function handleEvent(event) {
+    emit(this, EVENTS[event.type], event.target, event);
+  }
+});
+
+exports.observer = new Observer();
diff --git a/toolkit/jetpack/sdk/tabs/tab-fennec.js b/toolkit/jetpack/sdk/tabs/tab-fennec.js
new file mode 100644
index 000000000..3927337f6
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/tab-fennec.js
@@ -0,0 +1,249 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { Cc, Ci } = require('chrome');
+const { Class } = require('../core/heritage');
+const { tabNS, rawTabNS } = require('./namespace');
+const { EventTarget } = require('../event/target');
+const { activateTab, getTabTitle, setTabTitle, closeTab, getTabURL,
+        getTabContentWindow, getTabForBrowser, setTabURL, getOwnerWindow,
+        getTabContentDocument, getTabContentType, getTabId, isTab } = require('./utils');
+const { emit } = require('../event/core');
+const { isPrivate } = require('../private-browsing/utils');
+const { isWindowPrivate } = require('../window/utils');
+const { when: unload } = require('../system/unload');
+const { BLANK } = require('../content/thumbnail');
+const { viewFor } = require('../view/core');
+const { EVENTS } = require('./events');
+const { modelFor } = require('../model/core');
+
+const ERR_FENNEC_MSG = 'This method is not yet supported by Fennec';
+
+const Tab = Class({
+  extends: EventTarget,
+  initialize: function initialize(options) {
+    options = options.tab ? options : { tab: options };
+    let tab = options.tab;
+
+    EventTarget.prototype.initialize.call(this, options);
+    let tabInternals = tabNS(this);
+    rawTabNS(tab).tab = this;
+
+    let window = tabInternals.window = options.window || getOwnerWindow(tab);
+    tabInternals.tab = tab;
+
+    // TabReady
+    let onReady = tabInternals.onReady = onTabReady.bind(this);
+    tab.browser.addEventListener(EVENTS.ready.dom, onReady, false);
+
+    // TabPageShow
+    let onPageShow = tabInternals.onPageShow = onTabPageShow.bind(this);
+    tab.browser.addEventListener(EVENTS.pageshow.dom, onPageShow, false);
+
+    // TabLoad
+    let onLoad = tabInternals.onLoad = onTabLoad.bind(this);
+    tab.browser.addEventListener(EVENTS.load.dom, onLoad, true);
+
+    // TabClose
+    let onClose = tabInternals.onClose = onTabClose.bind(this);
+    window.BrowserApp.deck.addEventListener(EVENTS.close.dom, onClose, false);
+
+    unload(cleanupTab.bind(null, this));
+  },
+
+  /**
+   * The title of the page currently loaded in the tab.
+   * Changing this property changes an actual title.
+   * @type {String}
+   */
+  get title() {
+    return getTabTitle(tabNS(this).tab);
+  },
+  set title(title) {
+    setTabTitle(tabNS(this).tab, title);
+  },
+
+  /**
+   * Location of the page currently loaded in this tab.
+   * Changing this property will loads page under under the specified location.
+   * @type {String}
+   */
+  get url() {
+    return tabNS(this).closed ? undefined : getTabURL(tabNS(this).tab);
+  },
+  set url(url) {
+    setTabURL(tabNS(this).tab, url);
+  },
+
+  getThumbnail: function() {
+    // TODO: implement!
+    console.error(ERR_FENNEC_MSG);
+
+    // return 80x45 blank default
+    return BLANK;
+  },
+
+  /**
+   * tab's document readyState, or 'uninitialized' if it doesn't even exist yet.
+   */
+  get readyState() {
+    let doc = getTabContentDocument(tabNS(this).tab);
+    return doc && doc.readyState || 'uninitialized';
+  },
+
+  get id() {
+    return getTabId(tabNS(this).tab);
+  },
+
+  /**
+   * The index of the tab relative to other tabs in the application window.
+   * Changing this property will change order of the actual position of the tab.
+   * @type {Number}
+   */
+  get index() {
+    if (tabNS(this).closed) return undefined;
+
+    let tabs = tabNS(this).window.BrowserApp.tabs;
+    let tab = tabNS(this).tab;
+    for (var i = tabs.length; i >= 0; i--) {
+      if (tabs[i] === tab)
+        return i;
+    }
+    return null;
+  },
+  set index(value) {
+    console.error(ERR_FENNEC_MSG); // TODO
+  },
+
+  /**
+   * Whether or not tab is pinned (Is an app-tab).
+   * @type {Boolean}
+   */
+  get isPinned() {
+    console.error(ERR_FENNEC_MSG); // TODO
+    return false; // TODO
+  },
+  pin: function pin() {
+    console.error(ERR_FENNEC_MSG); // TODO
+  },
+  unpin: function unpin() {
+    console.error(ERR_FENNEC_MSG); // TODO
+  },
+
+  /**
+   * Returns the MIME type that the document loaded in the tab is being
+   * rendered as.
+   * @type {String}
+   */
+  get contentType() {
+    return getTabContentType(tabNS(this).tab);
+  },
+
+  /**
+   * Create a worker for this tab, first argument is options given to Worker.
+   * @type {Worker}
+   */
+  attach: function attach(options) {
+    // BUG 792946 https://bugzilla.mozilla.org/show_bug.cgi?id=792946
+    // TODO: fix this circular dependency
+    let { Worker } = require('./worker');
+    return Worker(options, getTabContentWindow(tabNS(this).tab));
+  },
+
+  /**
+   * Make this tab active.
+   */
+  activate: function activate() {
+    activateTab(tabNS(this).tab, tabNS(this).window);
+  },
+
+  /**
+   * Close the tab
+   */
+  close: function close(callback) {
+    let tab = this;
+    this.once(EVENTS.close.name, function () {
+      tabNS(tab).closed = true;
+      if (callback) callback();
+    });
+
+    closeTab(tabNS(this).tab);
+  },
+
+  /**
+   * Reload the tab
+   */
+  reload: function reload() {
+    tabNS(this).tab.browser.reload();
+  }
+});
+exports.Tab = Tab;
+
+// Implement `viewFor` polymorphic function for the Tab
+// instances.
+viewFor.define(Tab, x => tabNS(x).tab);
+
+function cleanupTab(tab) {
+  let tabInternals = tabNS(tab);
+  if (!tabInternals.tab)
+    return;
+
+  if (tabInternals.tab.browser) {
+    tabInternals.tab.browser.removeEventListener(EVENTS.ready.dom, tabInternals.onReady, false);
+    tabInternals.tab.browser.removeEventListener(EVENTS.pageshow.dom, tabInternals.onPageShow, false);
+    tabInternals.tab.browser.removeEventListener(EVENTS.load.dom, tabInternals.onLoad, true);
+  }
+  tabInternals.onReady = null;
+  tabInternals.onPageShow = null;
+  tabInternals.onLoad = null;
+  tabInternals.window.BrowserApp.deck.removeEventListener(EVENTS.close.dom, tabInternals.onClose, false);
+  tabInternals.onClose = null;
+  rawTabNS(tabInternals.tab).tab = null;
+  tabInternals.tab = null;
+  tabInternals.window = null;
+}
+
+function onTabReady(event) {
+  let win = event.target.defaultView;
+
+  // ignore frames
+  if (win === win.top) {
+    emit(this, 'ready', this);
+  }
+}
+
+function onTabLoad (event) {
+  let win = event.target.defaultView;
+
+  // ignore frames
+  if (win === win.top) {
+    emit(this, 'load', this);
+  }
+}
+
+function onTabPageShow(event) {
+  let win = event.target.defaultView;
+  if (win === win.top)
+    emit(this, 'pageshow', this, event.persisted);
+}
+
+// TabClose
+function onTabClose(event) {
+  let rawTab = getTabForBrowser(event.target);
+  if (tabNS(this).tab !== rawTab)
+    return;
+
+  emit(this, EVENTS.close.name, this);
+  cleanupTab(this);
+};
+
+isPrivate.implement(Tab, tab => {
+  return isWindowPrivate(getTabContentWindow(tabNS(tab).tab));
+});
+
+// Implement `modelFor` function for the Tab instances.
+modelFor.when(isTab, rawTab => {
+  return rawTabNS(rawTab).tab;
+});
diff --git a/toolkit/jetpack/sdk/tabs/tab-firefox.js b/toolkit/jetpack/sdk/tabs/tab-firefox.js
new file mode 100644
index 000000000..f1da92379
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/tab-firefox.js
@@ -0,0 +1,353 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { Class } = require('../core/heritage');
+const { observer } = require('./observer');
+const { observer: windowObserver } = require('../windows/observer');
+const { addListItem, removeListItem } = require('../util/list');
+const { viewFor } = require('../view/core');
+const { modelFor } = require('../model/core');
+const { emit, setListeners } = require('../event/core');
+const { EventTarget } = require('../event/target');
+const { getBrowserForTab, setTabURL, getTabId, getTabURL, getTabForBrowser,
+        getTabs, getTabTitle, setTabTitle, getIndex, closeTab, reload, move,
+        activateTab, pin, unpin, isTab } = require('./utils');
+const { isBrowser, getInnerId, isWindowPrivate } = require('../window/utils');
+const { getThumbnailURIForWindow, BLANK } = require("../content/thumbnail");
+const { when } = require('../system/unload');
+const { ignoreWindow, isPrivate } = require('../private-browsing/utils')
+const { defer } = require('../lang/functional');
+const { getURL } = require('../url/utils');
+const { frames, remoteRequire } = require('../remote/parent');
+remoteRequire('sdk/content/tab-events');
+
+const modelsFor = new WeakMap();
+const viewsFor = new WeakMap();
+const destroyed = new WeakMap();
+
+const tabEvents = {};
+exports.tabEvents = tabEvents;
+
+function browser(tab) {
+  return getBrowserForTab(viewsFor.get(tab));
+}
+
+function isDestroyed(tab) {
+  return destroyed.has(tab);
+}
+
+function isClosed(tab) {
+  if (!viewsFor.has(tab))
+    return true;
+  return viewsFor.get(tab).closing;
+}
+
+// private tab attribute where the remote cached value is stored
+const remoteReadyStateCached = Symbol("remoteReadyStateCached");
+
+const Tab = Class({
+  implements: [EventTarget],
+  initialize: function(tabElement, options = null) {
+    modelsFor.set(tabElement, this);
+    viewsFor.set(this, tabElement);
+
+    if (options) {
+      EventTarget.prototype.initialize.call(this, options);
+
+      if (options.isPinned)
+        this.pin();
+
+      // Note that activate is defered and so will run after any open event
+      // is sent out
+      if (!options.inBackground)
+        this.activate();
+    }
+
+    getURL.implement(this, tab => tab.url);
+    isPrivate.implement(this, tab => {
+      return isWindowPrivate(viewsFor.get(tab).ownerDocument.defaultView);
+    });
+  },
+
+  get id() {
+    return isDestroyed(this) ? undefined : getTabId(viewsFor.get(this));
+  },
+
+  get title() {
+    return isDestroyed(this) ? undefined : getTabTitle(viewsFor.get(this));
+  },
+
+  set title(val) {
+    if (isDestroyed(this))
+      return;
+
+    setTabTitle(viewsFor.get(this), val);
+  },
+
+  get url() {
+    return isDestroyed(this) ? undefined : getTabURL(viewsFor.get(this));
+  },
+
+  set url(val) {
+    if (isDestroyed(this))
+      return;
+
+    setTabURL(viewsFor.get(this), val);
+  },
+
+  get contentType() {
+    return isDestroyed(this) ? undefined : browser(this).documentContentType;
+  },
+
+  get index() {
+    return isDestroyed(this) ? undefined : getIndex(viewsFor.get(this));
+  },
+
+  set index(val) {
+    if (isDestroyed(this))
+      return;
+
+    move(viewsFor.get(this), val);
+  },
+
+  get isPinned() {
+    return isDestroyed(this) ? undefined : viewsFor.get(this).pinned;
+  },
+
+  get window() {
+    if (isClosed(this))
+      return undefined;
+
+    // TODO: Remove the dependency on the windows module, see bug 792670
+    require('../windows');
+    let tabElement = viewsFor.get(this);
+    let domWindow = tabElement.ownerDocument.defaultView;
+    return modelFor(domWindow);
+  },
+
+  get readyState() {
+    return isDestroyed(this) ? undefined : this[remoteReadyStateCached] || "uninitialized";
+  },
+
+  pin: function() {
+    if (isDestroyed(this))
+      return;
+
+    pin(viewsFor.get(this));
+  },
+
+  unpin: function() {
+    if (isDestroyed(this))
+      return;
+
+    unpin(viewsFor.get(this));
+  },
+
+  close: function(callback) {
+    let tabElement = viewsFor.get(this);
+
+    if (isDestroyed(this) || !tabElement || !tabElement.parentNode) {
+      if (callback)
+        callback();
+      return;
+    }
+
+    this.once('close', () => {
+      this.destroy();
+      if (callback)
+        callback();
+    });
+
+    closeTab(tabElement);
+  },
+
+  reload: function() {
+    if (isDestroyed(this))
+      return;
+
+    reload(viewsFor.get(this));
+  },
+
+  activate: defer(function() {
+    if (isDestroyed(this))
+      return;
+
+    activateTab(viewsFor.get(this));
+  }),
+
+  getThumbnail: function() {
+    if (isDestroyed(this))
+      return BLANK;
+
+    // TODO: This is unimplemented in e10s: bug 1148601
+    if (browser(this).isRemoteBrowser) {
+      console.error('This method is not supported with E10S');
+      return BLANK;
+    }
+    return getThumbnailURIForWindow(browser(this).contentWindow);
+  },
+
+  attach: function(options) {
+    if (isDestroyed(this))
+      return;
+
+    let { Worker } = require('../content/worker');
+    let { connect, makeChildOptions } = require('../content/utils');
+
+    let worker = Worker(options);
+    worker.once("detach", () => {
+      worker.destroy();
+    });
+
+    let attach = frame => {
+      let childOptions = makeChildOptions(options);
+      frame.port.emit("sdk/tab/attach", childOptions);
+      connect(worker, frame, { id: childOptions.id, url: this.url });
+    };
+
+    // Do this synchronously if possible
+    let frame = frames.getFrameForBrowser(browser(this));
+    if (frame) {
+      attach(frame);
+    }
+    else {
+      let listener = (frame) => {
+        if (frame.frameElement != browser(this))
+          return;
+
+        frames.off("attach", listener);
+        attach(frame);
+      };
+      frames.on("attach", listener);
+    }
+
+    return worker;
+  },
+
+  destroy: function() {
+    if (isDestroyed(this))
+      return;
+
+    destroyed.set(this, true);
+  }
+});
+exports.Tab = Tab;
+
+viewFor.define(Tab, tab => viewsFor.get(tab));
+
+// Returns the high-level window for this DOM window if the windows module has
+// ever been loaded otherwise returns null
+function maybeWindowFor(domWindow) {
+  try {
+    return modelFor(domWindow);
+  }
+  catch (e) {
+    return null;
+  }
+}
+
+function tabEmit(tab, event, ...args) {
+  // Don't emit events for destroyed tabs
+  if (isDestroyed(tab))
+    return;
+
+  // If the windows module was never loaded this will return null. We don't need
+  // to emit to the window.tabs object in this case as nothing can be listening.
+  let tabElement = viewsFor.get(tab);
+  let window = maybeWindowFor(tabElement.ownerDocument.defaultView);
+  if (window)
+    emit(window.tabs, event, tab, ...args);
+
+  emit(tabEvents, event, tab, ...args);
+  emit(tab, event, tab, ...args);
+}
+
+function windowClosed(domWindow) {
+  if (!isBrowser(domWindow))
+    return;
+
+  for (let tabElement of getTabs(domWindow)) {
+    tabEventListener("close", tabElement);
+  }
+}
+windowObserver.on('close', windowClosed);
+
+// Don't want to send close events after unloaded
+when(_ => {
+  windowObserver.off('close', windowClosed);
+});
+
+// Listen for tabbrowser events
+function tabEventListener(event, tabElement, ...args) {
+  let domWindow = tabElement.ownerDocument.defaultView;
+
+  if (ignoreWindow(domWindow))
+    return;
+
+  // Don't send events for tabs that are already closing
+  if (event != "close" && (tabElement.closing || !tabElement.parentNode))
+    return;
+
+  let tab = modelsFor.get(tabElement);
+  if (!tab)
+    tab = new Tab(tabElement);
+
+  let window = maybeWindowFor(domWindow);
+
+  if (event == "open") {
+    // Note, add to the window tabs first because if this is the first access to
+    // window.tabs it will be prefilling itself with everything from tabs
+    if (window)
+      addListItem(window.tabs, tab);
+    // The tabs module will take care of adding to its internal list
+  }
+  else if (event == "close") {
+    if (window)
+      removeListItem(window.tabs, tab);
+    // The tabs module will take care of removing from its internal list
+  }
+  else if (event == "init" || event == "create" || event == "ready" || event == "load") {
+    // Ignore load events from before browser windows have fully loaded, these
+    // are for about:blank in the initial tab
+    if (isBrowser(domWindow) && !domWindow.gBrowserInit.delayedStartupFinished)
+      return;
+
+    // update the cached remote readyState value
+    let { readyState } = args[0] || {};
+    tab[remoteReadyStateCached] = readyState;
+  }
+
+  if (event == "init") {
+    // Do not emit events for the detected existent tabs, we only need to cache
+    // their current document.readyState value.
+    return;
+  }
+
+  tabEmit(tab, event, ...args);
+
+  // The tab object shouldn't be reachable after closed
+  if (event == "close") {
+    viewsFor.delete(tab);
+    modelsFor.delete(tabElement);
+  }
+}
+observer.on('*', tabEventListener);
+
+// Listen for tab events from content
+frames.port.on('sdk/tab/event', (frame, event, ...args) => {
+  if (!frame.isTab)
+    return;
+
+  let tabElement = getTabForBrowser(frame.frameElement);
+  if (!tabElement)
+    return;
+
+  tabEventListener(event, tabElement, ...args);
+});
+
+// Implement `modelFor` function for the Tab instances..
+modelFor.when(isTab, view => {
+  return modelsFor.get(view);
+});
diff --git a/toolkit/jetpack/sdk/tabs/tab.js b/toolkit/jetpack/sdk/tabs/tab.js
new file mode 100644
index 000000000..fa2272494
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/tab.js
@@ -0,0 +1,24 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+const { getTargetWindow } = require("../content/mod");
+const { getTabContentWindow, isTab } = require("./utils");
+const { viewFor } = require("../view/core");
+
+if (require('../system/xul-app').name == 'Fennec') {
+  module.exports = require('./tab-fennec');
+}
+else {
+  module.exports = require('./tab-firefox');
+}
+
+getTargetWindow.when(isTab, tab => getTabContentWindow(tab));
+
+getTargetWindow.when(x => x instanceof module.exports.Tab,
+  tab => getTabContentWindow(viewFor(tab)));
diff --git a/toolkit/jetpack/sdk/tabs/tabs-firefox.js b/toolkit/jetpack/sdk/tabs/tabs-firefox.js
new file mode 100644
index 000000000..1eefecb4c
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/tabs-firefox.js
@@ -0,0 +1,135 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Class } = require('../core/heritage');
+const { Tab, tabEvents } = require('./tab');
+const { EventTarget } = require('../event/target');
+const { emit, setListeners } = require('../event/core');
+const { pipe } = require('../event/utils');
+const { observer: windowObserver } = require('../windows/observer');
+const { List, addListItem, removeListItem } = require('../util/list');
+const { modelFor } = require('../model/core');
+const { viewFor } = require('../view/core');
+const { getTabs, getSelectedTab } = require('./utils');
+const { getMostRecentBrowserWindow, isBrowser } = require('../window/utils');
+const { Options } = require('./common');
+const { isPrivate } = require('../private-browsing');
+const { ignoreWindow, isWindowPBSupported } = require('../private-browsing/utils')
+const { isPrivateBrowsingSupported } = require('sdk/self');
+
+const supportPrivateTabs = isPrivateBrowsingSupported && isWindowPBSupported;
+
+const Tabs = Class({
+  implements: [EventTarget],
+  extends: List,
+  initialize: function() {
+    List.prototype.initialize.call(this);
+
+    // We must do the list manipulation here where the object is extensible
+    this.on("open", tab => {
+      addListItem(this, tab);
+    });
+
+    this.on("close", tab => {
+      removeListItem(this, tab);
+    });
+  },
+
+  get activeTab() {
+    let activeDomWin = getMostRecentBrowserWindow();
+    if (!activeDomWin)
+      return null;
+    return modelFor(getSelectedTab(activeDomWin));
+  },
+
+  open: function(options) {
+    options = Options(options);
+
+    // TODO: Remove the dependency on the windows module: bug 792670
+    let windows = require('../windows').browserWindows;
+    let activeWindow = windows.activeWindow;
+
+    let privateState = supportPrivateTabs && options.isPrivate;
+    // When no isPrivate option was passed use the private state of the active
+    // window
+    if (activeWindow && privateState === undefined)
+      privateState = isPrivate(activeWindow);
+
+    function getWindow(privateState) {
+      for (let window of windows) {
+        if (privateState === isPrivate(window)) {
+          return window;
+        }
+      }
+      return null;
+    }
+
+    function openNewWindowWithTab() {
+      windows.open({
+        url: options.url,
+        isPrivate: privateState,
+        onOpen: function(newWindow) {
+          let tab = newWindow.tabs[0];
+          setListeners(tab, options);
+
+          if (options.isPinned)
+            tab.pin();
+
+          // We don't emit the open event for the first tab in a new window so
+          // do it now the listeners are attached
+          emit(tab, "open", tab);
+        }
+      });
+    }
+
+    if (options.inNewWindow)
+      return openNewWindowWithTab();
+
+    // if the active window is in the state that we need then use it
+    if (activeWindow && (privateState === isPrivate(activeWindow)))
+      return activeWindow.tabs.open(options);
+
+    // find a window in the state that we need
+    let window = getWindow(privateState);
+    if (window)
+      return window.tabs.open(options);
+
+    return openNewWindowWithTab();
+  }
+});
+
+const allTabs = new Tabs();
+// Export a new object with allTabs as the prototype, otherwise allTabs becomes
+// frozen and addListItem and removeListItem don't work correctly.
+module.exports = Object.create(allTabs);
+pipe(tabEvents, module.exports);
+
+function addWindowTab(window, tabElement) {
+  let tab = new Tab(tabElement);
+  if (window)
+    addListItem(window.tabs, tab);
+  addListItem(allTabs, tab);
+  emit(allTabs, "open", tab);
+}
+
+// Find tabs in already open windows
+for (let tabElement of getTabs())
+  addWindowTab(null, tabElement);
+
+// Detect tabs in new windows
+windowObserver.on('open', domWindow => {
+  if (!isBrowser(domWindow) || ignoreWindow(domWindow))
+    return;
+
+  let window = null;
+  try {
+    modelFor(domWindow);
+  }
+  catch (e) { }
+
+  for (let tabElement of getTabs(domWindow)) {
+    addWindowTab(window, tabElement);
+  }
+});
diff --git a/toolkit/jetpack/sdk/tabs/utils.js b/toolkit/jetpack/sdk/tabs/utils.js
new file mode 100644
index 000000000..eae3d41fe
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/utils.js
@@ -0,0 +1,370 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+
+// NOTE: This file should only deal with xul/native tabs
+
+
+const { Ci, Cu } = require('chrome');
+const { defer } = require("../lang/functional");
+const { windows, isBrowser } = require('../window/utils');
+const { isPrivateBrowsingSupported } = require('../self');
+const { ShimWaiver } = Cu.import("resource://gre/modules/ShimWaiver.jsm");
+
+// Bug 834961: ignore private windows when they are not supported
+function getWindows() {
+  return windows(null, { includePrivate: isPrivateBrowsingSupported });
+}
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+// Define predicate functions that can be used to detech weather
+// we deal with fennec tabs or firefox tabs.
+
+// Predicate to detect whether tab is XUL "Tab" node.
+const isXULTab = tab =>
+  tab instanceof Ci.nsIDOMNode &&
+  tab.nodeName === "tab" &&
+  tab.namespaceURI === XUL_NS;
+exports.isXULTab = isXULTab;
+
+// Predicate to detecet whether given tab is a fettec tab.
+// Unfortunately we have to guess via duck typinng of:
+// http://mxr.mozilla.org/mozilla-central/source/mobile/android/chrome/content/browser.js#2583
+const isFennecTab = tab =>
+  tab &&
+  tab.QueryInterface &&
+  Ci.nsIBrowserTab &&
+  tab.QueryInterface(Ci.nsIBrowserTab) === tab;
+exports.isFennecTab = isFennecTab;
+
+const isTab = x => isXULTab(x) || isFennecTab(x);
+exports.isTab = isTab;
+
+function activateTab(tab, window) {
+  let gBrowser = getTabBrowserForTab(tab);
+
+  // normal case
+  if (gBrowser) {
+    gBrowser.selectedTab = tab;
+  }
+  // fennec ?
+  else if (window && window.BrowserApp) {
+    window.BrowserApp.selectTab(tab);
+  }
+  return null;
+}
+exports.activateTab = activateTab;
+
+function getTabBrowser(window) {
+  // bug 1009938 - may be null in SeaMonkey
+  return window.gBrowser || window.getBrowser();
+}
+exports.getTabBrowser = getTabBrowser;
+
+function getTabContainer(window) {
+  return getTabBrowser(window).tabContainer;
+}
+exports.getTabContainer = getTabContainer;
+
+/**
+ * Returns the tabs for the `window` if given, or the tabs
+ * across all the browser's windows otherwise.
+ *
+ * @param {nsIWindow} [window]
+ *    A reference to a window
+ *
+ * @returns {Array} an array of Tab objects
+ */
+function getTabs(window) {
+  if (arguments.length === 0) {
+    return getWindows().
+               filter(isBrowser).
+               reduce((tabs, window) => tabs.concat(getTabs(window)), []);
+  }
+
+  // fennec
+  if (window.BrowserApp)
+    return window.BrowserApp.tabs;
+
+  // firefox - default
+  return Array.filter(getTabContainer(window).children, t => !t.closing);
+}
+exports.getTabs = getTabs;
+
+function getActiveTab(window) {
+  return getSelectedTab(window);
+}
+exports.getActiveTab = getActiveTab;
+
+function getOwnerWindow(tab) {
+  // normal case
+  if (tab.ownerDocument)
+    return tab.ownerDocument.defaultView;
+
+  // try fennec case
+  return getWindowHoldingTab(tab);
+}
+exports.getOwnerWindow = getOwnerWindow;
+
+// fennec
+function getWindowHoldingTab(rawTab) {
+  for (let window of getWindows()) {
+    // this function may be called when not using fennec,
+    // but BrowserApp is only defined on Fennec
+    if (!window.BrowserApp)
+      continue;
+
+    for (let tab of window.BrowserApp.tabs) {
+      if (tab === rawTab)
+        return window;
+    }
+  }
+
+  return null;
+}
+
+function openTab(window, url, options) {
+  options = options || {};
+
+  // fennec?
+  if (window.BrowserApp) {
+    return window.BrowserApp.addTab(url, {
+      selected: options.inBackground ? false : true,
+      pinned: options.isPinned || false,
+      isPrivate: options.isPrivate || false,
+      parentId: window.BrowserApp.selectedTab.id
+    });
+  }
+
+  // firefox
+  let newTab = window.gBrowser.addTab(url);
+  if (!options.inBackground) {
+    activateTab(newTab);
+  }
+  return newTab;
+};
+exports.openTab = openTab;
+
+function isTabOpen(tab) {
+  // try normal case then fennec case
+  return !!((tab.linkedBrowser) || getWindowHoldingTab(tab));
+}
+exports.isTabOpen = isTabOpen;
+
+function closeTab(tab) {
+  let gBrowser = getTabBrowserForTab(tab);
+  // normal case?
+  if (gBrowser) {
+    // Bug 699450: the tab may already have been detached
+    if (!tab.parentNode)
+      return;
+    return gBrowser.removeTab(tab);
+  }
+
+  let window = getWindowHoldingTab(tab);
+  // fennec?
+  if (window && window.BrowserApp) {
+    // Bug 699450: the tab may already have been detached
+    if (!tab.browser)
+      return;
+    return window.BrowserApp.closeTab(tab);
+  }
+  return null;
+}
+exports.closeTab = closeTab;
+
+function getURI(tab) {
+  if (tab.browser) // fennec
+    return tab.browser.currentURI.spec;
+  return tab.linkedBrowser.currentURI.spec;
+}
+exports.getURI = getURI;
+
+function getTabBrowserForTab(tab) {
+  let outerWin = getOwnerWindow(tab);
+  if (outerWin)
+    return getOwnerWindow(tab).gBrowser;
+  return null;
+}
+exports.getTabBrowserForTab = getTabBrowserForTab;
+
+function getBrowserForTab(tab) {
+  if (tab.browser) // fennec
+    return tab.browser;
+
+  return tab.linkedBrowser;
+}
+exports.getBrowserForTab = getBrowserForTab;
+
+function getTabId(tab) {
+  if (tab.browser) // fennec
+    return tab.id
+
+  return String.split(tab.linkedPanel, 'panel').pop();
+}
+exports.getTabId = getTabId;
+
+function getTabForId(id) {
+  return getTabs().find(tab => getTabId(tab) === id) || null;
+}
+exports.getTabForId = getTabForId;
+
+function getTabTitle(tab) {
+  return getBrowserForTab(tab).contentTitle || tab.label || "";
+}
+exports.getTabTitle = getTabTitle;
+
+function setTabTitle(tab, title) {
+  title = String(title);
+  if (tab.browser) {
+    // Fennec
+    tab.browser.contentDocument.title = title;
+  }
+  else {
+    let browser = getBrowserForTab(tab);
+    // Note that we aren't actually setting the document title in e10s, just
+    // the title the browser thinks the content has
+    if (browser.isRemoteBrowser)
+      browser._contentTitle = title;
+    else
+      browser.contentDocument.title = title;
+  }
+  tab.label = String(title);
+}
+exports.setTabTitle = setTabTitle;
+
+function getTabContentDocument(tab) {
+  return getBrowserForTab(tab).contentDocument;
+}
+exports.getTabContentDocument = getTabContentDocument;
+
+function getTabContentWindow(tab) {
+  return getBrowserForTab(tab).contentWindow;
+}
+exports.getTabContentWindow = getTabContentWindow;
+
+/**
+ * Returns all tabs' content windows across all the browsers' windows
+ */
+function getAllTabContentWindows() {
+  return getTabs().map(getTabContentWindow);
+}
+exports.getAllTabContentWindows = getAllTabContentWindows;
+
+// gets the tab containing the provided window
+function getTabForContentWindow(window) {
+  return getTabs().find(tab => getTabContentWindow(tab) === window.top) || null;
+}
+exports.getTabForContentWindow = getTabForContentWindow;
+
+// only sdk/selection.js is relying on shims
+function getTabForContentWindowNoShim(window) {
+  function getTabContentWindowNoShim(tab) {
+    let browser = getBrowserForTab(tab);
+    return ShimWaiver.getProperty(browser, "contentWindow");
+  }
+  return getTabs().find(tab => getTabContentWindowNoShim(tab) === window.top) || null;
+}
+exports.getTabForContentWindowNoShim = getTabForContentWindowNoShim;
+
+function getTabURL(tab) {
+  return String(getBrowserForTab(tab).currentURI.spec);
+}
+exports.getTabURL = getTabURL;
+
+function setTabURL(tab, url) {
+  let browser = getBrowserForTab(tab);
+  browser.loadURI(String(url));
+}
+// "TabOpen" event is fired when it's still "about:blank" is loaded in the
+// changing `location` property of the `contentDocument` has no effect since
+// seems to be either ignored or overridden by internal listener, there for
+// location change is enqueued for the next turn of event loop.
+exports.setTabURL = defer(setTabURL);
+
+function getTabContentType(tab) {
+  return getBrowserForTab(tab).contentDocument.contentType;
+}
+exports.getTabContentType = getTabContentType;
+
+function getSelectedTab(window) {
+  if (window.BrowserApp) // fennec?
+    return window.BrowserApp.selectedTab;
+  if (window.gBrowser)
+    return window.gBrowser.selectedTab;
+  return null;
+}
+exports.getSelectedTab = getSelectedTab;
+
+
+function getTabForBrowser(browser) {
+  for (let window of getWindows()) {
+    // this function may be called when not using fennec
+    if (!window.BrowserApp)
+      continue;
+
+    for  (let tab of window.BrowserApp.tabs) {
+      if (tab.browser === browser)
+        return tab;
+    }
+  }
+
+  let tabbrowser = browser.getTabBrowser && browser.getTabBrowser()
+  return !!tabbrowser && tabbrowser.getTabForBrowser(browser);
+}
+exports.getTabForBrowser = getTabForBrowser;
+
+function pin(tab) {
+  let gBrowser = getTabBrowserForTab(tab);
+  // TODO: Implement Fennec support
+  if (gBrowser) gBrowser.pinTab(tab);
+}
+exports.pin = pin;
+
+function unpin(tab) {
+  let gBrowser = getTabBrowserForTab(tab);
+  // TODO: Implement Fennec support
+  if (gBrowser) gBrowser.unpinTab(tab);
+}
+exports.unpin = unpin;
+
+function isPinned(tab) {
+  return !!tab.pinned;
+}
+exports.isPinned = isPinned;
+
+function reload(tab) {
+  getBrowserForTab(tab).reload();
+}
+exports.reload = reload
+
+function getIndex(tab) {
+  let gBrowser = getTabBrowserForTab(tab);
+  // Firefox
+  if (gBrowser) {
+    return tab._tPos;
+  }
+  // Fennec
+  else {
+    let window = getWindowHoldingTab(tab)
+    let tabs = window.BrowserApp.tabs;
+    for (let i = tabs.length; i >= 0; i--)
+      if (tabs[i] === tab) return i;
+  }
+}
+exports.getIndex = getIndex;
+
+function move(tab, index) {
+  let gBrowser = getTabBrowserForTab(tab);
+  // Firefox
+  if (gBrowser) gBrowser.moveTabTo(tab, index);
+  // TODO: Implement fennec support
+}
+exports.move = move;
diff --git a/toolkit/jetpack/sdk/tabs/worker.js b/toolkit/jetpack/sdk/tabs/worker.js
new file mode 100644
index 000000000..d2ba33696
--- /dev/null
+++ b/toolkit/jetpack/sdk/tabs/worker.js
@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const ContentWorker = require('../content/worker').Worker;
+
+function Worker(options, window) {
+  options.window = window;
+
+  let worker = ContentWorker(options);
+  worker.once("detach", function detach() {
+    worker.destroy();
+  });
+  return worker;
+}
+exports.Worker = Worker;
\ No newline at end of file
diff --git a/toolkit/jetpack/sdk/test.js b/toolkit/jetpack/sdk/test.js
new file mode 100644
index 000000000..e7e3df840
--- /dev/null
+++ b/toolkit/jetpack/sdk/test.js
@@ -0,0 +1,114 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cu } = require("chrome");
+const { Task } = require("resource://gre/modules/Task.jsm", {});
+const { defer } = require("sdk/core/promise");
+const BaseAssert = require("sdk/test/assert").Assert;
+const { isFunction, isObject, isGenerator } = require("sdk/lang/type");
+const { extend } = require("sdk/util/object");
+
+exports.Assert = BaseAssert;
+
+/**
+ * Function takes test `suite` object in CommonJS format and defines all of the
+ * tests from that suite and nested suites in a jetpack format on a given
+ * `target` object. Optionally third argument `prefix` can be passed to prefix
+ * all the test names.
+ */
+function defineTestSuite(target, suite, prefix) {
+  prefix = prefix || "";
+  // If suite defines `Assert` that's what `assert` object have to be created
+  // from and passed to a test function (This allows custom assertion functions)
+  // See for details: http://wiki.commonjs.org/wiki/Unit_Testing/1.1
+  let Assert = suite.Assert || BaseAssert;
+  // Going through each item in the test suite and wrapping it into a
+  // Jetpack test format.
+  Object.keys(suite).forEach(function(key) {
+     // If name starts with test then it's a test function or suite.
+    if (key.indexOf("test") === 0) {
+      let test = suite[key];
+
+      // For each test function so we create a wrapper test function in a
+      // jetpack format and copy that to a `target` exports.
+      if (isFunction(test)) {
+
+        // Since names of the test may match across suites we use full object
+        // path as a name to avoid overriding same function.
+        target[prefix + key] = function(options) {
+
+          // Creating `assert` functions for this test.
+          let assert = Assert(options);
+          assert.end = () => options.done();
+
+          // If test function is a generator use a task JS to allow yield-ing
+          // style test runs.
+          if (isGenerator(test)) {
+            options.waitUntilDone();
+            Task.spawn(test.bind(null, assert)).
+                catch(assert.fail).
+                then(assert.end);
+          }
+
+          // If CommonJS test function expects more than one argument
+          // it means that test is async and second argument is a callback
+          // to notify that test is finished.
+          else if (1 < test.length) {
+            // Letting test runner know that test is executed async and
+            // creating a callback function that CommonJS tests will call
+            // once it's done.
+            options.waitUntilDone();
+            test(assert, function() {
+              options.done();
+            });
+          }
+
+          // Otherwise CommonJS test is synchronous so we call it only with
+          // one argument.
+          else {
+            test(assert);
+          }
+        }
+      }
+
+      // If it's an object then it's a test suite containing test function
+      // and / or nested test suites. In that case we just extend prefix used
+      // and call this function to copy and wrap tests from nested suite.
+      else if (isObject(test)) {
+        // We need to clone `tests` instead of modifying it, since it's very
+        // likely that it is frozen (usually test suites imported modules).
+        test = extend(Object.prototype, test, {
+          Assert: test.Assert || Assert
+        });
+        defineTestSuite(target, test, prefix + key + ".");
+      }
+    }
+  });
+}
+
+/**
+ * This function is a CommonJS test runner function, but since Jetpack test
+ * runner and test format is different from CommonJS this function shims given
+ * `exports` with all its tests into a Jetpack test format so that the built-in
+ * test runner will be able to run CommonJS test without manual changes.
+ */
+exports.run = function run(exports) {
+  // We can't leave old properties on exports since those are test in a CommonJS
+  // format that why we move everything to a new `suite` object.
+  let suite = {};
+  Object.keys(exports).forEach(function(key) {
+    suite[key] = exports[key];
+    delete exports[key];
+  });
+
+  // Now we wrap all the CommonJS tests to a Jetpack format and define
+  // those to a given `exports` object since that where jetpack test runner
+  // will look for them.
+  defineTestSuite(exports, suite);
+};
diff --git a/toolkit/jetpack/sdk/test/assert.js b/toolkit/jetpack/sdk/test/assert.js
new file mode 100644
index 000000000..8478c8414
--- /dev/null
+++ b/toolkit/jetpack/sdk/test/assert.js
@@ -0,0 +1,366 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { isFunction, isNull, isObject, isString,
+        isRegExp, isArray, isDate, isPrimitive,
+        isUndefined, instanceOf, source } = require("../lang/type");
+
+/**
+ * The `AssertionError` is defined in assert.
+ * @extends Error
+ * @example
+ *  new assert.AssertionError({
+ *    message: message,
+ *    actual: actual,
+ *    expected: expected
+ *  })
+ */
+function AssertionError(options) {
+  let assertionError = Object.create(AssertionError.prototype);
+
+  if (isString(options))
+    options = { message: options };
+  if ("actual" in options)
+    assertionError.actual = options.actual;
+  if ("expected" in options)
+    assertionError.expected = options.expected;
+  if ("operator" in options)
+    assertionError.operator = options.operator;
+
+  assertionError.message = options.message;
+  assertionError.stack = new Error().stack;
+  return assertionError;
+}
+AssertionError.prototype = Object.create(Error.prototype, {
+  constructor: { value: AssertionError },
+  name: { value: "AssertionError", enumerable: true },
+  toString: { value: function toString() {
+    let value;
+    if (this.message) {
+      value = this.name + " : " + this.message;
+    }
+    else {
+      value = [
+        this.name + " : ",
+        source(this.expected),
+        this.operator,
+        source(this.actual)
+      ].join(" ");
+    }
+    return value;
+  }}
+});
+exports.AssertionError = AssertionError;
+
+function Assert(logger) {
+  let assert = Object.create(Assert.prototype, { _log: { value: logger }});
+
+  assert.fail = assert.fail.bind(assert);
+  assert.pass = assert.pass.bind(assert);
+
+  return assert;
+}
+
+Assert.prototype = {
+  fail: function fail(e) {
+    if (!e || typeof(e) !== 'object') {
+      this._log.fail(e);
+      return;
+    }
+    let message = e.message;
+    try {
+      if ('operator' in e) {
+        message += [
+          " -",
+          source(e.actual),
+          e.operator,
+          source(e.expected)
+        ].join(" ");
+      }
+    }
+    catch(e) {}
+    this._log.fail(message);
+  },
+  pass: function pass(message) {
+    this._log.pass(message);
+    return true;
+  },
+  error: function error(e) {
+    this._log.exception(e);
+  },
+  ok: function ok(value, message) {
+    if (!!!value) {
+      this.fail({
+        actual: value,
+        expected: true,
+        message: message,
+        operator: "=="
+      });
+      return false;
+    }
+
+    this.pass(message);
+    return true;
+  },
+
+  /**
+   * The equality assertion tests shallow, coercive equality with `==`.
+   * @example
+   *    assert.equal(1, 1, "one is one");
+   */
+  equal: function equal(actual, expected, message) {
+    if (actual == expected) {
+      this.pass(message);
+      return true;
+    }
+
+    this.fail({
+      actual: actual,
+      expected: expected,
+      message: message,
+      operator: "=="
+    });
+    return false;
+  },
+
+  /**
+   * The non-equality assertion tests for whether two objects are not equal
+   * with `!=`.
+   * @example
+   *    assert.notEqual(1, 2, "one is not two");
+   */
+  notEqual: function notEqual(actual, expected, message) {
+    if (actual != expected) {
+      this.pass(message);
+      return true;
+    }
+
+    this.fail({
+      actual: actual,
+      expected: expected,
+      message: message,
+      operator: "!=",
+    });
+    return false;
+  },
+
+  /**
+   * The equivalence assertion tests a deep (with `===`) equality relation.
+   * @example
+   *    assert.deepEqual({ a: "foo" }, { a: "foo" }, "equivalent objects")
+   */
+   deepEqual: function deepEqual(actual, expected, message) {
+    if (isDeepEqual(actual, expected)) {
+      this.pass(message);
+      return true;
+    }
+
+    this.fail({
+      actual: actual,
+      expected: expected,
+      message: message,
+      operator: "deepEqual"
+    });
+    return false;
+  },
+
+  /**
+   * The non-equivalence assertion tests for any deep (with `===`) inequality.
+   * @example
+   *    assert.notDeepEqual({ a: "foo" }, Object.create({ a: "foo" }),
+   *                        "object's inherit from different prototypes");
+   */
+  notDeepEqual: function notDeepEqual(actual, expected, message) {
+    if (!isDeepEqual(actual, expected)) {
+      this.pass(message);
+      return true;
+    }
+
+    this.fail({
+      actual: actual,
+      expected: expected,
+      message: message,
+      operator: "notDeepEqual"
+    });
+    return false;
+  },
+
+  /**
+   * The strict equality assertion tests strict equality, as determined by
+   * `===`.
+   * @example
+   *    assert.strictEqual(null, null, "`null` is `null`")
+   */
+  strictEqual: function strictEqual(actual, expected, message) {
+    if (actual === expected) {
+      this.pass(message);
+      return true;
+    }
+
+    this.fail({
+      actual: actual,
+      expected: expected,
+      message: message,
+      operator: "==="
+    });
+    return false;
+  },
+
+  /**
+   * The strict non-equality assertion tests for strict inequality, as
+   * determined by `!==`.
+   * @example
+   *    assert.notStrictEqual(null, undefined, "`null` is not `undefined`");
+   */
+  notStrictEqual: function notStrictEqual(actual, expected, message) {
+    if (actual !== expected) {
+      this.pass(message);
+      return true;
+    }
+
+    this.fail({
+      actual: actual,
+      expected: expected,
+      message: message,
+      operator: "!=="
+    });
+    return false;
+  },
+
+  /**
+   * The assertion whether or not given `block` throws an exception. If optional
+   * `Error` argument is provided and it's type of function thrown error is
+   * asserted to be an instance of it, if type of `Error` is string then message
+   * of throw exception is asserted to contain it.
+   * @param {Function} block
+   *    Function that is expected to throw.
+   * @param {Error|RegExp} [Error]
+   *    Error constructor that is expected to be thrown or a string that
+   *    must be contained by a message of the thrown exception, or a RegExp
+   *    matching a message of the thrown exception.
+   * @param {String} message
+   *    Description message
+   *
+   * @examples
+   *
+   *    assert.throws(function block() {
+   *      doSomething(4)
+   *    }, "Object is expected", "Incorrect argument is passed");
+   *
+   *    assert.throws(function block() {
+   *      Object.create(5)
+   *    }, TypeError, "TypeError is thrown");
+   */
+  throws: function throws(block, Error, message) {
+    let threw = false;
+    let exception = null;
+
+    // If third argument is not provided and second argument is a string it
+    // means that optional `Error` argument was not passed, so we shift
+    // arguments.
+    if (isString(Error) && isUndefined(message)) {
+      message = Error;
+      Error = undefined;
+    }
+
+    // Executing given `block`.
+    try {
+      block();
+    }
+    catch (e) {
+      threw = true;
+      exception = e;
+    }
+
+    // If exception was thrown and `Error` argument was not passed assert is
+    // passed.
+    if (threw && (isUndefined(Error) ||
+                 // If passed `Error` is RegExp using it's test method to
+                 // assert thrown exception message.
+                 (isRegExp(Error) && (Error.test(exception.message) || Error.test(exception.toString()))) ||
+                 // If passed `Error` is a constructor function testing if
+                 // thrown exception is an instance of it.
+                 (isFunction(Error) && instanceOf(exception, Error))))
+    {
+      this.pass(message);
+      return true;
+    }
+
+    // Otherwise we report assertion failure.
+    let failure = {
+      message: message,
+      operator: "matches"
+    };
+
+    if (exception) {
+      failure.actual = exception.message || exception.toString();
+    }
+
+    if (Error) {
+      failure.expected = Error.toString();
+    }
+
+    this.fail(failure);
+    return false;
+  }
+};
+exports.Assert = Assert;
+
+function isDeepEqual(actual, expected) {
+  // 7.1. All identical values are equivalent, as determined by ===.
+  if (actual === expected) {
+    return true;
+  }
+
+  // 7.2. If the expected value is a Date object, the actual value is
+  // equivalent if it is also a Date object that refers to the same time.
+  else if (isDate(actual) && isDate(expected)) {
+    return actual.getTime() === expected.getTime();
+  }
+
+  // XXX specification bug: this should be specified
+  else if (isPrimitive(actual) || isPrimitive(expected)) {
+    return expected === actual;
+  }
+
+  // 7.3. Other pairs that do not both pass typeof value == "object",
+  // equivalence is determined by ==.
+  else if (!isObject(actual) && !isObject(expected)) {
+    return actual == expected;
+  }
+
+  // 7.4. For all other Object pairs, including Array objects, equivalence is
+  // determined by having the same number of owned properties (as verified
+  // with Object.prototype.hasOwnProperty.call), the same set of keys
+  // (although not necessarily the same order), equivalent values for every
+  // corresponding key, and an identical "prototype" property. Note: this
+  // accounts for both named and indexed properties on Arrays.
+  else {
+    return actual.prototype === expected.prototype &&
+           isEquivalent(actual, expected);
+  }
+}
+
+function isEquivalent(a, b, stack) {
+  let aKeys = Object.keys(a);
+  let bKeys = Object.keys(b);
+
+  return aKeys.length === bKeys.length &&
+          isArrayEquivalent(aKeys.sort(), bKeys.sort()) &&
+          aKeys.every(function(key) {
+            return isDeepEqual(a[key], b[key], stack)
+          });
+}
+
+function isArrayEquivalent(a, b, stack) {
+  return isArray(a) && isArray(b) &&
+         a.every(function(value, index) {
+           return isDeepEqual(value, b[index]);
+         });
+}
diff --git a/toolkit/jetpack/sdk/test/harness.js b/toolkit/jetpack/sdk/test/harness.js
new file mode 100644
index 000000000..1b31a1c79
--- /dev/null
+++ b/toolkit/jetpack/sdk/test/harness.js
@@ -0,0 +1,645 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci, Cu } = require("chrome");
+const { Loader } = require('./loader');
+const { serializeStack, parseStack  } = require("toolkit/loader");
+const { setTimeout } = require('../timers');
+const { PlainTextConsole } = require("../console/plain-text");
+const { when: unload } = require("../system/unload");
+const { format, fromException }  = require("../console/traceback");
+const system = require("../system");
+const { gc: gcPromise } = require('./memory');
+const { defer } = require('../core/promise');
+const { extend } = require('../core/heritage');
+
+// Trick manifest builder to make it think we need these modules ?
+const unit = require("../deprecated/unit-test");
+const test = require("../../test");
+const url = require("../url");
+
+function emptyPromise() {
+  let { promise, resolve } = defer();
+  resolve();
+  return promise;
+}
+
+var cService = Cc['@mozilla.org/consoleservice;1'].getService(Ci.nsIConsoleService);
+
+// The console used to log messages
+var testConsole;
+
+// Cuddlefish loader in which we load and execute tests.
+var loader;
+
+// Function to call when we're done running tests.
+var onDone;
+
+// Function to print text to a console, w/o CR at the end.
+var print;
+
+// How many more times to run all tests.
+var iterationsLeft;
+
+// Whether to report memory profiling information.
+var profileMemory;
+
+// Whether we should stop as soon as a test reports a failure.
+var stopOnError;
+
+// Function to call to retrieve a list of tests to execute
+var findAndRunTests;
+
+// Combined information from all test runs.
+var results;
+
+// A list of the compartments and windows loaded after startup
+var startLeaks;
+
+// JSON serialization of last memory usage stats; we keep it stringified
+// so we don't actually change the memory usage stats (in terms of objects)
+// of the JSRuntime we're profiling.
+var lastMemoryUsage;
+
+function analyzeRawProfilingData(data) {
+  var graph = data.graph;
+  var shapes = {};
+
+  // Convert keys in the graph from strings to ints.
+  // TODO: Can we get rid of this ridiculousness?
+  var newGraph = {};
+  for (id in graph) {
+    newGraph[parseInt(id)] = graph[id];
+  }
+  graph = newGraph;
+
+  var modules = 0;
+  var moduleIds = [];
+  var moduleObjs = {UNKNOWN: 0};
+  for (let name in data.namedObjects) {
+    moduleObjs[name] = 0;
+    moduleIds[data.namedObjects[name]] = name;
+    modules++;
+  }
+
+  var count = 0;
+  for (id in graph) {
+    var parent = graph[id].parent;
+    while (parent) {
+      if (parent in moduleIds) {
+        var name = moduleIds[parent];
+        moduleObjs[name]++;
+        break;
+      }
+      if (!(parent in graph)) {
+        moduleObjs.UNKNOWN++;
+        break;
+      }
+      parent = graph[parent].parent;
+    }
+    count++;
+  }
+
+  print("\nobject count is " + count + " in " + modules + " modules" +
+        " (" + data.totalObjectCount + " across entire JS runtime)\n");
+  if (lastMemoryUsage) {
+    var last = JSON.parse(lastMemoryUsage);
+    var diff = {
+      moduleObjs: dictDiff(last.moduleObjs, moduleObjs),
+      totalObjectClasses: dictDiff(last.totalObjectClasses,
+                                   data.totalObjectClasses)
+    };
+
+    for (let name in diff.moduleObjs)
+      print("  " + diff.moduleObjs[name] + " in " + name + "\n");
+    for (let name in diff.totalObjectClasses)
+      print("  " + diff.totalObjectClasses[name] + " instances of " +
+            name + "\n");
+  }
+  lastMemoryUsage = JSON.stringify(
+    {moduleObjs: moduleObjs,
+     totalObjectClasses: data.totalObjectClasses}
+  );
+}
+
+function dictDiff(last, curr) {
+  var diff = {};
+
+  for (let name in last) {
+    var result = (curr[name] || 0) - last[name];
+    if (result)
+      diff[name] = (result > 0 ? "+" : "") + result;
+  }
+  for (let name in curr) {
+    var result = curr[name] - (last[name] || 0);
+    if (result)
+      diff[name] = (result > 0 ? "+" : "") + result;
+  }
+  return diff;
+}
+
+function reportMemoryUsage() {
+  if (!profileMemory) {
+    return emptyPromise();
+  }
+
+  return gcPromise().then((() => {
+    var mgr = Cc["@mozilla.org/memory-reporter-manager;1"]
+              .getService(Ci.nsIMemoryReporterManager);
+    let count = 0;
+    function logReporter(process, path, kind, units, amount, description) {
+      print(((++count == 1) ? "\n" : "") + description + ": " + amount + "\n");
+    }
+    mgr.getReportsForThisProcess(logReporter, null, /* anonymize = */ false);
+  }));
+}
+
+var gWeakrefInfo;
+
+function checkMemory() {
+  return gcPromise().then(_ => {
+    let leaks = getPotentialLeaks();
+
+    let compartmentURLs = Object.keys(leaks.compartments).filter(function(url) {
+      return !(url in startLeaks.compartments);
+    });
+
+    let windowURLs = Object.keys(leaks.windows).filter(function(url) {
+      return !(url in startLeaks.windows);
+    });
+
+    for (let url of compartmentURLs)
+      console.warn("LEAKED", leaks.compartments[url]);
+
+    for (let url of windowURLs)
+      console.warn("LEAKED", leaks.windows[url]);
+  }).then(showResults);
+}
+
+function showResults() {
+  let { promise, resolve } = defer();
+
+  if (gWeakrefInfo) {
+    gWeakrefInfo.forEach(
+      function(info) {
+        var ref = info.weakref.get();
+        if (ref !== null) {
+          var data = ref.__url__ ? ref.__url__ : ref;
+          var warning = data == "[object Object]"
+            ? "[object " + data.constructor.name + "(" +
+              Object.keys(data).join(", ") + ")]"
+            : data;
+          console.warn("LEAK", warning, info.bin);
+        }
+      }
+    );
+  }
+
+  onDone(results);
+
+  resolve();
+  return promise;
+}
+
+function cleanup() {
+  let coverObject = {};
+  try {
+    loader.unload();
+
+    if (loader.globals.console.errorsLogged && !results.failed) {
+      results.failed++;
+      console.error("warnings and/or errors were logged.");
+    }
+
+    if (consoleListener.errorsLogged && !results.failed) {
+      console.warn(consoleListener.errorsLogged + " " +
+                   "warnings or errors were logged to the " +
+                   "platform's nsIConsoleService, which could " +
+                   "be of no consequence; however, they could also " +
+                   "be indicative of aberrant behavior.");
+    }
+
+    // read the code coverage object, if it exists, from CoverJS-moz
+    if (typeof loader.globals.global == "object") {
+      coverObject = loader.globals.global['__$coverObject'] || {};
+    }
+
+    consoleListener.errorsLogged = 0;
+    loader = null;
+
+    consoleListener.unregister();
+
+    Cu.forceGC();
+  }
+  catch (e) {
+    results.failed++;
+    console.error("unload.send() threw an exception.");
+    console.exception(e);
+  };
+
+  setTimeout(require("./options").checkMemory ? checkMemory : showResults, 1);
+
+  // dump the coverobject
+  if (Object.keys(coverObject).length){
+    const self = require('sdk/self');
+    const {pathFor} = require("sdk/system");
+    let file = require('sdk/io/file');
+    const {env} = require('sdk/system/environment');
+    console.log("CWD:", env.PWD);
+    let out = file.join(env.PWD,'coverstats-'+self.id+'.json');
+    console.log('coverstats:', out);
+    let outfh = file.open(out,'w');
+    outfh.write(JSON.stringify(coverObject,null,2));
+    outfh.flush();
+    outfh.close();
+  }
+}
+
+function getPotentialLeaks() {
+  Cu.forceGC();
+
+  // Things we can assume are part of the platform and so aren't leaks
+  let GOOD_BASE_URLS = [
+    "chrome://",
+    "resource:///",
+    "resource://app/",
+    "resource://gre/",
+    "resource://gre-resources/",
+    "resource://pdf.js/",
+    "resource://pdf.js.components/",
+    "resource://services-common/",
+    "resource://services-crypto/",
+    "resource://services-sync/"
+  ];
+
+  let ioService = Cc["@mozilla.org/network/io-service;1"].
+                 getService(Ci.nsIIOService);
+  let uri = ioService.newURI("chrome://global/content/", "UTF-8", null);
+  let chromeReg = Cc["@mozilla.org/chrome/chrome-registry;1"].
+                  getService(Ci.nsIChromeRegistry);
+  uri = chromeReg.convertChromeURL(uri);
+  let spec = uri.spec;
+  let pos = spec.indexOf("!/");
+  GOOD_BASE_URLS.push(spec.substring(0, pos + 2));
+
+  let zoneRegExp = new RegExp("^explicit/js-non-window/zones/zone[^/]+/compartment\\((.+)\\)");
+  let compartmentRegexp = new RegExp("^explicit/js-non-window/compartments/non-window-global/compartment\\((.+)\\)/");
+  let compartmentDetails = new RegExp("^([^,]+)(?:, (.+?))?(?: \\(from: (.*)\\))?$");
+  let windowRegexp = new RegExp("^explicit/window-objects/top\\((.*)\\)/active");
+  let windowDetails = new RegExp("^(.*), id=.*$");
+
+  function isPossibleLeak(item) {
+    if (!item.location)
+      return false;
+
+    for (let url of GOOD_BASE_URLS) {
+      if (item.location.substring(0, url.length) == url) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  let compartments = {};
+  let windows = {};
+  function logReporter(process, path, kind, units, amount, description) {
+    let matches;
+
+    if ((matches = compartmentRegexp.exec(path)) || (matches = zoneRegExp.exec(path))) {
+      if (matches[1] in compartments)
+        return;
+
+      let details = compartmentDetails.exec(matches[1]);
+      if (!details) {
+        console.error("Unable to parse compartment detail " + matches[1]);
+        return;
+      }
+
+      let item = {
+        path: matches[1],
+        principal: details[1],
+        location: details[2] ? details[2].replace(/\\/g, "/") : undefined,
+        source: details[3] ? details[3].split(" -> ").reverse() : undefined,
+        toString: function() {
+          return this.location;
+        }
+      };
+
+      if (!isPossibleLeak(item))
+        return;
+
+      compartments[matches[1]] = item;
+      return;
+    }
+
+    if ((matches = windowRegexp.exec(path))) {
+      if (matches[1] in windows)
+        return;
+
+      let details = windowDetails.exec(matches[1]);
+      if (!details) {
+        console.error("Unable to parse window detail " + matches[1]);
+        return;
+      }
+
+      let item = {
+        path: matches[1],
+        location: details[1].replace(/\\/g, "/"),
+        source: [details[1].replace(/\\/g, "/")],
+        toString: function() {
+          return this.location;
+        }
+      };
+
+      if (!isPossibleLeak(item))
+        return;
+
+      windows[matches[1]] = item;
+    }
+  }
+
+  Cc["@mozilla.org/memory-reporter-manager;1"]
+    .getService(Ci.nsIMemoryReporterManager)
+    .getReportsForThisProcess(logReporter, null, /* anonymize = */ false);
+
+  return { compartments: compartments, windows: windows };
+}
+
+function nextIteration(tests) {
+  if (tests) {
+    results.passed += tests.passed;
+    results.failed += tests.failed;
+
+    reportMemoryUsage().then(_ => {
+      let testRun = [];
+      for (let test of tests.testRunSummary) {
+        let testCopy = {};
+        for (let info in test) {
+          testCopy[info] = test[info];
+        }
+        testRun.push(testCopy);
+      }
+
+      results.testRuns.push(testRun);
+      iterationsLeft--;
+
+      checkForEnd();
+    })
+  }
+  else {
+    checkForEnd();
+  }
+}
+
+function checkForEnd() {
+  if (iterationsLeft && (!stopOnError || results.failed == 0)) {
+    // Pass the loader which has a hooked console that doesn't dispatch
+    // errors to the JS console and avoid firing false alarm in our
+    // console listener
+    findAndRunTests(loader, nextIteration);
+  }
+  else {
+    setTimeout(cleanup, 0);
+  }
+}
+
+var POINTLESS_ERRORS = [
+  'Invalid chrome URI:',
+  'OpenGL LayerManager Initialized Succesfully.',
+  '[JavaScript Error: "TelemetryStopwatch:',
+  'reference to undefined property',
+  '[JavaScript Error: "The character encoding of the HTML document was ' +
+    'not declared.',
+  '[Javascript Warning: "Error: Failed to preserve wrapper of wrapped ' +
+    'native weak map key',
+  '[JavaScript Warning: "Duplicate resource declaration for',
+  'file: "chrome://browser/content/',
+  'file: "chrome://global/content/',
+  '[JavaScript Warning: "The character encoding of a framed document was ' +
+    'not declared.',
+  'file: "chrome://browser/skin/'
+];
+
+// These are messages that will cause a test to fail if logged through the
+// console service
+var IMPORTANT_ERRORS = [
+  'Sending message that cannot be cloned. Are you trying to send an XPCOM object?',
+];
+
+var consoleListener = {
+  registered: false,
+
+  register: function() {
+    if (this.registered)
+      return;
+    cService.registerListener(this);
+    this.registered = true;
+  },
+
+  unregister: function() {
+    if (!this.registered)
+      return;
+    cService.unregisterListener(this);
+    this.registered = false;
+  },
+
+  errorsLogged: 0,
+
+  observe: function(object) {
+    if (!(object instanceof Ci.nsIScriptError))
+      return;
+    this.errorsLogged++;
+    var message = object.QueryInterface(Ci.nsIConsoleMessage).message;
+    if (IMPORTANT_ERRORS.find(msg => message.indexOf(msg) >= 0)) {
+      testConsole.error(message);
+      return;
+    }
+    var pointless = POINTLESS_ERRORS.filter(err => message.indexOf(err) >= 0);
+    if (pointless.length == 0 && message)
+      testConsole.log(message);
+  }
+};
+
+function TestRunnerConsole(base, options) {
+  let proto = extend(base, {
+    errorsLogged: 0,
+    warn: function warn() {
+      this.errorsLogged++;
+      base.warn.apply(base, arguments);
+    },
+    error: function error() {
+      this.errorsLogged++;
+      base.error.apply(base, arguments);
+    },
+    info: function info(first) {
+      if (options.verbose)
+        base.info.apply(base, arguments);
+      else
+        if (first == "pass:")
+          print(".");
+    },
+  });
+  return Object.create(proto);
+}
+
+function stringify(arg) {
+  try {
+    return String(arg);
+  }
+  catch(ex) {
+    return "<toString() error>";
+  }
+}
+
+function stringifyArgs(args) {
+  return Array.map(args, stringify).join(" ");
+}
+
+function TestRunnerTinderboxConsole(base, options) {
+  this.base = base;
+  this.print = options.print;
+  this.verbose = options.verbose;
+  this.errorsLogged = 0;
+
+  // Binding all the public methods to an instance so that they can be used
+  // as callback / listener functions straightaway.
+  this.log = this.log.bind(this);
+  this.info = this.info.bind(this);
+  this.warn = this.warn.bind(this);
+  this.error = this.error.bind(this);
+  this.debug = this.debug.bind(this);
+  this.exception = this.exception.bind(this);
+  this.trace = this.trace.bind(this);
+};
+
+TestRunnerTinderboxConsole.prototype = {
+  testMessage: function testMessage(pass, expected, test, message) {
+    let type = "TEST-";
+    if (expected) {
+      if (pass)
+        type += "PASS";
+      else
+        type += "KNOWN-FAIL";
+    }
+    else {
+      this.errorsLogged++;
+      if (pass)
+        type += "UNEXPECTED-PASS";
+      else
+        type += "UNEXPECTED-FAIL";
+    }
+
+    this.print(type + " | " + test + " | " + message + "\n");
+    if (!expected)
+      this.trace();
+  },
+
+  log: function log() {
+    this.print("TEST-INFO | " + stringifyArgs(arguments) + "\n");
+  },
+
+  info: function info(first) {
+    this.print("TEST-INFO | " + stringifyArgs(arguments) + "\n");
+  },
+
+  warn: function warn() {
+    this.errorsLogged++;
+    this.print("TEST-UNEXPECTED-FAIL | " + stringifyArgs(arguments) + "\n");
+  },
+
+  error: function error() {
+    this.errorsLogged++;
+    this.print("TEST-UNEXPECTED-FAIL | " + stringifyArgs(arguments) + "\n");
+    this.base.error.apply(this.base, arguments);
+  },
+
+  debug: function debug() {
+    this.print("TEST-INFO | " + stringifyArgs(arguments) + "\n");
+  },
+
+  exception: function exception(e) {
+    this.print("An exception occurred.\n" +
+               require("../console/traceback").format(e) + "\n" + e + "\n");
+  },
+
+  trace: function trace() {
+    var traceback = require("../console/traceback");
+    var stack = traceback.get();
+    stack.splice(-1, 1);
+    this.print("TEST-INFO | " + stringify(traceback.format(stack)) + "\n");
+  }
+};
+
+var runTests = exports.runTests = function runTests(options) {
+  iterationsLeft = options.iterations;
+  profileMemory = options.profileMemory;
+  stopOnError = options.stopOnError;
+  onDone = options.onDone;
+  print = options.print;
+  findAndRunTests = options.findAndRunTests;
+
+  results = {
+    passed: 0,
+    failed: 0,
+    testRuns: []
+  };
+
+  try {
+    consoleListener.register();
+    print("Running tests on " + system.name + " " + system.version +
+          "/Gecko " + system.platformVersion + " (Build " +
+          system.build + ") (" + system.id + ") under " +
+          system.platform + "/" + system.architecture + ".\n");
+
+    if (options.parseable)
+      testConsole = new TestRunnerTinderboxConsole(new PlainTextConsole(), options);
+    else
+      testConsole = new TestRunnerConsole(new PlainTextConsole(), options);
+
+    loader = Loader(module, {
+      console: testConsole,
+      global: {} // useful for storing things like coverage testing.
+    });
+
+    // Load these before getting initial leak stats as they will still be in
+    // memory when we check later
+    require("../deprecated/unit-test");
+    require("../deprecated/unit-test-finder");
+    if (profileMemory)
+      startLeaks = getPotentialLeaks();
+
+    nextIteration();
+  } catch (e) {
+    let frames = fromException(e).reverse().reduce(function(frames, frame) {
+      if (frame.fileName.split("/").pop() === "unit-test-finder.js")
+        frames.done = true
+      if (!frames.done) frames.push(frame)
+
+      return frames
+    }, [])
+
+    let prototype = typeof(e) === "object" ? e.constructor.prototype :
+                    Error.prototype;
+    let stack = serializeStack(frames.reverse());
+
+    let error = Object.create(prototype, {
+      message: { value: e.message, writable: true, configurable: true },
+      fileName: { value: e.fileName, writable: true, configurable: true },
+      lineNumber: { value: e.lineNumber, writable: true, configurable: true },
+      stack: { value: stack, writable: true, configurable: true },
+      toString: { value: () => String(e), writable: true, configurable: true },
+    });
+
+    print("Error: " + error + " \n " + format(error));
+    onDone({passed: 0, failed: 1});
+  }
+};
+
+unload(_ => consoleListener.unregister());
diff --git a/toolkit/jetpack/sdk/test/httpd.js b/toolkit/jetpack/sdk/test/httpd.js
new file mode 100644
index 000000000..218493924
--- /dev/null
+++ b/toolkit/jetpack/sdk/test/httpd.js
@@ -0,0 +1,6 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+throw new Error(`This file was removed. A copy can be obtained from:
+  https://github.com/mozilla/addon-sdk/blob/master/test/lib/httpd.js`);
diff --git a/toolkit/jetpack/sdk/test/loader.js b/toolkit/jetpack/sdk/test/loader.js
new file mode 100644
index 000000000..33ba2ca5a
--- /dev/null
+++ b/toolkit/jetpack/sdk/test/loader.js
@@ -0,0 +1,123 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { resolveURI, Require,
+        unload, override, descriptor } = require('../../toolkit/loader');
+const { ensure } = require('../system/unload');
+const addonWindow = require('../addon/window');
+const { PlainTextConsole } = require('sdk/console/plain-text');
+
+var defaultGlobals = override(require('../system/globals'), {
+  console: console
+});
+
+function CustomLoader(module, globals, packaging, overrides={}) {
+  let options = packaging || require("@loader/options");
+  options = override(options, {
+    id: overrides.id || options.id,
+    globals: override(defaultGlobals, globals || {}),
+    modules: override(override(options.modules || {}, overrides.modules || {}), {
+      'sdk/addon/window': addonWindow
+    })
+  });
+
+  let loaderModule = options.isNative ? '../../toolkit/loader' : '../loader/cuddlefish';
+  let { Loader } = require(loaderModule);
+  let loader = Loader(options);
+  let wrapper = Object.create(loader, descriptor({
+    require: Require(loader, module),
+    sandbox: function(id) {
+      let requirement = loader.resolve(id, module.id);
+      if (!requirement)
+        requirement = id;
+      let uri = resolveURI(requirement, loader.mapping);
+      return loader.sandboxes[uri];
+    },
+    unload: function(reason) {
+      unload(loader, reason);
+    }
+  }));
+  ensure(wrapper);
+  return wrapper;
+};
+exports.Loader = CustomLoader;
+
+function HookedPlainTextConsole(hook, print, innerID) {
+  this.log = hook.bind(null, "log", innerID);
+  this.info = hook.bind(null, "info", innerID);
+  this.warn = hook.bind(null, "warn", innerID);
+  this.error = hook.bind(null, "error", innerID);
+  this.debug = hook.bind(null, "debug", innerID);
+  this.exception = hook.bind(null, "exception", innerID);
+  this.time = hook.bind(null, "time", innerID);
+  this.timeEnd = hook.bind(null, "timeEnd", innerID);
+
+  this.__exposedProps__ = {
+    log: "rw", info: "rw", warn: "rw", error: "rw", debug: "rw",
+    exception: "rw", time: "rw", timeEnd: "rw"
+  };
+}
+
+// Creates a custom loader instance whose console module is hooked in order
+// to avoid printing messages to the console, and instead, expose them in the
+// returned `messages` array attribute
+exports.LoaderWithHookedConsole = function (module, callback) {
+  let messages = [];
+  function hook(type, innerID, msg) {
+    messages.push({ type: type, msg: msg, innerID: innerID });
+    if (callback)
+      callback(type, msg, innerID);
+  }
+
+  return {
+    loader: CustomLoader(module, {
+      console: new HookedPlainTextConsole(hook, null, null)
+    }, null, {
+      modules: {
+        'sdk/console/plain-text': {
+          PlainTextConsole: HookedPlainTextConsole.bind(null, hook)
+        }
+      }
+    }),
+    messages: messages
+  };
+}
+
+// Same than LoaderWithHookedConsole with lower level, instead we get what is
+// actually printed to the command line console
+exports.LoaderWithHookedConsole2 = function (module, callback) {
+  let messages = [];
+  return {
+    loader: CustomLoader(module, {
+      console: new PlainTextConsole(function (msg) {
+        messages.push(msg);
+        if (callback)
+          callback(msg);
+      })
+    }),
+    messages: messages
+  };
+}
+
+// Creates a custom loader with a filtered console. The callback is passed every
+// console message type and message and if it returns false the message will
+// not be logged normally
+exports.LoaderWithFilteredConsole = function (module, callback) {
+  function hook(type, innerID, msg) {
+    if (callback && callback(type, msg, innerID) == false)
+      return;
+    console[type](msg);
+  }
+
+  return CustomLoader(module, {
+    console: new HookedPlainTextConsole(hook, null, null)
+  }, null, {
+    modules: {
+      'sdk/console/plain-text': {
+        PlainTextConsole: HookedPlainTextConsole.bind(null, hook)
+      }
+    }
+  });
+}
diff --git a/toolkit/jetpack/sdk/test/memory.js b/toolkit/jetpack/sdk/test/memory.js
new file mode 100644
index 000000000..bd1198bfe
--- /dev/null
+++ b/toolkit/jetpack/sdk/test/memory.js
@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { Cu } = require("chrome");
+
+function gc() {
+  return new Promise(resolve => Cu.schedulePreciseGC(resolve));
+}
+exports.gc = gc;
diff --git a/toolkit/jetpack/sdk/test/options.js b/toolkit/jetpack/sdk/test/options.js
new file mode 100644
index 000000000..9bc611ca5
--- /dev/null
+++ b/toolkit/jetpack/sdk/test/options.js
@@ -0,0 +1,23 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const options = require("@test/options");
+const { id } = require("../self");
+const { get } = require("../preferences/service");
+
+const readPref = (key) => get("extensions." + id + ".sdk." + key);
+
+exports.iterations = readPref("test.iterations") || options.iterations;
+exports.filter = readPref("test.filter") || options.filter;
+exports.profileMemory = readPref("profile.memory") || options.profileMemory;
+exports.stopOnError = readPref("test.stop") || options.stopOnError;
+exports.keepOpen = readPref("test.keepOpen") || false;
+exports.verbose = (readPref("output.logLevel") == "verbose") || options.verbose;
+exports.parseable = (readPref("output.format") == "tbpl") || options.parseable;
+exports.checkMemory = readPref("profile.leaks") || options.check_memory;
diff --git a/toolkit/jetpack/sdk/test/runner.js b/toolkit/jetpack/sdk/test/runner.js
new file mode 100644
index 000000000..ea37ac84f
--- /dev/null
+++ b/toolkit/jetpack/sdk/test/runner.js
@@ -0,0 +1,131 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+var { exit, stdout } = require("../system");
+var cfxArgs = require("../test/options");
+var events = require("../system/events");
+const { resolve } = require("../core/promise");
+
+function runTests(findAndRunTests) {
+  var harness = require("./harness");
+
+  function onDone(tests) {
+    stdout.write("\n");
+    var total = tests.passed + tests.failed;
+    stdout.write(tests.passed + " of " + total + " tests passed.\n");
+
+    events.emit("sdk:test:results", { data: JSON.stringify(tests) });
+
+    if (tests.failed == 0) {
+      if (tests.passed === 0)
+        stdout.write("No tests were run\n");
+      if (!cfxArgs.keepOpen)
+        exit(0);
+    } else {
+      if (cfxArgs.verbose || cfxArgs.parseable)
+        printFailedTests(tests, stdout.write);
+      if (!cfxArgs.keepOpen)
+        exit(1);
+    }
+  };
+
+  // We may have to run test on next cycle, otherwise XPCOM components
+  // are not correctly updated.
+  // For ex: nsIFocusManager.getFocusedElementForWindow may throw
+  // NS_ERROR_ILLEGAL_VALUE exception.
+  require("../timers").setTimeout(_ => harness.runTests({
+    findAndRunTests: findAndRunTests,
+    iterations: cfxArgs.iterations || 1,
+    filter: cfxArgs.filter,
+    profileMemory: cfxArgs.profileMemory,
+    stopOnError: cfxArgs.stopOnError,
+    verbose: cfxArgs.verbose,
+    parseable: cfxArgs.parseable,
+    print: stdout.write,
+    onDone: onDone
+  }));
+}
+
+function printFailedTests(tests, print) {
+  let iterationNumber = 0;
+  let singleIteration = (tests.testRuns || []).length == 1;
+  let padding = singleIteration ? "" : "  ";
+
+  print("\nThe following tests failed:\n");
+
+  for (let testRun of tests.testRuns) {
+    iterationNumber++;
+
+    if (!singleIteration)
+      print("  Iteration " + iterationNumber + ":\n");
+
+    for (let test of testRun) {
+      if (test.failed > 0) {
+        print(padding + "  " + test.name + ": " + test.errors +"\n");
+      }
+    }
+    print("\n");
+  }
+}
+
+function main() {
+  var testsStarted = false;
+
+  if (!testsStarted) {
+    testsStarted = true;
+    runTests(function findAndRunTests(loader, nextIteration) {
+      loader.require("../deprecated/unit-test").findAndRunTests({
+        testOutOfProcess: false,
+        testInProcess: true,
+        stopOnError: cfxArgs.stopOnError,
+        filter: cfxArgs.filter,
+        onDone: nextIteration
+      });
+    });
+  }
+};
+
+if (require.main === module)
+  main();
+
+exports.runTestsFromModule = function runTestsFromModule(module) {
+  let id = module.id;
+  // Make a copy of exports as it may already be frozen by module loader
+  let exports = {};
+  Object.keys(module.exports).forEach(key => {
+    exports[key] = module.exports[key];
+  });
+
+  runTests(function findAndRunTests(loader, nextIteration) {
+    // Consider that all these tests are CommonJS ones
+    loader.require('../../test').run(exports);
+
+    // Reproduce what is done in sdk/deprecated/unit-test-finder.findTests()
+    let tests = [];
+    for (let name of Object.keys(exports).sort()) {
+      tests.push({
+        setup: exports.setup,
+        teardown: exports.teardown,
+        testFunction: exports[name],
+        name: id + "." + name
+      });
+    }
+
+    // Reproduce what is done by unit-test.findAndRunTests()
+    var { TestRunner } = loader.require("../deprecated/unit-test");
+    var runner = new TestRunner();
+    runner.startMany({
+      tests: {
+        getNext: () => resolve(tests.shift())
+      },
+      stopOnError: cfxArgs.stopOnError,
+      onDone: nextIteration
+    });
+  });
+}
diff --git a/toolkit/jetpack/sdk/test/utils.js b/toolkit/jetpack/sdk/test/utils.js
new file mode 100644
index 000000000..b01df67d4
--- /dev/null
+++ b/toolkit/jetpack/sdk/test/utils.js
@@ -0,0 +1,199 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+const { defer } = require('../core/promise');
+const { setInterval, clearInterval } = require('../timers');
+const { getTabs, closeTab } = require("../tabs/utils");
+const { windows: getWindows } = require("../window/utils");
+const { close: closeWindow } = require("../window/helpers");
+const { isGenerator } = require("../lang/type");
+const { env } = require("../system/environment");
+const { Task } = require("resource://gre/modules/Task.jsm");
+
+const getTestNames = (exports) =>
+  Object.keys(exports).filter(name => /^test/.test(name));
+
+const isTestAsync = ({length}) => length > 1;
+const isHelperAsync = ({length}) => length > 2;
+
+/*
+ * Takes an `exports` object of a test file and a function `beforeFn`
+ * to be run before each test. `beforeFn` is called with a `name` string
+ * as the first argument of the test name, and may specify a second
+ * argument function `done` to indicate that this function should
+ * resolve asynchronously
+ */
+function before (exports, beforeFn) {
+  getTestNames(exports).map(name => {
+    let testFn = exports[name];
+
+    // GENERATOR TESTS
+    if (isGenerator(testFn) && isGenerator(beforeFn)) {
+      exports[name] = function*(assert) {
+        yield Task.spawn(beforeFn.bind(null, name, assert));
+        yield Task.spawn(testFn.bind(null, assert));
+      }
+    }
+    else if (isGenerator(testFn) && !isHelperAsync(beforeFn)) {
+      exports[name] = function*(assert) {
+        beforeFn(name, assert);
+        yield Task.spawn(testFn.bind(null, assert));
+      }
+    }
+    else if (isGenerator(testFn) && isHelperAsync(beforeFn)) {
+      exports[name] = function*(assert) {
+        yield new Promise(resolve => beforeFn(name, assert, resolve));
+        yield Task.spawn(testFn.bind(null, assert));
+      }
+    }
+    // SYNC TESTS
+    else if (!isTestAsync(testFn) && isGenerator(beforeFn)) {
+      exports[name] = function*(assert) {
+        yield Task.spawn(beforeFn.bind(null, name, assert));
+        testFn(assert);
+      };
+    }
+    else if (!isTestAsync(testFn) && !isHelperAsync(beforeFn)) {
+      exports[name] = function (assert) {
+        beforeFn(name, assert);
+        testFn(assert);
+      };
+    }
+    else if (!isTestAsync(testFn) && isHelperAsync(beforeFn)) {
+      exports[name] = function (assert, done) {
+        beforeFn(name, assert, () => {
+          testFn(assert);
+          done();
+        });
+      };
+    }
+    // ASYNC TESTS
+    else if (isTestAsync(testFn) && isGenerator(beforeFn)) {
+      exports[name] = function*(assert) {
+        yield Task.spawn(beforeFn.bind(null, name, assert));
+        yield new Promise(resolve => testFn(assert, resolve));
+      };
+    }
+    else if (isTestAsync(testFn) && !isHelperAsync(beforeFn)) {
+      exports[name] = function (assert, done) {
+        beforeFn(name, assert);
+        testFn(assert, done);
+      };
+    }
+    else if (isTestAsync(testFn) && isHelperAsync(beforeFn)) {
+      exports[name] = function (assert, done) {
+        beforeFn(name, assert, () => {
+          testFn(assert, done);
+        });
+      };
+    }
+  });
+}
+exports.before = before;
+
+/*
+ * Takes an `exports` object of a test file and a function `afterFn`
+ * to be run after each test. `afterFn` is called with a `name` string
+ * as the first argument of the test name, and may specify a second
+ * argument function `done` to indicate that this function should
+ * resolve asynchronously
+ */
+function after (exports, afterFn) {
+  getTestNames(exports).map(name => {
+    let testFn = exports[name];
+
+    // GENERATOR TESTS
+    if (isGenerator(testFn) && isGenerator(afterFn)) {
+      exports[name] = function*(assert) {
+        yield Task.spawn(testFn.bind(null, assert));
+        yield Task.spawn(afterFn.bind(null, name, assert));
+      }
+    }
+    else if (isGenerator(testFn) && !isHelperAsync(afterFn)) {
+      exports[name] = function*(assert) {
+        yield Task.spawn(testFn.bind(null, assert));
+        afterFn(name, assert);
+      }
+    }
+    else if (isGenerator(testFn) && isHelperAsync(afterFn)) {
+      exports[name] = function*(assert) {
+        yield Task.spawn(testFn.bind(null, assert));
+        yield new Promise(resolve => afterFn(name, assert, resolve));
+      }
+    }
+    // SYNC TESTS
+    else if (!isTestAsync(testFn) && isGenerator(afterFn)) {
+      exports[name] = function*(assert) {
+        testFn(assert);
+        yield Task.spawn(afterFn.bind(null, name, assert));
+      };
+    }
+    else if (!isTestAsync(testFn) && !isHelperAsync(afterFn)) {
+      exports[name] = function (assert) {
+        testFn(assert);
+        afterFn(name, assert);
+      };
+    }
+    else if (!isTestAsync(testFn) && isHelperAsync(afterFn)) {
+      exports[name] = function (assert, done) {
+        testFn(assert);
+        afterFn(name, assert, done);
+      };
+    }
+    // ASYNC TESTS
+    else if (isTestAsync(testFn) && isGenerator(afterFn)) {
+      exports[name] = function*(assert) {
+        yield new Promise(resolve => testFn(assert, resolve));
+        yield Task.spawn(afterFn.bind(null, name, assert));
+      };
+    }
+    else if (isTestAsync(testFn) && !isHelperAsync(afterFn)) {
+      exports[name] = function*(assert) {
+        yield new Promise(resolve => testFn(assert, resolve));
+        afterFn(name, assert);
+      };
+    }
+    else if (isTestAsync(testFn) && isHelperAsync(afterFn)) {
+      exports[name] = function*(assert) {
+        yield new Promise(resolve => testFn(assert, resolve));
+        yield new Promise(resolve => afterFn(name, assert, resolve));
+      };
+    }
+  });
+}
+exports.after = after;
+
+function waitUntil (predicate, delay) {
+  let { promise, resolve } = defer();
+  let interval = setInterval(() => {
+    if (!predicate()) return;
+    clearInterval(interval);
+    resolve();
+  }, delay || 10);
+  return promise;
+}
+exports.waitUntil = waitUntil;
+
+var cleanUI = function cleanUI() {
+  let { promise, resolve } = defer();
+
+  let windows = getWindows(null, { includePrivate: true });
+  if (windows.length > 1) {
+    return closeWindow(windows[1]).then(cleanUI);
+  }
+
+  getTabs(windows[0]).slice(1).forEach(closeTab);
+
+  resolve();
+
+  return promise;
+}
+exports.cleanUI = cleanUI;
+
+exports.isTravisCI = ("TRAVIS" in env && "CI" in env);
diff --git a/toolkit/jetpack/sdk/timers.js b/toolkit/jetpack/sdk/timers.js
new file mode 100644
index 000000000..e97db01f2
--- /dev/null
+++ b/toolkit/jetpack/sdk/timers.js
@@ -0,0 +1,105 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "stable"
+};
+
+const { CC, Cc, Ci } = require("chrome");
+const { when: unload } = require("./system/unload");
+
+const { TYPE_ONE_SHOT, TYPE_REPEATING_SLACK } = Ci.nsITimer;
+const Timer = CC("@mozilla.org/timer;1", "nsITimer");
+const timers = Object.create(null);
+const threadManager = Cc["@mozilla.org/thread-manager;1"].
+                      getService(Ci.nsIThreadManager);
+const prefBranch = Cc["@mozilla.org/preferences-service;1"].
+                    getService(Ci.nsIPrefService).
+                    QueryInterface(Ci.nsIPrefBranch);
+
+var MIN_DELAY = 4;
+// Try to get min timeout delay used by browser.
+try { MIN_DELAY = prefBranch.getIntPref("dom.min_timeout_value"); } finally {}
+
+
+// Last timer id.
+var lastID = 0;
+
+// Sets typer either by timeout or by interval
+// depending on a given type.
+function setTimer(type, callback, delay, ...args) {
+  let id = ++ lastID;
+  let timer = timers[id] = Timer();
+  timer.initWithCallback({
+    notify: function notify() {
+      try {
+        if (type === TYPE_ONE_SHOT)
+          delete timers[id];
+        callback.apply(null, args);
+      }
+      catch(error) {
+        console.exception(error);
+      }
+    }
+  }, Math.max(delay || MIN_DELAY), type);
+  return id;
+}
+
+function unsetTimer(id) {
+  let timer = timers[id];
+  delete timers[id];
+  if (timer) timer.cancel();
+}
+
+var immediates = new Map();
+
+var dispatcher = _ => {
+  // Allow scheduling of a new dispatch loop.
+  dispatcher.scheduled = false;
+  // Take a snapshot of timer `id`'s that have being present before
+  // starting a dispatch loop, in order to ignore timers registered
+  // in side effect to dispatch while also skipping immediates that
+  // were removed in side effect.
+  let ids = [...immediates.keys()];
+  for (let id of ids) {
+    let immediate = immediates.get(id);
+    if (immediate) {
+      immediates.delete(id);
+      try { immediate(); }
+      catch (error) { console.exception(error); }
+    }
+  }
+}
+
+function setImmediate(callback, ...params) {
+  let id = ++ lastID;
+  // register new immediate timer with curried params.
+  immediates.set(id, _ => callback.apply(callback, params));
+  // if dispatch loop is not scheduled schedule one. Own scheduler
+  if (!dispatcher.scheduled) {
+    dispatcher.scheduled = true;
+    threadManager.currentThread.dispatch(dispatcher,
+                                         Ci.nsIThread.DISPATCH_NORMAL);
+  }
+  return id;
+}
+
+function clearImmediate(id) {
+  immediates.delete(id);
+}
+
+// Bind timers so that toString-ing them looks same as on native timers.
+exports.setImmediate = setImmediate.bind(null);
+exports.clearImmediate = clearImmediate.bind(null);
+exports.setTimeout = setTimer.bind(null, TYPE_ONE_SHOT);
+exports.setInterval = setTimer.bind(null, TYPE_REPEATING_SLACK);
+exports.clearTimeout = unsetTimer.bind(null);
+exports.clearInterval = unsetTimer.bind(null);
+
+// all timers are cleared out on unload.
+unload(function() {
+  immediates.clear();
+  Object.keys(timers).forEach(unsetTimer)
+});
diff --git a/toolkit/jetpack/sdk/ui.js b/toolkit/jetpack/sdk/ui.js
new file mode 100644
index 000000000..7f9110b26
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui.js
@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental',
+  'engines': {
+    'Firefox': '> 28'
+  }
+};
+
+exports.ActionButton = require('./ui/button/action').ActionButton;
+exports.ToggleButton = require('./ui/button/toggle').ToggleButton;
+exports.Sidebar = require('./ui/sidebar').Sidebar;
+exports.Frame = require('./ui/frame').Frame;
+exports.Toolbar = require('./ui/toolbar').Toolbar;
diff --git a/toolkit/jetpack/sdk/ui/button/action.js b/toolkit/jetpack/sdk/ui/button/action.js
new file mode 100644
index 000000000..dfb092d0c
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/button/action.js
@@ -0,0 +1,114 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental',
+  'engines': {
+    'Firefox': '> 28'
+  }
+};
+
+const { Class } = require('../../core/heritage');
+const { merge } = require('../../util/object');
+const { Disposable } = require('../../core/disposable');
+const { on, off, emit, setListeners } = require('../../event/core');
+const { EventTarget } = require('../../event/target');
+const { getNodeView } = require('../../view/core');
+
+const view = require('./view');
+const { buttonContract, stateContract } = require('./contract');
+const { properties, render, state, register, unregister,
+        getDerivedStateFor } = require('../state');
+const { events: stateEvents } = require('../state/events');
+const { events: viewEvents } = require('./view/events');
+const events = require('../../event/utils');
+
+const { getActiveTab } = require('../../tabs/utils');
+
+const { id: addonID } = require('../../self');
+const { identify } = require('../id');
+
+const buttons = new Map();
+
+const toWidgetId = id =>
+  ('action-button--' + addonID.toLowerCase()+ '-' + id).
+    replace(/[^a-z0-9_-]/g, '');
+
+const ActionButton = Class({
+  extends: EventTarget,
+  implements: [
+    properties(stateContract),
+    state(stateContract),
+    Disposable
+  ],
+  setup: function setup(options) {
+    let state = merge({
+      disabled: false
+    }, buttonContract(options));
+
+    let id = toWidgetId(options.id);
+
+    register(this, state);
+
+    // Setup listeners.
+    setListeners(this, options);
+
+    buttons.set(id, this);
+
+    view.create(merge({}, state, { id: id }));
+  },
+
+  dispose: function dispose() {
+    let id = toWidgetId(this.id);
+    buttons.delete(id);
+
+    off(this);
+
+    view.dispose(id);
+
+    unregister(this);
+  },
+
+  get id() {
+    return this.state().id;
+  },
+
+  click: function click() { view.click(toWidgetId(this.id)) }
+});
+exports.ActionButton = ActionButton;
+
+identify.define(ActionButton, ({id}) => toWidgetId(id));
+
+getNodeView.define(ActionButton, button =>
+  view.nodeFor(toWidgetId(button.id))
+);
+
+var actionButtonStateEvents = events.filter(stateEvents,
+  e => e.target instanceof ActionButton);
+
+var actionButtonViewEvents = events.filter(viewEvents,
+  e => buttons.has(e.target));
+
+var clickEvents = events.filter(actionButtonViewEvents, e => e.type === 'click');
+var updateEvents = events.filter(actionButtonViewEvents, e => e.type === 'update');
+
+on(clickEvents, 'data', ({target: id, window}) => {
+  let button = buttons.get(id);
+  let state = getDerivedStateFor(button, getActiveTab(window));
+
+  emit(button, 'click', state);
+});
+
+on(updateEvents, 'data', ({target: id, window}) => {
+  render(buttons.get(id), window);
+});
+
+on(actionButtonStateEvents, 'data', ({target, window, state}) => {
+  let id = toWidgetId(target.id);
+  view.setIcon(id, window, state.icon);
+  view.setLabel(id, window, state.label);
+  view.setDisabled(id, window, state.disabled);
+  view.setBadge(id, window, state.badge, state.badgeColor);
+});
diff --git a/toolkit/jetpack/sdk/ui/button/contract.js b/toolkit/jetpack/sdk/ui/button/contract.js
new file mode 100644
index 000000000..ce6e33d95
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/button/contract.js
@@ -0,0 +1,73 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { contract } = require('../../util/contract');
+const { isLocalURL } = require('../../url');
+const { isNil, isObject, isString } = require('../../lang/type');
+const { required, either, string, boolean, object, number } = require('../../deprecated/api-utils');
+const { merge } = require('../../util/object');
+const { freeze } = Object;
+
+const isIconSet = (icons) =>
+  Object.keys(icons).
+    every(size => String(size >>> 0) === size && isLocalURL(icons[size]));
+
+var iconSet = {
+  is: either(object, string),
+  map: v => isObject(v) ? freeze(merge({}, v)) : v,
+  ok: v => (isString(v) && isLocalURL(v)) || (isObject(v) && isIconSet(v)),
+  msg: 'The option "icon" must be a local URL or an object with ' +
+    'numeric keys / local URL values pair.'
+}
+
+var id = {
+  is: string,
+  ok: v => /^[a-z-_][a-z0-9-_]*$/i.test(v),
+  msg: 'The option "id" must be a valid alphanumeric id (hyphens and ' +
+        'underscores are allowed).'
+};
+
+var label = {
+  is: string,
+  ok: v => isNil(v) || v.trim().length > 0,
+  msg: 'The option "label" must be a non empty string'
+}
+
+var badge = {
+  is: either(string, number),
+  msg: 'The option "badge" must be a string or a number'
+}
+
+var badgeColor = {
+  is: string,
+  msg: 'The option "badgeColor" must be a string'
+}
+
+var stateContract = contract({
+  label: label,
+  icon: iconSet,
+  disabled: boolean,
+  badge: badge,
+  badgeColor: badgeColor
+});
+
+exports.stateContract = stateContract;
+
+var buttonContract = contract(merge({}, stateContract.rules, {
+  id: required(id),
+  label: required(label),
+  icon: required(iconSet)
+}));
+
+exports.buttonContract = buttonContract;
+
+exports.toggleStateContract = contract(merge({
+  checked: boolean
+}, stateContract.rules));
+
+exports.toggleButtonContract = contract(merge({
+  checked: boolean
+}, buttonContract.rules));
+
diff --git a/toolkit/jetpack/sdk/ui/button/toggle.js b/toolkit/jetpack/sdk/ui/button/toggle.js
new file mode 100644
index 000000000..a226b3212
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/button/toggle.js
@@ -0,0 +1,127 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental',
+  'engines': {
+    'Firefox': '> 28'
+  }
+};
+
+const { Class } = require('../../core/heritage');
+const { merge } = require('../../util/object');
+const { Disposable } = require('../../core/disposable');
+const { on, off, emit, setListeners } = require('../../event/core');
+const { EventTarget } = require('../../event/target');
+const { getNodeView } = require('../../view/core');
+
+const view = require('./view');
+const { toggleButtonContract, toggleStateContract } = require('./contract');
+const { properties, render, state, register, unregister,
+  setStateFor, getStateFor, getDerivedStateFor } = require('../state');
+const { events: stateEvents } = require('../state/events');
+const { events: viewEvents } = require('./view/events');
+const events = require('../../event/utils');
+
+const { getActiveTab } = require('../../tabs/utils');
+
+const { id: addonID } = require('../../self');
+const { identify } = require('../id');
+
+const buttons = new Map();
+
+const toWidgetId = id =>
+  ('toggle-button--' + addonID.toLowerCase()+ '-' + id).
+    replace(/[^a-z0-9_-]/g, '');
+
+const ToggleButton = Class({
+  extends: EventTarget,
+  implements: [
+    properties(toggleStateContract),
+    state(toggleStateContract),
+    Disposable
+  ],
+  setup: function setup(options) {
+    let state = merge({
+      disabled: false,
+      checked: false
+    }, toggleButtonContract(options));
+
+    let id = toWidgetId(options.id);
+
+    register(this, state);
+
+    // Setup listeners.
+    setListeners(this, options);
+
+    buttons.set(id, this);
+
+    view.create(merge({ type: 'checkbox' }, state, { id: id }));
+  },
+
+  dispose: function dispose() {
+    let id = toWidgetId(this.id);
+    buttons.delete(id);
+
+    off(this);
+
+    view.dispose(id);
+
+    unregister(this);
+  },
+
+  get id() {
+    return this.state().id;
+  },
+
+  click: function click() {
+    return view.click(toWidgetId(this.id));
+  }
+});
+exports.ToggleButton = ToggleButton;
+
+identify.define(ToggleButton, ({id}) => toWidgetId(id));
+
+getNodeView.define(ToggleButton, button =>
+  view.nodeFor(toWidgetId(button.id))
+);
+
+var toggleButtonStateEvents = events.filter(stateEvents,
+  e => e.target instanceof ToggleButton);
+
+var toggleButtonViewEvents = events.filter(viewEvents,
+  e => buttons.has(e.target));
+
+var clickEvents = events.filter(toggleButtonViewEvents, e => e.type === 'click');
+var updateEvents = events.filter(toggleButtonViewEvents, e => e.type === 'update');
+
+on(toggleButtonStateEvents, 'data', ({target, window, state}) => {
+  let id = toWidgetId(target.id);
+
+  view.setIcon(id, window, state.icon);
+  view.setLabel(id, window, state.label);
+  view.setDisabled(id, window, state.disabled);
+  view.setChecked(id, window, state.checked);
+  view.setBadge(id, window, state.badge, state.badgeColor);
+});
+
+on(clickEvents, 'data', ({target: id, window, checked }) => {
+  let button = buttons.get(id);
+  let windowState = getStateFor(button, window);
+
+  let newWindowState = merge({}, windowState, { checked: checked });
+
+  setStateFor(button, window, newWindowState);
+
+  let state = getDerivedStateFor(button, getActiveTab(window));
+
+  emit(button, 'click', state);
+
+  emit(button, 'change', state);
+});
+
+on(updateEvents, 'data', ({target: id, window}) => {
+  render(buttons.get(id), window);
+});
diff --git a/toolkit/jetpack/sdk/ui/button/view.js b/toolkit/jetpack/sdk/ui/button/view.js
new file mode 100644
index 000000000..63b7aea31
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/button/view.js
@@ -0,0 +1,243 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental',
+  'engines': {
+    'Firefox': '> 28'
+  }
+};
+
+const { Cu } = require('chrome');
+const { on, off, emit } = require('../../event/core');
+
+const { data } = require('sdk/self');
+
+const { isObject, isNil } = require('../../lang/type');
+
+const { getMostRecentBrowserWindow } = require('../../window/utils');
+const { ignoreWindow } = require('../../private-browsing/utils');
+const { CustomizableUI } = Cu.import('resource:///modules/CustomizableUI.jsm', {});
+const { AREA_PANEL, AREA_NAVBAR } = CustomizableUI;
+
+const { events: viewEvents } = require('./view/events');
+
+const XUL_NS = 'http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul';
+
+const views = new Map();
+const customizedWindows = new WeakMap();
+
+const buttonListener = {
+  onCustomizeStart: window => {
+    for (let [id, view] of views) {
+      setIcon(id, window, view.icon);
+      setLabel(id, window, view.label);
+    }
+
+    customizedWindows.set(window, true);
+  },
+  onCustomizeEnd: window => {
+    customizedWindows.delete(window);
+
+    for (let [id, ] of views) {
+      let placement = CustomizableUI.getPlacementOfWidget(id);
+
+      if (placement)
+        emit(viewEvents, 'data', { type: 'update', target: id, window: window });
+    }
+  },
+  onWidgetAfterDOMChange: (node, nextNode, container) => {
+    let { id } = node;
+    let view = views.get(id);
+    let window = node.ownerDocument.defaultView;
+
+    if (view) {
+      emit(viewEvents, 'data', { type: 'update', target: id, window: window });
+    }
+  }
+};
+
+CustomizableUI.addListener(buttonListener);
+
+require('../../system/unload').when( _ =>
+  CustomizableUI.removeListener(buttonListener)
+);
+
+function getNode(id, window) {
+  return !views.has(id) || ignoreWindow(window)
+    ? null
+    : CustomizableUI.getWidget(id).forWindow(window).node
+};
+
+function isInToolbar(id) {
+  let placement = CustomizableUI.getPlacementOfWidget(id);
+
+  return placement && CustomizableUI.getAreaType(placement.area) === 'toolbar';
+}
+
+
+function getImage(icon, isInToolbar, pixelRatio) {
+  let targetSize = (isInToolbar ? 18 : 32) * pixelRatio;
+  let bestSize = 0;
+  let image = icon;
+
+  if (isObject(icon)) {
+    for (let size of Object.keys(icon)) {
+      size = +size;
+      let offset = targetSize - size;
+
+      if (offset === 0) {
+        bestSize = size;
+        break;
+      }
+
+      let delta = Math.abs(offset) - Math.abs(targetSize - bestSize);
+
+      if (delta < 0)
+        bestSize = size;
+    }
+
+    image = icon[bestSize];
+  }
+
+  if (image.indexOf('./') === 0)
+    return data.url(image.substr(2));
+
+  return image;
+}
+
+function nodeFor(id, window=getMostRecentBrowserWindow()) {
+  return customizedWindows.has(window) ? null : getNode(id, window);
+};
+exports.nodeFor = nodeFor;
+
+function create(options) {
+  let { id, label, icon, type, badge } = options;
+
+  if (views.has(id))
+    throw new Error('The ID "' + id + '" seems already used.');
+
+  CustomizableUI.createWidget({
+    id: id,
+    type: 'custom',
+    removable: true,
+    defaultArea: AREA_NAVBAR,
+    allowedAreas: [ AREA_PANEL, AREA_NAVBAR ],
+
+    onBuild: function(document) {
+      let window = document.defaultView;
+
+      let node = document.createElementNS(XUL_NS, 'toolbarbutton');
+
+      let image = getImage(icon, true, window.devicePixelRatio);
+
+      if (ignoreWindow(window))
+        node.style.display = 'none';
+
+      node.setAttribute('id', this.id);
+      node.setAttribute('class', 'toolbarbutton-1 chromeclass-toolbar-additional badged-button');
+      node.setAttribute('type', type);
+      node.setAttribute('label', label);
+      node.setAttribute('tooltiptext', label);
+      node.setAttribute('image', image);
+      node.setAttribute('constrain-size', 'true');
+
+      views.set(id, {
+        area: this.currentArea,
+        icon: icon,
+        label: label
+      });
+
+      node.addEventListener('command', function(event) {
+        if (views.has(id)) {
+          emit(viewEvents, 'data', {
+            type: 'click',
+            target: id,
+            window: event.view,
+            checked: node.checked
+          });
+        }
+      });
+
+      return node;
+    }
+  });
+};
+exports.create = create;
+
+function dispose(id) {
+  if (!views.has(id)) return;
+
+  views.delete(id);
+  CustomizableUI.destroyWidget(id);
+}
+exports.dispose = dispose;
+
+function setIcon(id, window, icon) {
+  let node = getNode(id, window);
+
+  if (node) {
+    icon = customizedWindows.has(window) ? views.get(id).icon : icon;
+    let image = getImage(icon, isInToolbar(id), window.devicePixelRatio);
+
+    node.setAttribute('image', image);
+  }
+}
+exports.setIcon = setIcon;
+
+function setLabel(id, window, label) {
+  let node = nodeFor(id, window);
+
+  if (node) {
+    node.setAttribute('label', label);
+    node.setAttribute('tooltiptext', label);
+  }
+}
+exports.setLabel = setLabel;
+
+function setDisabled(id, window, disabled) {
+  let node = nodeFor(id, window);
+
+  if (node)
+    node.disabled = disabled;
+}
+exports.setDisabled = setDisabled;
+
+function setChecked(id, window, checked) {
+  let node = nodeFor(id, window);
+
+  if (node)
+    node.checked = checked;
+}
+exports.setChecked = setChecked;
+
+function setBadge(id, window, badge, color) {
+  let node = nodeFor(id, window);
+
+  if (node) {
+    // `Array.from` is needed to handle unicode symbol properly:
+    // '𝐀𝐁'.length is 4 where Array.from('𝐀𝐁').length is 2
+    let text = isNil(badge)
+                  ? ''
+                  : Array.from(String(badge)).slice(0, 4).join('');
+
+    node.setAttribute('badge', text);
+
+    let badgeNode = node.ownerDocument.getAnonymousElementByAttribute(node,
+                                        'class', 'toolbarbutton-badge');
+
+    if (badgeNode)
+      badgeNode.style.backgroundColor = isNil(color) ? '' : color;
+  }
+}
+exports.setBadge = setBadge;
+
+function click(id) {
+  let node = nodeFor(id);
+
+  if (node)
+    node.click();
+}
+exports.click = click;
diff --git a/toolkit/jetpack/sdk/ui/button/view/events.js b/toolkit/jetpack/sdk/ui/button/view/events.js
new file mode 100644
index 000000000..98909656a
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/button/view/events.js
@@ -0,0 +1,18 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental',
+  'engines': {
+    'Firefox': '*',
+    'SeaMonkey': '*',
+    'Thunderbird': '*'
+  }
+};
+
+var channel = {};
+
+exports.events = channel;
diff --git a/toolkit/jetpack/sdk/ui/component.js b/toolkit/jetpack/sdk/ui/component.js
new file mode 100644
index 000000000..d1f12c95e
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/component.js
@@ -0,0 +1,182 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+// Internal properties not exposed to the public.
+const cache = Symbol("component/cache");
+const writer = Symbol("component/writer");
+const isFirstWrite = Symbol("component/writer/first-write?");
+const currentState = Symbol("component/state/current");
+const pendingState = Symbol("component/state/pending");
+const isWriting = Symbol("component/writing?");
+
+const isntNull = x => x !== null;
+
+const Component = function(options, children) {
+  this[currentState] = null;
+  this[pendingState] = null;
+  this[writer] = null;
+  this[cache] = null;
+  this[isFirstWrite] = true;
+
+  this[Component.construct](options, children);
+}
+Component.Component = Component;
+// Constructs component.
+Component.construct = Symbol("component/construct");
+// Called with `options` and `children` and must return
+// initial state back.
+Component.initial = Symbol("component/initial");
+
+// Function patches current `state` with a given update.
+Component.patch = Symbol("component/patch");
+// Function that replaces current `state` with a passed state.
+Component.reset = Symbol("component/reset");
+
+// Function that must return render tree from passed state.
+Component.render = Symbol("component/render");
+
+// Path of the component with in the mount point.
+Component.path = Symbol("component/path");
+
+Component.isMounted = component => !!component[writer];
+Component.isWriting = component => !!component[isWriting];
+
+// Internal method that mounts component to a writer.
+// Mounts component to a writer.
+Component.mount = (component, write) => {
+  if (Component.isMounted(component)) {
+    throw Error("Can not mount already mounted component");
+  }
+
+  component[writer] = write;
+  Component.write(component);
+
+  if (component[Component.mounted]) {
+    component[Component.mounted]();
+  }
+}
+
+// Unmounts component from a writer.
+Component.unmount = (component) => {
+  if (Component.isMounted(component)) {
+    component[writer] = null;
+    if (component[Component.unmounted]) {
+      component[Component.unmounted]();
+    }
+  } else {
+    console.warn("Unmounting component that is not mounted is redundant");
+  }
+};
+ // Method invoked once after inital write occurs.
+Component.mounted = Symbol("component/mounted");
+// Internal method that unmounts component from the writer.
+Component.unmounted = Symbol("component/unmounted");
+// Function that must return true if component is changed
+Component.isUpdated = Symbol("component/updated?");
+Component.update = Symbol("component/update");
+Component.updated = Symbol("component/updated");
+
+const writeChild = base => (child, index) => Component.write(child, base, index)
+Component.write = (component, base, index) => {
+  if (component === null) {
+    return component;
+  }
+
+  if (!(component instanceof Component)) {
+    const path = base ? `${base}${component.key || index}/` : `/`;
+    return Object.assign({}, component, {
+      [Component.path]: path,
+      children: component.children && component.children.
+                                        map(writeChild(path)).
+                                        filter(isntNull)
+    });
+  }
+
+  component[isWriting] = true;
+
+  try {
+
+    const current = component[currentState];
+    const pending = component[pendingState] || current;
+    const isUpdated = component[Component.isUpdated];
+    const isInitial = component[isFirstWrite];
+
+    if (isUpdated(current, pending) || isInitial) {
+      if (!isInitial && component[Component.update]) {
+        component[Component.update](pending, current)
+      }
+
+      // Note: [Component.update] could have caused more updates so can't use
+      // `pending` as `component[pendingState]` may have changed.
+      component[currentState] = component[pendingState] || current;
+      component[pendingState] = null;
+
+      const tree = component[Component.render](component[currentState]);
+      component[cache] = Component.write(tree, base, index);
+      if (component[writer]) {
+        component[writer].call(null, component[cache]);
+      }
+
+      if (!isInitial && component[Component.updated]) {
+        component[Component.updated](current, pending);
+      }
+    }
+
+    component[isFirstWrite] = false;
+
+    return component[cache];
+  } finally {
+    component[isWriting] = false;
+  }
+};
+
+Component.prototype = Object.freeze({
+  constructor: Component,
+
+  [Component.mounted]: null,
+  [Component.unmounted]: null,
+  [Component.update]: null,
+  [Component.updated]: null,
+
+  get state() {
+    return this[pendingState] || this[currentState];
+  },
+
+
+  [Component.construct](settings, items) {
+    const initial = this[Component.initial];
+    const base = initial(settings, items);
+    const options = Object.assign(Object.create(null), base.options, settings);
+    const children = base.children || items || null;
+    const state = Object.assign(Object.create(null), base, {options, children});
+    this[currentState] = state;
+
+    if (this.setup) {
+      this.setup(state);
+    }
+  },
+  [Component.initial](options, children) {
+    return Object.create(null);
+  },
+  [Component.patch](update) {
+    this[Component.reset](Object.assign({}, this.state, update));
+  },
+  [Component.reset](state) {
+    this[pendingState] = state;
+    if (Component.isMounted(this) && !Component.isWriting(this)) {
+      Component.write(this);
+    }
+  },
+
+  [Component.isUpdated](before, after) {
+    return before != after
+  },
+
+  [Component.render](state) {
+    throw Error("Component must implement [Component.render] member");
+  }
+});
+
+module.exports = Component;
diff --git a/toolkit/jetpack/sdk/ui/frame.js b/toolkit/jetpack/sdk/ui/frame.js
new file mode 100644
index 000000000..566353cdf
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/frame.js
@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "> 28"
+  }
+};
+
+require("./frame/view");
+const { Frame } = require("./frame/model");
+
+exports.Frame = Frame;
diff --git a/toolkit/jetpack/sdk/ui/frame/model.js b/toolkit/jetpack/sdk/ui/frame/model.js
new file mode 100644
index 000000000..627310874
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/frame/model.js
@@ -0,0 +1,154 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "> 28"
+  }
+};
+
+const { Class } = require("../../core/heritage");
+const { EventTarget } = require("../../event/target");
+const { emit, off, setListeners } = require("../../event/core");
+const { Reactor, foldp, send, merges } = require("../../event/utils");
+const { Disposable } = require("../../core/disposable");
+const { OutputPort } = require("../../output/system");
+const { InputPort } = require("../../input/system");
+const { identify } = require("../id");
+const { pairs, object, map, each } = require("../../util/sequence");
+const { patch, diff } = require("diffpatcher/index");
+const { isLocalURL } = require("../../url");
+const { compose } = require("../../lang/functional");
+const { contract } = require("../../util/contract");
+const { id: addonID, data: { url: resolve }} = require("../../self");
+const { Frames } = require("../../input/frame");
+
+
+const output = new OutputPort({ id: "frame-change" });
+const mailbox = new OutputPort({ id: "frame-mailbox" });
+const input = Frames;
+
+
+const makeID = url =>
+  ("frame-" + addonID + "-" + url).
+    split("/").join("-").
+    split(".").join("-").
+    replace(/[^A-Za-z0-9_\-]/g, "");
+
+const validate = contract({
+  name: {
+    is: ["string", "undefined"],
+    ok: x => /^[a-z][a-z0-9-_]+$/i.test(x),
+    msg: "The `option.name` must be a valid alphanumeric string (hyphens and " +
+         "underscores are allowed) starting with letter."
+  },
+  url: {
+    map: x => x.toString(),
+    is: ["string"],
+    ok: x => isLocalURL(x),
+    msg: "The `options.url` must be a valid local URI."
+  }
+});
+
+const Source = function({id, ownerID}) {
+  this.id = id;
+  this.ownerID = ownerID;
+};
+Source.postMessage = ({id, ownerID}, data, origin) => {
+  send(mailbox, object([id, {
+    inbox: {
+      target: {id: id, ownerID: ownerID},
+      timeStamp: Date.now(),
+      data: data,
+      origin: origin
+    }
+  }]));
+};
+Source.prototype.postMessage = function(data, origin) {
+  Source.postMessage(this, data, origin);
+};
+
+const Message = function({type, data, source, origin, timeStamp}) {
+  this.type = type;
+  this.data = data;
+  this.origin = origin;
+  this.timeStamp = timeStamp;
+  this.source = new Source(source);
+};
+
+
+const frames = new Map();
+const sources = new Map();
+
+const Frame = Class({
+  extends: EventTarget,
+  implements: [Disposable, Source],
+  initialize: function(params={}) {
+    const options = validate(params);
+    const id = makeID(options.name || options.url);
+
+    if (frames.has(id))
+      throw Error("Frame with this id already exists: " + id);
+
+    const initial = { id: id, url: resolve(options.url) };
+    this.id = id;
+
+    setListeners(this, params);
+
+    frames.set(this.id, this);
+
+    send(output, object([id, initial]));
+  },
+  get url() {
+    const state = reactor.value[this.id];
+    return state && state.url;
+  },
+  destroy: function() {
+    send(output, object([this.id, null]));
+    frames.delete(this.id);
+    off(this);
+  },
+  // `JSON.stringify` serializes objects based of the return
+  // value of this method. For convinienc we provide this method
+  // to serialize actual state data.
+  toJSON: function() {
+    return { id: this.id, url: this.url };
+  }
+});
+identify.define(Frame, frame => frame.id);
+
+exports.Frame = Frame;
+
+const reactor = new Reactor({
+  onStep: (present, past) => {
+    const delta = diff(past, present);
+
+    each(([id, update]) => {
+      const frame = frames.get(id);
+      if (update) {
+        if (!past[id])
+          emit(frame, "register");
+
+        if (update.outbox)
+          emit(frame, "message", new Message(present[id].outbox));
+
+        each(([ownerID, state]) => {
+          const readyState = state ? state.readyState : "detach";
+          const type = readyState === "loading" ? "attach" :
+                       readyState === "interactive" ? "ready" :
+                       readyState === "complete" ? "load" :
+                       readyState;
+
+          // TODO: Cache `Source` instances somewhere to preserve
+          // identity.
+          emit(frame, type, {type: type,
+                             source: new Source({id: id, ownerID: ownerID})});
+        }, pairs(update.owners));
+      }
+    }, pairs(delta));
+  }
+});
+reactor.run(input);
diff --git a/toolkit/jetpack/sdk/ui/frame/view.html b/toolkit/jetpack/sdk/ui/frame/view.html
new file mode 100644
index 000000000..2a405b583
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/frame/view.html
@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <script>
+      // HACK: This is not an ideal way to deliver chrome messages
+      // to an inner frame content but seems only way that would
+      // make `event.source` this (outer frame) window.
+      window.onmessage = function(event) {
+        var frame = document.querySelector("iframe");
+        var content = frame.contentWindow;
+        // If message is posted from chrome it has no `event.source`.
+        if (event.source === null)
+          content.postMessage(event.data, "*");
+      };
+    </script>
+  </head>
+  <body style="overflow: hidden"></body>
+</html>
diff --git a/toolkit/jetpack/sdk/ui/frame/view.js b/toolkit/jetpack/sdk/ui/frame/view.js
new file mode 100644
index 000000000..2eb4df2b7
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/frame/view.js
@@ -0,0 +1,150 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "> 28"
+  }
+};
+
+const { Cu, Ci } = require("chrome");
+const { CustomizableUI } = Cu.import('resource:///modules/CustomizableUI.jsm', {});
+const { subscribe, send, Reactor, foldp, lift, merges, keepIf } = require("../../event/utils");
+const { InputPort } = require("../../input/system");
+const { OutputPort } = require("../../output/system");
+const { LastClosed } = require("../../input/browser");
+const { pairs, keys, object, each } = require("../../util/sequence");
+const { curry, compose } = require("../../lang/functional");
+const { getFrameElement, getOuterId,
+        getByOuterId, getOwnerBrowserWindow } = require("../../window/utils");
+const { patch, diff } = require("diffpatcher/index");
+const { encode } = require("../../base64");
+const { Frames } = require("../../input/frame");
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+const HTML_NS = "http://www.w3.org/1999/xhtml";
+const OUTER_FRAME_URI = module.uri.replace(/\.js$/, ".html");
+
+const mailbox = new OutputPort({ id: "frame-mailbox" });
+
+const frameID = frame => frame.id.replace("outer-", "");
+const windowID = compose(getOuterId, getOwnerBrowserWindow);
+
+const getOuterFrame = (windowID, frameID) =>
+    getByOuterId(windowID).document.getElementById("outer-" + frameID);
+
+const listener = ({target, source, data, origin, timeStamp}) => {
+  // And sent received message to outbox so that frame API model
+  // will deal with it.
+  if (source && source !== target) {
+    const frame = getFrameElement(target);
+    const id = frameID(frame);
+    send(mailbox, object([id, {
+      outbox: {type: "message",
+               source: {id: id, ownerID: windowID(frame)},
+               data: data,
+               origin: origin,
+               timeStamp: timeStamp}}]));
+  }
+};
+
+// Utility function used to create frame with a given `state` and
+// inject it into given `window`.
+const registerFrame = ({id, url}) => {
+  CustomizableUI.createWidget({
+    id: id,
+    type: "custom",
+    removable: true,
+    onBuild: document => {
+      let view = document.createElementNS(XUL_NS, "toolbaritem");
+      view.setAttribute("id", id);
+      view.setAttribute("flex", 2);
+
+      let outerFrame = document.createElementNS(XUL_NS, "iframe");
+      outerFrame.setAttribute("src", OUTER_FRAME_URI);
+      outerFrame.setAttribute("id", "outer-" + id);
+      outerFrame.setAttribute("data-is-sdk-outer-frame", true);
+      outerFrame.setAttribute("type", "content");
+      outerFrame.setAttribute("transparent", true);
+      outerFrame.setAttribute("flex", 2);
+      outerFrame.setAttribute("style", "overflow: hidden;");
+      outerFrame.setAttribute("scrolling", "no");
+      outerFrame.setAttribute("disablehistory", true);
+      outerFrame.setAttribute("seamless", "seamless");
+      outerFrame.addEventListener("load", function onload() {
+        outerFrame.removeEventListener("load", onload, true);
+
+        let doc = outerFrame.contentDocument;
+
+        let innerFrame = doc.createElementNS(HTML_NS, "iframe");
+        innerFrame.setAttribute("id", id);
+        innerFrame.setAttribute("src", url);
+        innerFrame.setAttribute("seamless", "seamless");
+        innerFrame.setAttribute("sandbox", "allow-scripts");
+        innerFrame.setAttribute("scrolling", "no");
+        innerFrame.setAttribute("data-is-sdk-inner-frame", true);
+        innerFrame.setAttribute("style", [ "border:none",
+          "position:absolute", "width:100%", "top: 0",
+          "left: 0", "overflow: hidden"].join(";"));
+
+        doc.body.appendChild(innerFrame);
+      }, true);
+
+      view.appendChild(outerFrame);
+
+      return view;
+    }
+  });
+};
+
+const unregisterFrame = CustomizableUI.destroyWidget;
+
+const deliverMessage = curry((frameID, data, windowID) => {
+  const frame = getOuterFrame(windowID, frameID);
+  const content = frame && frame.contentWindow;
+
+  if (content)
+    content.postMessage(data, content.location.origin);
+});
+
+const updateFrame = (id, {inbox, owners}, present) => {
+  if (inbox) {
+    const { data, target:{ownerID}, source } = present[id].inbox;
+    if (ownerID)
+      deliverMessage(id, data, ownerID);
+    else
+      each(deliverMessage(id, data), keys(present[id].owners));
+  }
+
+  each(setupView(id), pairs(owners));
+};
+
+const setupView = curry((frameID, [windowID, state]) => {
+  if (state && state.readyState === "loading") {
+    const frame = getOuterFrame(windowID, frameID);
+    // Setup a message listener on contentWindow.
+    frame.contentWindow.addEventListener("message", listener);
+  }
+});
+
+
+const reactor = new Reactor({
+  onStep: (present, past) => {
+    const delta = diff(past, present);
+
+    // Apply frame changes
+    each(([id, update]) => {
+      if (update === null)
+        unregisterFrame(id);
+      else if (past[id])
+        updateFrame(id, update, present);
+      else
+        registerFrame(update);
+    }, pairs(delta));
+  },
+  onEnd: state => each(unregisterFrame, keys(state))
+});
+reactor.run(Frames);
diff --git a/toolkit/jetpack/sdk/ui/id.js b/toolkit/jetpack/sdk/ui/id.js
new file mode 100644
index 000000000..d17eb0a4e
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/id.js
@@ -0,0 +1,27 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental'
+};
+
+const method = require('../../method/core');
+const { uuid } = require('../util/uuid');
+
+// NOTE: use lang/functional memoize when it is updated to use WeakMap
+function memoize(f) {
+  const memo = new WeakMap();
+
+  return function memoizer(o) {
+    let key = o;
+    if (!memo.has(key))
+      memo.set(key, f.apply(this, arguments));
+    return memo.get(key);
+  };
+}
+
+var identify = method('identify');
+identify.define(Object, memoize(function() { return uuid(); }));
+exports.identify = identify;
diff --git a/toolkit/jetpack/sdk/ui/sidebar.js b/toolkit/jetpack/sdk/ui/sidebar.js
new file mode 100644
index 000000000..59e35ea11
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/sidebar.js
@@ -0,0 +1,311 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental',
+  'engines': {
+    'Firefox': '*'
+  }
+};
+
+const { Class } = require('../core/heritage');
+const { merge } = require('../util/object');
+const { Disposable } = require('../core/disposable');
+const { off, emit, setListeners } = require('../event/core');
+const { EventTarget } = require('../event/target');
+const { URL } = require('../url');
+const { add, remove, has, clear, iterator } = require('../lang/weak-set');
+const { id: addonID, data } = require('../self');
+const { WindowTracker } = require('../deprecated/window-utils');
+const { isShowing } = require('./sidebar/utils');
+const { isBrowser, getMostRecentBrowserWindow, windows, isWindowPrivate } = require('../window/utils');
+const { ns } = require('../core/namespace');
+const { remove: removeFromArray } = require('../util/array');
+const { show, hide, toggle } = require('./sidebar/actions');
+const { Worker } = require('../deprecated/sync-worker');
+const { contract: sidebarContract } = require('./sidebar/contract');
+const { create, dispose, updateTitle, updateURL, isSidebarShowing, showSidebar, hideSidebar } = require('./sidebar/view');
+const { defer } = require('../core/promise');
+const { models, views, viewsFor, modelFor } = require('./sidebar/namespace');
+const { isLocalURL } = require('../url');
+const { ensure } = require('../system/unload');
+const { identify } = require('./id');
+const { uuid } = require('../util/uuid');
+const { viewFor } = require('../view/core');
+
+const resolveURL = (url) => url ? data.url(url) : url;
+
+const sidebarNS = ns();
+
+const WEB_PANEL_BROWSER_ID = 'web-panels-browser';
+
+var sidebars = {};
+
+const Sidebar = Class({
+  implements: [ Disposable ],
+  extends: EventTarget,
+  setup: function(options) {
+    // inital validation for the model information
+    let model = sidebarContract(options);
+
+    // save the model information
+    models.set(this, model);
+
+    // generate an id if one was not provided
+    model.id = model.id || addonID + '-' + uuid();
+
+    // further validation for the title and url
+    validateTitleAndURLCombo({}, this.title, this.url);
+
+    const self = this;
+    const internals = sidebarNS(self);
+    const windowNS = internals.windowNS = ns();
+
+    // see bug https://bugzilla.mozilla.org/show_bug.cgi?id=886148
+    ensure(this, 'destroy');
+
+    setListeners(this, options);
+
+    let bars = [];
+    internals.tracker = WindowTracker({
+      onTrack: function(window) {
+        if (!isBrowser(window))
+          return;
+
+        let sidebar = window.document.getElementById('sidebar');
+        let sidebarBox = window.document.getElementById('sidebar-box');
+
+        let bar = create(window, {
+          id: self.id,
+          title: self.title,
+          sidebarurl: self.url
+        });
+        bars.push(bar);
+        windowNS(window).bar = bar;
+
+        bar.addEventListener('command', function() {
+          if (isSidebarShowing(window, self)) {
+            hideSidebar(window, self).catch(() => {});
+            return;
+          }
+
+          showSidebar(window, self);
+        }, false);
+
+        function onSidebarLoad() {
+          // check if the sidebar is ready
+          let isReady = sidebar.docShell && sidebar.contentDocument;
+          if (!isReady)
+            return;
+
+          // check if it is a web panel
+          let panelBrowser = sidebar.contentDocument.getElementById(WEB_PANEL_BROWSER_ID);
+          if (!panelBrowser) {
+            bar.removeAttribute('checked');
+            return;
+          }
+
+          let sbTitle = window.document.getElementById('sidebar-title');
+          function onWebPanelSidebarCreated() {
+            if (panelBrowser.contentWindow.location != resolveURL(model.url) ||
+                sbTitle.value != model.title) {
+              return;
+            }
+
+            let worker = windowNS(window).worker = Worker({
+              window: panelBrowser.contentWindow,
+              injectInDocument: true
+            });
+
+            function onWebPanelSidebarUnload() {
+              windowNS(window).onWebPanelSidebarUnload = null;
+
+              // uncheck the associated menuitem
+              bar.setAttribute('checked', 'false');
+
+              emit(self, 'hide', {});
+              emit(self, 'detach', worker);
+              windowNS(window).worker = null;
+            }
+            windowNS(window).onWebPanelSidebarUnload = onWebPanelSidebarUnload;
+            panelBrowser.contentWindow.addEventListener('unload', onWebPanelSidebarUnload, true);
+
+            // check the associated menuitem
+            bar.setAttribute('checked', 'true');
+
+            function onWebPanelSidebarReady() {
+              panelBrowser.contentWindow.removeEventListener('DOMContentLoaded', onWebPanelSidebarReady, false);
+              windowNS(window).onWebPanelSidebarReady = null;
+
+              emit(self, 'ready', worker);
+            }
+            windowNS(window).onWebPanelSidebarReady = onWebPanelSidebarReady;
+            panelBrowser.contentWindow.addEventListener('DOMContentLoaded', onWebPanelSidebarReady, false);
+
+            function onWebPanelSidebarLoad() {
+              panelBrowser.contentWindow.removeEventListener('load', onWebPanelSidebarLoad, true);
+              windowNS(window).onWebPanelSidebarLoad = null;
+
+              // TODO: decide if returning worker is acceptable..
+              //emit(self, 'show', { worker: worker });
+              emit(self, 'show', {});
+            }
+            windowNS(window).onWebPanelSidebarLoad = onWebPanelSidebarLoad;
+            panelBrowser.contentWindow.addEventListener('load', onWebPanelSidebarLoad, true);
+
+            emit(self, 'attach', worker);
+          }
+          windowNS(window).onWebPanelSidebarCreated = onWebPanelSidebarCreated;
+          panelBrowser.addEventListener('DOMWindowCreated', onWebPanelSidebarCreated, true);
+        }
+        windowNS(window).onSidebarLoad = onSidebarLoad;
+        sidebar.addEventListener('load', onSidebarLoad, true); // removed properly
+      },
+      onUntrack: function(window) {
+        if (!isBrowser(window))
+          return;
+
+        // hide the sidebar if it is showing
+        hideSidebar(window, self).catch(() => {});
+
+        // kill the menu item
+        let { bar } = windowNS(window);
+        if (bar) {
+          removeFromArray(viewsFor(self), bar);
+          dispose(bar);
+        }
+
+        // kill listeners
+        let sidebar = window.document.getElementById('sidebar');
+
+        if (windowNS(window).onSidebarLoad) {
+          sidebar && sidebar.removeEventListener('load', windowNS(window).onSidebarLoad, true)
+          windowNS(window).onSidebarLoad = null;
+        }
+
+        let panelBrowser = sidebar && sidebar.contentDocument.getElementById(WEB_PANEL_BROWSER_ID);
+        if (windowNS(window).onWebPanelSidebarCreated) {
+          panelBrowser && panelBrowser.removeEventListener('DOMWindowCreated', windowNS(window).onWebPanelSidebarCreated, true);
+          windowNS(window).onWebPanelSidebarCreated = null;
+        }
+
+        if (windowNS(window).onWebPanelSidebarReady) {
+          panelBrowser && panelBrowser.contentWindow.removeEventListener('DOMContentLoaded', windowNS(window).onWebPanelSidebarReady, false);
+          windowNS(window).onWebPanelSidebarReady = null;
+        }
+
+        if (windowNS(window).onWebPanelSidebarLoad) {
+          panelBrowser && panelBrowser.contentWindow.removeEventListener('load', windowNS(window).onWebPanelSidebarLoad, true);
+          windowNS(window).onWebPanelSidebarLoad = null;
+        }
+
+        if (windowNS(window).onWebPanelSidebarUnload) {
+          panelBrowser && panelBrowser.contentWindow.removeEventListener('unload', windowNS(window).onWebPanelSidebarUnload, true);
+          windowNS(window).onWebPanelSidebarUnload();
+        }
+      }
+    });
+
+    views.set(this, bars);
+
+    add(sidebars, this);
+  },
+  get id() {
+    return (modelFor(this) || {}).id;
+  },
+  get title() {
+    return (modelFor(this) || {}).title;
+  },
+  set title(v) {
+    // destroyed?
+    if (!modelFor(this))
+      return;
+    // validation
+    if (typeof v != 'string')
+      throw Error('title must be a string');
+    validateTitleAndURLCombo(this, v, this.url);
+    // do update
+    updateTitle(this, v);
+    return modelFor(this).title = v;
+  },
+  get url() {
+    return (modelFor(this) || {}).url;
+  },
+  set url(v) {
+    // destroyed?
+    if (!modelFor(this))
+      return;
+
+    // validation
+    if (!isLocalURL(v))
+      throw Error('the url must be a valid local url');
+
+    validateTitleAndURLCombo(this, this.title, v);
+
+    // do update
+    updateURL(this, v);
+    modelFor(this).url = v;
+  },
+  show: function(window) {
+    return showSidebar(viewFor(window), this);
+  },
+  hide: function(window) {
+    return hideSidebar(viewFor(window), this);
+  },
+  dispose: function() {
+    const internals = sidebarNS(this);
+
+    off(this);
+
+    remove(sidebars, this);
+
+    // stop tracking windows
+    if (internals.tracker) {
+      internals.tracker.unload();
+    }
+
+    internals.tracker = null;
+    internals.windowNS = null;
+
+    views.delete(this);
+    models.delete(this);
+  }
+});
+exports.Sidebar = Sidebar;
+
+function validateTitleAndURLCombo(sidebar, title, url) {
+  url = resolveURL(url);
+
+  if (sidebar.title == title && sidebar.url == url) {
+    return false;
+  }
+
+  for (let window of windows(null, { includePrivate: true })) {
+    let sidebar = window.document.querySelector('menuitem[sidebarurl="' + url + '"][label="' + title + '"]');
+    if (sidebar) {
+      throw Error('The provided title and url combination is invalid (already used).');
+    }
+  }
+
+  return false;
+}
+
+isShowing.define(Sidebar, isSidebarShowing.bind(null, null));
+show.define(Sidebar, showSidebar.bind(null, null));
+hide.define(Sidebar, hideSidebar.bind(null, null));
+
+identify.define(Sidebar, function(sidebar) {
+  return sidebar.id;
+});
+
+function toggleSidebar(window, sidebar) {
+  // TODO: make sure this is not private
+  window = window || getMostRecentBrowserWindow();
+  if (isSidebarShowing(window, sidebar)) {
+    return hideSidebar(window, sidebar);
+  }
+  return showSidebar(window, sidebar);
+}
+toggle.define(Sidebar, toggleSidebar.bind(null, null));
diff --git a/toolkit/jetpack/sdk/ui/sidebar/actions.js b/toolkit/jetpack/sdk/ui/sidebar/actions.js
new file mode 100644
index 000000000..4a52984c9
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/sidebar/actions.js
@@ -0,0 +1,10 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const method = require('../../../method/core');
+
+exports.show = method('show');
+exports.hide = method('hide');
+exports.toggle = method('toggle');
diff --git a/toolkit/jetpack/sdk/ui/sidebar/contract.js b/toolkit/jetpack/sdk/ui/sidebar/contract.js
new file mode 100644
index 000000000..b59c37c0b
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/sidebar/contract.js
@@ -0,0 +1,27 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { contract } = require('../../util/contract');
+const { isValidURI, URL, isLocalURL } = require('../../url');
+const { isNil, isObject, isString } = require('../../lang/type');
+
+exports.contract = contract({
+  id: {
+  	is: [ 'string', 'undefined' ],
+  	ok: v => /^[a-z0-9-_]+$/i.test(v),
+    msg: 'The option "id" must be a valid alphanumeric id (hyphens and ' +
+         'underscores are allowed).'
+  },
+  title: {
+  	is: [ 'string' ],
+  	ok: v => v.length
+  },
+  url: {
+    is: [ 'string' ],
+    ok: v => isLocalURL(v),
+    map: v => v.toString(),
+    msg: 'The option "url" must be a valid local URI.'
+  }
+});
diff --git a/toolkit/jetpack/sdk/ui/sidebar/namespace.js b/toolkit/jetpack/sdk/ui/sidebar/namespace.js
new file mode 100644
index 000000000..d79725d1a
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/sidebar/namespace.js
@@ -0,0 +1,15 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const models = exports.models = new WeakMap();
+const views = exports.views = new WeakMap();
+exports.buttons = new WeakMap();
+
+exports.viewsFor = function viewsFor(sidebar) {
+  return views.get(sidebar);
+};
+exports.modelFor = function modelFor(sidebar) {
+  return models.get(sidebar);
+};
diff --git a/toolkit/jetpack/sdk/ui/sidebar/utils.js b/toolkit/jetpack/sdk/ui/sidebar/utils.js
new file mode 100644
index 000000000..d6145c32e
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/sidebar/utils.js
@@ -0,0 +1,8 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const method = require('../../../method/core');
+
+exports.isShowing = method('isShowing');
diff --git a/toolkit/jetpack/sdk/ui/sidebar/view.js b/toolkit/jetpack/sdk/ui/sidebar/view.js
new file mode 100644
index 000000000..c91e69d3d
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/sidebar/view.js
@@ -0,0 +1,214 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable',
+  'engines': {
+    'Firefox': '*'
+  }
+};
+
+const { models, buttons, views, viewsFor, modelFor } = require('./namespace');
+const { isBrowser, getMostRecentBrowserWindow, windows, isWindowPrivate } = require('../../window/utils');
+const { setStateFor } = require('../state');
+const { defer } = require('../../core/promise');
+const { isPrivateBrowsingSupported, data } = require('../../self');
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+const WEB_PANEL_BROWSER_ID = 'web-panels-browser';
+
+const resolveURL = (url) => url ? data.url(url) : url;
+
+function create(window, details) {
+  let id = makeID(details.id);
+  let { document } = window;
+
+  if (document.getElementById(id))
+    throw new Error('The ID "' + details.id + '" seems already used.');
+
+  let menuitem = document.createElementNS(XUL_NS, 'menuitem');
+  menuitem.setAttribute('id', id);
+  menuitem.setAttribute('label', details.title);
+  menuitem.setAttribute('sidebarurl', resolveURL(details.sidebarurl));
+  menuitem.setAttribute('checked', 'false');
+  menuitem.setAttribute('type', 'checkbox');
+  menuitem.setAttribute('group', 'sidebar');
+  menuitem.setAttribute('autoCheck', 'false');
+
+  document.getElementById('viewSidebarMenu').appendChild(menuitem);
+
+  return menuitem;
+}
+exports.create = create;
+
+function dispose(menuitem) {
+  menuitem.parentNode.removeChild(menuitem);
+}
+exports.dispose = dispose;
+
+function updateTitle(sidebar, title) {
+  let button = buttons.get(sidebar);
+
+  for (let window of windows(null, { includePrivate: true })) {
+  	let { document } = window;
+
+    // update the button
+    if (button) {
+      setStateFor(button, window, { label: title });
+    }
+
+    // update the menuitem
+    let mi = document.getElementById(makeID(sidebar.id));
+    if (mi) {
+      mi.setAttribute('label', title)
+    }
+
+    // update sidebar, if showing
+    if (isSidebarShowing(window, sidebar)) {
+      document.getElementById('sidebar-title').setAttribute('value', title);
+    }
+  }
+}
+exports.updateTitle = updateTitle;
+
+function updateURL(sidebar, url) {
+  let eleID = makeID(sidebar.id);
+
+  url = resolveURL(url);
+
+  for (let window of windows(null, { includePrivate: true })) {
+    // update the menuitem
+    let mi = window.document.getElementById(eleID);
+    if (mi) {
+      mi.setAttribute('sidebarurl', url)
+    }
+
+    // update sidebar, if showing
+    if (isSidebarShowing(window, sidebar)) {
+      showSidebar(window, sidebar, url);
+    }
+  }
+}
+exports.updateURL = updateURL;
+
+function isSidebarShowing(window, sidebar) {
+  let win = window || getMostRecentBrowserWindow();
+
+  // make sure there is a window
+  if (!win) {
+    return false;
+  }
+
+  // make sure there is a sidebar for the window
+  let sb = win.document.getElementById('sidebar');
+  let sidebarTitle = win.document.getElementById('sidebar-title');
+  if (!(sb && sidebarTitle)) {
+    return false;
+  }
+
+  // checks if the sidebar box is hidden
+  let sbb = win.document.getElementById('sidebar-box');
+  if (!sbb || sbb.hidden) {
+    return false;
+  }
+
+  if (sidebarTitle.value == modelFor(sidebar).title) {
+    let url = resolveURL(modelFor(sidebar).url);
+
+    // checks if the sidebar is loading
+    if (win.gWebPanelURI == url) {
+      return true;
+    }
+
+    // checks if the sidebar loaded already
+    let ele = sb.contentDocument && sb.contentDocument.getElementById(WEB_PANEL_BROWSER_ID);
+    if (!ele) {
+      return false;
+    }
+
+    if (ele.getAttribute('cachedurl') == url) {
+      return true;
+    }
+
+    if (ele && ele.contentWindow && ele.contentWindow.location == url) {
+      return true;
+    }
+  }
+
+  // default
+  return false;
+}
+exports.isSidebarShowing = isSidebarShowing;
+
+function showSidebar(window, sidebar, newURL) {
+  window = window || getMostRecentBrowserWindow();
+
+  let { promise, resolve, reject } = defer();
+  let model = modelFor(sidebar);
+
+  if (!newURL && isSidebarShowing(window, sidebar)) {
+    resolve({});
+  }
+  else if (!isPrivateBrowsingSupported && isWindowPrivate(window)) {
+    reject(Error('You cannot show a sidebar on private windows'));
+  }
+  else {
+    sidebar.once('show', resolve);
+
+    let menuitem = window.document.getElementById(makeID(model.id));
+    menuitem.setAttribute('checked', true);
+
+    window.openWebPanel(model.title, resolveURL(newURL || model.url));
+  }
+
+  return promise;
+}
+exports.showSidebar = showSidebar;
+
+
+function hideSidebar(window, sidebar) {
+  window = window || getMostRecentBrowserWindow();
+
+  let { promise, resolve, reject } = defer();
+
+  if (!isSidebarShowing(window, sidebar)) {
+    reject(Error('The sidebar is already hidden'));
+  }
+  else {
+    sidebar.once('hide', resolve);
+
+    // Below was taken from http://mxr.mozilla.org/mozilla-central/source/browser/base/content/browser.js#4775
+    // the code for window.todggleSideBar()..
+    let { document } = window;
+    let sidebarEle = document.getElementById('sidebar');
+    let sidebarTitle = document.getElementById('sidebar-title');
+    let sidebarBox = document.getElementById('sidebar-box');
+    let sidebarSplitter = document.getElementById('sidebar-splitter');
+    let commandID = sidebarBox.getAttribute('sidebarcommand');
+    let sidebarBroadcaster = document.getElementById(commandID);
+
+    sidebarBox.hidden = true;
+    sidebarSplitter.hidden = true;
+
+    sidebarEle.setAttribute('src', 'about:blank');
+    //sidebarEle.docShell.createAboutBlankContentViewer(null);
+
+    sidebarBroadcaster.removeAttribute('checked');
+    sidebarBox.setAttribute('sidebarcommand', '');
+    sidebarTitle.value = '';
+    sidebarBox.hidden = true;
+    sidebarSplitter.hidden = true;
+
+    // TODO: perhaps this isn't necessary if the window is not most recent?
+    window.gBrowser.selectedBrowser.focus();
+  }
+
+  return promise;
+}
+exports.hideSidebar = hideSidebar;
+
+function makeID(id) {
+  return 'jetpack-sidebar-' + id;
+}
diff --git a/toolkit/jetpack/sdk/ui/state.js b/toolkit/jetpack/sdk/ui/state.js
new file mode 100644
index 000000000..152ce696d
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/state.js
@@ -0,0 +1,239 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+// The Button module currently supports only Firefox.
+// See: https://bugzilla.mozilla.org/show_bug.cgi?id=jetpack-panel-apps
+module.metadata = {
+  'stability': 'experimental',
+  'engines': {
+    'Firefox': '*',
+    'SeaMonkey': '*',
+    'Thunderbird': '*'
+  }
+};
+
+const { Ci } = require('chrome');
+
+const events = require('../event/utils');
+const { events: browserEvents } = require('../browser/events');
+const { events: tabEvents } = require('../tab/events');
+const { events: stateEvents } = require('./state/events');
+
+const { windows, isInteractive, getFocusedBrowser } = require('../window/utils');
+const { getActiveTab, getOwnerWindow } = require('../tabs/utils');
+
+const { ignoreWindow } = require('../private-browsing/utils');
+
+const { freeze } = Object;
+const { merge } = require('../util/object');
+const { on, off, emit } = require('../event/core');
+
+const { add, remove, has, clear, iterator } = require('../lang/weak-set');
+const { isNil } = require('../lang/type');
+
+const { viewFor } = require('../view/core');
+
+const components = new WeakMap();
+
+const ERR_UNREGISTERED = 'The state cannot be set or get. ' +
+  'The object may be not be registered, or may already have been unloaded.';
+
+const ERR_INVALID_TARGET = 'The state cannot be set or get for this target.' +
+  'Only window, tab and registered component are valid targets.';
+
+const isWindow = thing => thing instanceof Ci.nsIDOMWindow;
+const isTab = thing => thing.tagName && thing.tagName.toLowerCase() === 'tab';
+const isActiveTab = thing => isTab(thing) && thing === getActiveTab(getOwnerWindow(thing));
+const isEnumerable = window => !ignoreWindow(window);
+const browsers = _ =>
+  windows('navigator:browser', { includePrivate: true }).filter(isInteractive);
+const getMostRecentTab = _ => getActiveTab(getFocusedBrowser());
+
+function getStateFor(component, target) {
+  if (!isRegistered(component))
+    throw new Error(ERR_UNREGISTERED);
+
+  if (!components.has(component))
+    return null;
+
+  let states = components.get(component);
+
+  if (target) {
+    if (isTab(target) || isWindow(target) || target === component)
+      return states.get(target) || null;
+    else
+      throw new Error(ERR_INVALID_TARGET);
+  }
+
+  return null;
+}
+exports.getStateFor = getStateFor;
+
+function getDerivedStateFor(component, target) {
+  if (!isRegistered(component))
+    throw new Error(ERR_UNREGISTERED);
+
+  if (!components.has(component))
+    return null;
+
+  let states = components.get(component);
+
+  let componentState = states.get(component);
+  let windowState = null;
+  let tabState = null;
+
+  if (target) {
+    // has a target
+    if (isTab(target)) {
+      windowState = states.get(getOwnerWindow(target), null);
+
+      if (states.has(target)) {
+        // we have a tab state
+        tabState = states.get(target);
+      }
+    }
+    else if (isWindow(target) && states.has(target)) {
+      // we have a window state
+      windowState = states.get(target);
+    }
+  }
+
+  return freeze(merge({}, componentState, windowState, tabState));
+}
+exports.getDerivedStateFor = getDerivedStateFor;
+
+function setStateFor(component, target, state) {
+  if (!isRegistered(component))
+    throw new Error(ERR_UNREGISTERED);
+
+  let isComponentState = target === component;
+  let targetWindows = isWindow(target) ? [target] :
+                      isActiveTab(target) ? [getOwnerWindow(target)] :
+                      isComponentState ? browsers() :
+                      isTab(target) ? [] :
+                      null;
+
+  if (!targetWindows)
+    throw new Error(ERR_INVALID_TARGET);
+
+  // initialize the state's map
+  if (!components.has(component))
+    components.set(component, new WeakMap());
+
+  let states = components.get(component);
+
+  if (state === null && !isComponentState) // component state can't be deleted
+    states.delete(target);
+  else {
+    let base = isComponentState ? states.get(target) : null;
+    states.set(target, freeze(merge({}, base, state)));
+  }
+
+  render(component, targetWindows);
+}
+exports.setStateFor = setStateFor;
+
+function render(component, targetWindows) {
+  targetWindows = targetWindows ? [].concat(targetWindows) : browsers();
+
+  for (let window of targetWindows.filter(isEnumerable)) {
+    let tabState = getDerivedStateFor(component, getActiveTab(window));
+
+    emit(stateEvents, 'data', {
+      type: 'render',
+      target: component,
+      window: window,
+      state: tabState
+    });
+
+  }
+}
+exports.render = render;
+
+function properties(contract) {
+  let { rules } = contract;
+  let descriptor = Object.keys(rules).reduce(function(descriptor, name) {
+    descriptor[name] = {
+      get: function() { return getDerivedStateFor(this)[name] },
+      set: function(value) {
+        let changed = {};
+        changed[name] = value;
+
+        setStateFor(this, this, contract(changed));
+      }
+    }
+    return descriptor;
+  }, {});
+
+  return Object.create(Object.prototype, descriptor);
+}
+exports.properties = properties;
+
+function state(contract) {
+  return {
+    state: function state(target, state) {
+      let nativeTarget = target === 'window' ? getFocusedBrowser()
+                          : target === 'tab' ? getMostRecentTab()
+                          : target === this ? null
+                          : viewFor(target);
+
+      if (!nativeTarget && target !== this && !isNil(target))
+        throw new Error(ERR_INVALID_TARGET);
+
+      target = nativeTarget || target;
+
+      // jquery style
+      return arguments.length < 2
+        ? getDerivedStateFor(this, target)
+        : setStateFor(this, target, contract(state))
+    }
+  }
+}
+exports.state = state;
+
+const register = (component, state) => {
+  add(components, component);
+  setStateFor(component, component, state);
+}
+exports.register = register;
+
+const unregister = component => {
+  remove(components, component);
+}
+exports.unregister = unregister;
+
+const isRegistered = component => has(components, component);
+exports.isRegistered = isRegistered;
+
+var tabSelect = events.filter(tabEvents, e => e.type === 'TabSelect');
+var tabClose = events.filter(tabEvents, e => e.type === 'TabClose');
+var windowOpen = events.filter(browserEvents, e => e.type === 'load');
+var windowClose = events.filter(browserEvents, e => e.type === 'close');
+
+var close = events.merge([tabClose, windowClose]);
+var activate = events.merge([windowOpen, tabSelect]);
+
+on(activate, 'data', ({target}) => {
+  let [window, tab] = isWindow(target)
+                        ? [target, getActiveTab(target)]
+                        : [getOwnerWindow(target), target];
+
+  if (ignoreWindow(window)) return;
+
+  for (let component of iterator(components)) {
+    emit(stateEvents, 'data', {
+      type: 'render',
+      target: component,
+      window: window,
+      state: getDerivedStateFor(component, tab)
+    });
+  }
+});
+
+on(close, 'data', function({target}) {
+  for (let component of iterator(components)) {
+    components.get(component).delete(target);
+  }
+});
diff --git a/toolkit/jetpack/sdk/ui/state/events.js b/toolkit/jetpack/sdk/ui/state/events.js
new file mode 100644
index 000000000..98909656a
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/state/events.js
@@ -0,0 +1,18 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  'stability': 'experimental',
+  'engines': {
+    'Firefox': '*',
+    'SeaMonkey': '*',
+    'Thunderbird': '*'
+  }
+};
+
+var channel = {};
+
+exports.events = channel;
diff --git a/toolkit/jetpack/sdk/ui/toolbar.js b/toolkit/jetpack/sdk/ui/toolbar.js
new file mode 100644
index 000000000..c1becab2d
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/toolbar.js
@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "> 28"
+  }
+};
+
+const { Toolbar } = require("./toolbar/model");
+require("./toolbar/view");
+
+exports.Toolbar = Toolbar;
diff --git a/toolkit/jetpack/sdk/ui/toolbar/model.js b/toolkit/jetpack/sdk/ui/toolbar/model.js
new file mode 100644
index 000000000..5c5428606
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/toolbar/model.js
@@ -0,0 +1,151 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "> 28"
+  }
+};
+
+const { Class } = require("../../core/heritage");
+const { EventTarget } = require("../../event/target");
+const { off, setListeners, emit } = require("../../event/core");
+const { Reactor, foldp, merges, send } = require("../../event/utils");
+const { Disposable } = require("../../core/disposable");
+const { InputPort } = require("../../input/system");
+const { OutputPort } = require("../../output/system");
+const { identify } = require("../id");
+const { pairs, object, map, each } = require("../../util/sequence");
+const { patch, diff } = require("diffpatcher/index");
+const { contract } = require("../../util/contract");
+const { id: addonID } = require("../../self");
+
+// Input state is accumulated from the input received form the toolbar
+// view code & local output. Merging local output reflects local state
+// changes without complete roundloop.
+const input = foldp(patch, {}, new InputPort({ id: "toolbar-changed" }));
+const output = new OutputPort({ id: "toolbar-change" });
+
+// Takes toolbar title and normalizes is to an
+// identifier, also prefixes with add-on id.
+const titleToId = title =>
+  ("toolbar-" + addonID + "-" + title).
+    toLowerCase().
+    replace(/\s/g, "-").
+    replace(/[^A-Za-z0-9_\-]/g, "");
+
+const validate = contract({
+  title: {
+    is: ["string"],
+    ok: x => x.length > 0,
+    msg: "The `option.title` string must be provided"
+  },
+  items: {
+    is:["undefined", "object", "array"],
+    msg: "The `options.items` must be iterable sequence of items"
+  },
+  hidden: {
+    is: ["boolean", "undefined"],
+    msg: "The `options.hidden` must be boolean"
+  }
+});
+
+// Toolbars is a mapping between `toolbar.id` & `toolbar` instances,
+// which is used to find intstance for dispatching events.
+var toolbars = new Map();
+
+const Toolbar = Class({
+  extends: EventTarget,
+  implements: [Disposable],
+  initialize: function(params={}) {
+    const options = validate(params);
+    const id = titleToId(options.title);
+
+    if (toolbars.has(id))
+      throw Error("Toolbar with this id already exists: " + id);
+
+    // Set of the items in the toolbar isn't mutable, as a matter of fact
+    // it just defines desired set of items, actual set is under users
+    // control. Conver test to an array and freeze to make sure users won't
+    // try mess with it.
+    const items = Object.freeze(options.items ? [...options.items] : []);
+
+    const initial = {
+      id: id,
+      title: options.title,
+      // By default toolbars are visible when add-on is installed, unless
+      // add-on authors decides it should be hidden. From that point on
+      // user is in control.
+      collapsed: !!options.hidden,
+      // In terms of state only identifiers of items matter.
+      items: items.map(identify)
+    };
+
+    this.id = id;
+    this.items = items;
+
+    toolbars.set(id, this);
+    setListeners(this, params);
+
+    // Send initial state to the host so it can reflect it
+    // into a user interface.
+    send(output, object([id, initial]));
+  },
+
+  get title() {
+    const state = reactor.value[this.id];
+    return state && state.title;
+  },
+  get hidden() {
+    const state = reactor.value[this.id];
+    return state && state.collapsed;
+  },
+
+  destroy: function() {
+    send(output, object([this.id, null]));
+  },
+  // `JSON.stringify` serializes objects based of the return
+  // value of this method. For convinienc we provide this method
+  // to serialize actual state data. Note: items will also be
+  // serialized so they should probably implement `toJSON`.
+  toJSON: function() {
+    return {
+      id: this.id,
+      title: this.title,
+      hidden: this.hidden,
+      items: this.items
+    };
+  }
+});
+exports.Toolbar = Toolbar;
+identify.define(Toolbar, toolbar => toolbar.id);
+
+const dispose = toolbar => {
+  toolbars.delete(toolbar.id);
+  emit(toolbar, "detach");
+  off(toolbar);
+};
+
+const reactor = new Reactor({
+  onStep: (present, past) => {
+    const delta = diff(past, present);
+
+    each(([id, update]) => {
+      const toolbar = toolbars.get(id);
+
+      // Remove
+      if (!update)
+        dispose(toolbar);
+      // Add
+      else if (!past[id])
+        emit(toolbar, "attach");
+      // Update
+      else
+        emit(toolbar, update.collapsed ? "hide" : "show", toolbar);
+    }, pairs(delta));
+  }
+});
+reactor.run(input);
diff --git a/toolkit/jetpack/sdk/ui/toolbar/view.js b/toolkit/jetpack/sdk/ui/toolbar/view.js
new file mode 100644
index 000000000..4ef0c3d46
--- /dev/null
+++ b/toolkit/jetpack/sdk/ui/toolbar/view.js
@@ -0,0 +1,248 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental",
+  "engines": {
+    "Firefox": "> 28"
+  }
+};
+
+const { Cu } = require("chrome");
+const { CustomizableUI } = Cu.import('resource:///modules/CustomizableUI.jsm', {});
+const { subscribe, send, Reactor, foldp, lift, merges } = require("../../event/utils");
+const { InputPort } = require("../../input/system");
+const { OutputPort } = require("../../output/system");
+const { Interactive } = require("../../input/browser");
+const { CustomizationInput } = require("../../input/customizable-ui");
+const { pairs, map, isEmpty, object,
+        each, keys, values } = require("../../util/sequence");
+const { curry, flip } = require("../../lang/functional");
+const { patch, diff } = require("diffpatcher/index");
+const prefs = require("../../preferences/service");
+const { getByOuterId } = require("../../window/utils");
+const { ignoreWindow } = require('../../private-browsing/utils');
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+const PREF_ROOT = "extensions.sdk-toolbar-collapsed.";
+
+
+// There are two output ports one for publishing changes that occured
+// and the other for change requests. Later is synchronous and is only
+// consumed here. Note: it needs to be synchronous to avoid race conditions
+// when `collapsed` attribute changes are caused by user interaction and
+// toolbar is destroyed between the ticks.
+const output = new OutputPort({ id: "toolbar-changed" });
+const syncoutput = new OutputPort({ id: "toolbar-change", sync: true });
+
+// Merge disptached changes and recevied changes from models to keep state up to
+// date.
+const Toolbars = foldp(patch, {}, merges([new InputPort({ id: "toolbar-changed" }),
+                                          new InputPort({ id: "toolbar-change" })]));
+const State = lift((toolbars, windows, customizable) =>
+  ({windows: windows, toolbars: toolbars, customizable: customizable}),
+  Toolbars, Interactive, new CustomizationInput());
+
+// Shared event handler that makes `event.target.parent` collapsed.
+// Used as toolbar's close buttons click handler.
+const collapseToolbar = event => {
+  const toolbar = event.target.parentNode;
+  toolbar.collapsed = true;
+};
+
+const parseAttribute = x =>
+  x === "true" ? true :
+  x === "false" ? false :
+  x === "" ? null :
+  x;
+
+// Shared mutation observer that is used to observe `toolbar` node's
+// attribute mutations. Mutations are aggregated in the `delta` hash
+// and send to `ToolbarStateChanged` channel to let model know state
+// has changed.
+const attributesChanged = mutations => {
+  const delta = mutations.reduce((changes, {attributeName, target}) => {
+    const id = target.id;
+    const field = attributeName === "toolbarname" ? "title" : attributeName;
+    let change = changes[id] || (changes[id] = {});
+    change[field] = parseAttribute(target.getAttribute(attributeName));
+    return changes;
+  }, {});
+
+  // Calculate what are the updates from the current state and if there are
+  // any send them.
+  const updates = diff(reactor.value, patch(reactor.value, delta));
+
+  if (!isEmpty(pairs(updates))) {
+    // TODO: Consider sending sync to make sure that there won't be a new
+    // update doing a delete in the meantime.
+    send(syncoutput, updates);
+  }
+};
+
+
+// Utility function creates `toolbar` with a "close" button and returns
+// it back. In addition it set's up a listener and observer to communicate
+// state changes.
+const addView = curry((options, {document, window}) => {
+  if (ignoreWindow(window))
+    return;
+
+  let view = document.createElementNS(XUL_NS, "toolbar");
+  view.setAttribute("id", options.id);
+  view.setAttribute("collapsed", options.collapsed);
+  view.setAttribute("toolbarname", options.title);
+  view.setAttribute("pack", "end");
+  view.setAttribute("customizable", "false");
+  view.setAttribute("style", "padding: 2px 0; max-height: 40px;");
+  view.setAttribute("mode", "icons");
+  view.setAttribute("iconsize", "small");
+  view.setAttribute("context", "toolbar-context-menu");
+  view.setAttribute("class", "chromeclass-toolbar");
+
+  let label = document.createElementNS(XUL_NS, "label");
+  label.setAttribute("value", options.title);
+  label.setAttribute("collapsed", "true");
+  view.appendChild(label);
+
+  let closeButton = document.createElementNS(XUL_NS, "toolbarbutton");
+  closeButton.setAttribute("id", "close-" + options.id);
+  closeButton.setAttribute("class", "close-icon");
+  closeButton.setAttribute("customizable", false);
+  closeButton.addEventListener("command", collapseToolbar);
+
+  view.appendChild(closeButton);
+
+  // In order to have a close button not costumizable, aligned on the right,
+  // leaving the customizable capabilities of Australis, we need to create
+  // a toolbar inside a toolbar.
+  // This is should be a temporary hack, we should have a proper XBL for toolbar
+  // instead. See:
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=982005
+  let toolbar = document.createElementNS(XUL_NS, "toolbar");
+  toolbar.setAttribute("id", "inner-" + options.id);
+  toolbar.setAttribute("defaultset", options.items.join(","));
+  toolbar.setAttribute("customizable", "true");
+  toolbar.setAttribute("style", "-moz-appearance: none; overflow: hidden");
+  toolbar.setAttribute("mode", "icons");
+  toolbar.setAttribute("iconsize", "small");
+  toolbar.setAttribute("context", "toolbar-context-menu");
+  toolbar.setAttribute("flex", "1");
+
+  view.insertBefore(toolbar, closeButton);
+
+  const observer = new document.defaultView.MutationObserver(attributesChanged);
+  observer.observe(view, { attributes: true,
+                           attributeFilter: ["collapsed", "toolbarname"] });
+
+  const toolbox = document.getElementById("navigator-toolbox");
+  toolbox.appendChild(view);
+});
+const viewAdd = curry(flip(addView));
+
+const removeView = curry((id, {document}) => {
+  const view = document.getElementById(id);
+  if (view) view.remove();
+});
+
+const updateView = curry((id, {title, collapsed, isCustomizing}, {document}) => {
+  const view = document.getElementById(id);
+
+  if (!view)
+    return;
+
+  if (title)
+    view.setAttribute("toolbarname", title);
+
+  if (collapsed !== void(0))
+    view.setAttribute("collapsed", Boolean(collapsed));
+
+  if (isCustomizing !== void(0)) {
+    view.querySelector("label").collapsed = !isCustomizing;
+    view.querySelector("toolbar").style.visibility = isCustomizing
+                                                ? "hidden" : "visible";
+  }
+});
+
+const viewUpdate = curry(flip(updateView));
+
+// Utility function used to register toolbar into CustomizableUI.
+const registerToolbar = state => {
+  // If it's first additon register toolbar as customizableUI component.
+  CustomizableUI.registerArea("inner-" + state.id, {
+    type: CustomizableUI.TYPE_TOOLBAR,
+    legacy: true,
+    defaultPlacements: [...state.items]
+  });
+};
+// Utility function used to unregister toolbar from the CustomizableUI.
+const unregisterToolbar = CustomizableUI.unregisterArea;
+
+const reactor = new Reactor({
+  onStep: (present, past) => {
+    const delta = diff(past, present);
+
+    each(([id, update]) => {
+      // If update is `null` toolbar is removed, in such case
+      // we unregister toolbar and remove it from each window
+      // it was added to.
+      if (update === null) {
+        unregisterToolbar("inner-" + id);
+        each(removeView(id), values(past.windows));
+
+        send(output, object([id, null]));
+      }
+      else if (past.toolbars[id]) {
+        // If `collapsed` state for toolbar was updated, persist
+        // it for a future sessions.
+        if (update.collapsed !== void(0))
+          prefs.set(PREF_ROOT + id, update.collapsed);
+
+        // Reflect update in each window it was added to.
+        each(updateView(id, update), values(past.windows));
+
+        send(output, object([id, update]));
+      }
+      // Hack: Mutation observers are invoked async, which means that if
+      // client does `hide(toolbar)` & then `toolbar.destroy()` by the
+      // time we'll get update for `collapsed` toolbar will be removed.
+      // For now we check if `update.id` is present which will be undefined
+      // in such cases.
+      else if (update.id) {
+        // If it is a new toolbar we create initial state by overriding
+        // `collapsed` filed with value persisted in previous sessions.
+        const state = patch(update, {
+          collapsed: prefs.get(PREF_ROOT + id, update.collapsed),
+        });
+
+        // Register toolbar and add it each window known in the past
+        // (note that new windows if any will be handled in loop below).
+        registerToolbar(state);
+        each(addView(state), values(past.windows));
+
+        send(output, object([state.id, state]));
+      }
+    }, pairs(delta.toolbars));
+
+    // Add views to every window that was added.
+    each(window => {
+      if (window)
+        each(viewAdd(window), values(past.toolbars));
+    }, values(delta.windows));
+
+    each(([id, isCustomizing]) => {
+      each(viewUpdate(getByOuterId(id), {isCustomizing: !!isCustomizing}),
+        keys(present.toolbars));
+
+    }, pairs(delta.customizable))
+  },
+  onEnd: state => {
+    each(id => {
+      unregisterToolbar("inner-" + id);
+      each(removeView(id), values(state.windows));
+    }, keys(state.toolbars));
+  }
+});
+reactor.run(State);
diff --git a/toolkit/jetpack/sdk/uri/resource.js b/toolkit/jetpack/sdk/uri/resource.js
new file mode 100644
index 000000000..8a1dcbf2c
--- /dev/null
+++ b/toolkit/jetpack/sdk/uri/resource.js
@@ -0,0 +1,37 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const {Cc, Ci} = require("chrome");
+const ioService = Cc["@mozilla.org/network/io-service;1"].
+                  getService(Ci.nsIIOService);
+const resourceHandler = ioService.getProtocolHandler("resource").
+                        QueryInterface(Ci.nsIResProtocolHandler);
+
+const URI = (uri, base=null) =>
+  ioService.newURI(uri, null, base && URI(base))
+
+const mount = (domain, uri) =>
+  resourceHandler.setSubstitution(domain, ioService.newURI(uri, null, null));
+exports.mount = mount;
+
+const unmount = (domain, uri) =>
+  resourceHandler.setSubstitution(domain, null);
+exports.unmount = unmount;
+
+const domain = 1;
+const path = 2;
+const resolve = (uri) => {
+  const match = /resource\:\/\/([^\/]+)\/{0,1}([\s\S]*)/.exec(uri);
+  const domain = match && match[1];
+  const path = match && match[2];
+  return !match ? null :
+         !resourceHandler.hasSubstitution(domain) ? null :
+  resourceHandler.resolveURI(URI(`/${path}`, `resource://${domain}/`));
+}
+exports.resolve = resolve;
diff --git a/toolkit/jetpack/sdk/url.js b/toolkit/jetpack/sdk/url.js
new file mode 100644
index 000000000..ae16ac4a8
--- /dev/null
+++ b/toolkit/jetpack/sdk/url.js
@@ -0,0 +1,349 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci, Cr, Cu } = require("chrome");
+
+const { Class } = require("./core/heritage");
+const base64 = require("./base64");
+var tlds = Cc["@mozilla.org/network/effective-tld-service;1"]
+          .getService(Ci.nsIEffectiveTLDService);
+
+var ios = Cc['@mozilla.org/network/io-service;1']
+          .getService(Ci.nsIIOService);
+
+var resProt = ios.getProtocolHandler("resource")
+              .QueryInterface(Ci.nsIResProtocolHandler);
+
+var URLParser = Cc["@mozilla.org/network/url-parser;1?auth=no"]
+                .getService(Ci.nsIURLParser);
+
+const { Services } = Cu.import("resource://gre/modules/Services.jsm");
+
+function newURI(uriStr, base) {
+  try {
+    let baseURI = base ? ios.newURI(base, null, null) : null;
+    return ios.newURI(uriStr, null, baseURI);
+  }
+  catch (e) {
+    if (e.result == Cr.NS_ERROR_MALFORMED_URI) {
+      throw new Error("malformed URI: " + uriStr);
+    }
+    if (e.result == Cr.NS_ERROR_FAILURE ||
+        e.result == Cr.NS_ERROR_ILLEGAL_VALUE) {
+      throw new Error("invalid URI: " + uriStr);
+    }
+  }
+}
+
+function resolveResourceURI(uri) {
+  var resolved;
+  try {
+    resolved = resProt.resolveURI(uri);
+  }
+  catch (e) {
+    if (e.result == Cr.NS_ERROR_NOT_AVAILABLE) {
+      throw new Error("resource does not exist: " + uri.spec);
+    }
+  }
+  return resolved;
+}
+
+var fromFilename = exports.fromFilename = function fromFilename(path) {
+  var file = Cc['@mozilla.org/file/local;1']
+             .createInstance(Ci.nsILocalFile);
+  file.initWithPath(path);
+  return ios.newFileURI(file).spec;
+};
+
+var toFilename = exports.toFilename = function toFilename(url) {
+  var uri = newURI(url);
+  if (uri.scheme == "resource")
+    uri = newURI(resolveResourceURI(uri));
+  if (uri.scheme == "chrome") {
+    var channel = ios.newChannelFromURI2(uri,
+                                         null,      // aLoadingNode
+                                         Services.scriptSecurityManager.getSystemPrincipal(),
+                                         null,      // aTriggeringPrincipal
+                                         Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
+                                         Ci.nsIContentPolicy.TYPE_OTHER);
+    try {
+      channel = channel.QueryInterface(Ci.nsIFileChannel);
+      return channel.file.path;
+    }
+    catch (e) {
+      if (e.result == Cr.NS_NOINTERFACE) {
+        throw new Error("chrome url isn't on filesystem: " + url);
+      }
+    }
+  }
+  if (uri.scheme == "file") {
+    var file = uri.QueryInterface(Ci.nsIFileURL).file;
+    return file.path;
+  }
+  throw new Error("cannot map to filename: " + url);
+};
+
+function URL(url, base) {
+  if (!(this instanceof URL)) {
+     return new URL(url, base);
+  }
+
+  var uri = newURI(url, base);
+
+  var userPass = null;
+  try {
+    userPass = uri.userPass ? uri.userPass : null;
+  }
+  catch (e) {
+    if (e.result != Cr.NS_ERROR_FAILURE) {
+      throw e;
+    }
+  }
+
+  var host = null;
+  try {
+    host = uri.host;
+  }
+  catch (e) {
+    if (e.result != Cr.NS_ERROR_FAILURE) {
+      throw e;
+    }
+  }
+
+  var port = null;
+  try {
+    port = uri.port == -1 ? null : uri.port;
+  }
+  catch (e) {
+    if (e.result != Cr.NS_ERROR_FAILURE) {
+      throw e;
+    }
+  }
+
+  let fileName = "/";
+  try {
+    fileName = uri.QueryInterface(Ci.nsIURL).fileName;
+  } catch (e) {
+    if (e.result != Cr.NS_NOINTERFACE) {
+      throw e;
+    }
+  }
+
+  let uriData = [uri.path, uri.path.length, {}, {}, {}, {}, {}, {}];
+  URLParser.parsePath.apply(URLParser, uriData);
+  let [{ value: filepathPos }, { value: filepathLen },
+    { value: queryPos }, { value: queryLen },
+    { value: refPos }, { value: refLen }] = uriData.slice(2);
+
+  let hash = uri.ref ? "#" + uri.ref : "";
+  let pathname = uri.path.substr(filepathPos, filepathLen);
+  let search = uri.path.substr(queryPos, queryLen);
+  search = search ? "?" + search : "";
+
+  this.__defineGetter__("fileName", () => fileName);
+  this.__defineGetter__("scheme", () => uri.scheme);
+  this.__defineGetter__("userPass", () => userPass);
+  this.__defineGetter__("host", () => host);
+  this.__defineGetter__("hostname", () => host);
+  this.__defineGetter__("port", () => port);
+  this.__defineGetter__("path", () => uri.path);
+  this.__defineGetter__("pathname", () => pathname);
+  this.__defineGetter__("hash", () => hash);
+  this.__defineGetter__("href", () => uri.spec);
+  this.__defineGetter__("origin", () => uri.prePath);
+  this.__defineGetter__("protocol", () => uri.scheme + ":");
+  this.__defineGetter__("search", () => search);
+
+  Object.defineProperties(this, {
+    toString: {
+      value() {
+        return new String(uri.spec).toString();
+      },
+      enumerable: false
+    },
+    valueOf: {
+      value() {
+        return new String(uri.spec).valueOf();
+      },
+      enumerable: false
+    },
+    toSource: {
+      value() {
+        return new String(uri.spec).toSource();
+      },
+      enumerable: false
+    },
+    // makes more sense to flatten to string, easier to travel across JSON
+    toJSON: {
+      value() {
+        return new String(uri.spec).toString();
+      },
+      enumerable: false
+    }
+  });
+
+  return this;
+};
+
+URL.prototype = Object.create(String.prototype);
+exports.URL = URL;
+
+/**
+ * Parse and serialize a Data URL.
+ *
+ * See: http://tools.ietf.org/html/rfc2397
+ *
+ * Note: Could be extended in the future to decode / encode automatically binary
+ * data.
+ */
+const DataURL = Class({
+
+  get base64 () {
+    return "base64" in this.parameters;
+  },
+
+  set base64 (value) {
+    if (value)
+      this.parameters["base64"] = "";
+    else
+      delete this.parameters["base64"];
+  },
+  /**
+  * Initialize the Data URL object. If a uri is given, it will be parsed.
+  *
+  * @param {String} [uri] The uri to parse
+  *
+  * @throws {URIError} if the Data URL is malformed
+   */
+  initialize: function(uri) {
+    // Due to bug 751834 it is not possible document and define these
+    // properties in the prototype.
+
+    /**
+     * An hashmap that contains the parameters of the Data URL. By default is
+     * empty, that accordingly to RFC is equivalent to {"charset" : "US-ASCII"}
+     */
+    this.parameters = {};
+
+    /**
+     * The MIME type of the data. By default is empty, that accordingly to RFC
+     * is equivalent to "text/plain"
+     */
+    this.mimeType = "";
+
+    /**
+     * The string that represent the data in the Data URL
+     */
+    this.data = "";
+
+    if (typeof uri === "undefined")
+      return;
+
+    uri = String(uri);
+
+    let matches = uri.match(/^data:([^,]*),(.*)$/i);
+
+    if (!matches)
+      throw new URIError("Malformed Data URL: " + uri);
+
+    let mediaType = matches[1].trim();
+
+    this.data = decodeURIComponent(matches[2].trim());
+
+    if (!mediaType)
+      return;
+
+    let parametersList = mediaType.split(";");
+
+    this.mimeType = parametersList.shift().trim();
+
+    for (let parameter, i = 0; parameter = parametersList[i++];) {
+      let pairs = parameter.split("=");
+      let name = pairs[0].trim();
+      let value = pairs.length > 1 ? decodeURIComponent(pairs[1].trim()) : "";
+
+      this.parameters[name] = value;
+    }
+
+    if (this.base64)
+      this.data = base64.decode(this.data);
+
+  },
+
+  /**
+   * Returns the object as a valid Data URL string
+   *
+   * @returns {String} The Data URL
+   */
+  toString : function() {
+    let parametersList = [];
+
+    for (let name in this.parameters) {
+      let encodedParameter = encodeURIComponent(name);
+      let value = this.parameters[name];
+
+      if (value)
+        encodedParameter += "=" + encodeURIComponent(value);
+
+      parametersList.push(encodedParameter);
+    }
+
+    // If there is at least a parameter, add an empty string in order
+    // to start with a `;` on join call.
+    if (parametersList.length > 0)
+      parametersList.unshift("");
+
+    let data = this.base64 ? base64.encode(this.data) : this.data;
+
+    return "data:" +
+      this.mimeType +
+      parametersList.join(";") + "," +
+      encodeURIComponent(data);
+  }
+});
+
+exports.DataURL = DataURL;
+
+var getTLD = exports.getTLD = function getTLD (url) {
+  let uri = newURI(url.toString());
+  let tld = null;
+  try {
+    tld = tlds.getPublicSuffix(uri);
+  }
+  catch (e) {
+    if (e.result != Cr.NS_ERROR_INSUFFICIENT_DOMAIN_LEVELS &&
+        e.result != Cr.NS_ERROR_HOST_IS_IP_ADDRESS) {
+      throw e;
+    }
+  }
+  return tld;
+};
+
+var isValidURI = exports.isValidURI = function (uri) {
+  try {
+    newURI(uri);
+  }
+  catch(e) {
+    return false;
+  }
+  return true;
+}
+
+function isLocalURL(url) {
+  if (String.indexOf(url, './') === 0)
+    return true;
+
+  try {
+    return ['resource', 'data', 'chrome'].indexOf(URL(url).scheme) > -1;
+  }
+  catch(e) {}
+
+  return false;
+}
+exports.isLocalURL = isLocalURL;
diff --git a/toolkit/jetpack/sdk/url/utils.js b/toolkit/jetpack/sdk/url/utils.js
new file mode 100644
index 000000000..aa5759204
--- /dev/null
+++ b/toolkit/jetpack/sdk/url/utils.js
@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Cc, Ci, Cr } = require("chrome");
+const IOService = Cc["@mozilla.org/network/io-service;1"].
+                    getService(Ci.nsIIOService);
+const { isValidURI } = require("../url");
+const { method } = require("../../method/core");
+
+function newURI (uri) {
+  if (!isValidURI(uri))
+    throw new Error("malformed URI: " + uri);
+  return IOService.newURI(uri, null, null);
+}
+exports.newURI = newURI;
+
+var getURL = method('sdk/url:getURL');
+getURL.define(String, url => url);
+getURL.define(function (object) {
+  return null;
+});
+exports.getURL = getURL;
diff --git a/toolkit/jetpack/sdk/util/array.js b/toolkit/jetpack/sdk/util/array.js
new file mode 100644
index 000000000..1d61a973e
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/array.js
@@ -0,0 +1,123 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+/**
+ * Returns `true` if given `array` contain given `element` or `false`
+ * otherwise.
+ * @param {Array} array
+ *    Target array.
+ * @param {Object|String|Number|Boolean} element
+ *    Element being looked up.
+ * @returns {Boolean}
+ */
+var has = exports.has = function has(array, element) {
+  // shorter and faster equivalent of `array.indexOf(element) >= 0`
+  return !!~array.indexOf(element);
+};
+var hasAny = exports.hasAny = function hasAny(array, elements) {
+  if (arguments.length < 2)
+    return false;
+  if (!Array.isArray(elements))
+    elements = [ elements ];
+  return array.some(function (element) {
+      return has(elements, element);
+  });
+};
+
+/**
+ * Adds given `element` to the given `array` if it does not contain it yet.
+ * `true` is returned if element was added otherwise `false` is returned.
+ * @param {Array} array
+ *    Target array.
+ * @param {Object|String|Number|Boolean} element
+ *    Element to be added.
+ * @returns {Boolean}
+ */
+var add = exports.add = function add(array, element) {
+  var result;
+  if ((result = !has(array, element)))
+    array.push(element);
+
+  return result;
+};
+
+/**
+ * Removes first occurrence of the given `element` from the given `array`. If
+ * `array` does not contain given `element` `false` is returned otherwise
+ * `true` is returned.
+ * @param {Array} array
+ *    Target array.
+ * @param {Object|String|Number|Boolean} element
+ *    Element to be removed.
+ * @returns {Boolean}
+ */
+exports.remove = function remove(array, element) {
+  var result;
+  if ((result = has(array, element)))
+    array.splice(array.indexOf(element), 1);
+
+  return result;
+};
+
+/**
+ * Produces a duplicate-free version of the given `array`.
+ * @param {Array} array
+ *    Source array.
+ * @returns {Array}
+ */
+function unique(array) {
+  return array.reduce(function(result, item) {
+    add(result, item);
+    return result;
+  }, []);
+};
+exports.unique = unique;
+
+/**
+ * Produce an array that contains the union: each distinct element from all
+ * of the passed-in arrays.
+ */
+function union() {
+  return unique(Array.concat.apply(null, arguments));
+};
+exports.union = union;
+
+exports.flatten = function flatten(array){
+   var flat = [];
+   for (var i = 0, l = array.length; i < l; i++) {
+    flat = flat.concat(Array.isArray(array[i]) ? flatten(array[i]) : array[i]);
+   }
+   return flat;
+};
+
+function fromIterator(iterator) {
+  let array = [];
+  if (iterator.__iterator__) {
+    for (let item of iterator)
+      array.push(item);
+  }
+  else {
+    for (let item of iterator)
+      array.push(item);
+  }
+  return array;
+}
+exports.fromIterator = fromIterator;
+
+function find(array, predicate, fallback) {
+  var index = 0;
+  var count = array.length;
+  while (index < count) {
+    var value = array[index];
+    if (predicate(value)) return value;
+    else index = index + 1;
+  }
+  return fallback;
+}
+exports.find = find;
diff --git a/toolkit/jetpack/sdk/util/collection.js b/toolkit/jetpack/sdk/util/collection.js
new file mode 100644
index 000000000..194a29470
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/collection.js
@@ -0,0 +1,115 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+exports.Collection = Collection;
+
+/**
+ * Adds a collection property to the given object.  Setting the property to a
+ * scalar value empties the collection and adds the value.  Setting it to an
+ * array empties the collection and adds all the items in the array.
+ *
+ * @param obj
+ *        The property will be defined on this object.
+ * @param propName
+ *        The name of the property.
+ * @param array
+ *        If given, this will be used as the collection's backing array.
+ */
+exports.addCollectionProperty = function addCollProperty(obj, propName, array) {
+  array = array || [];
+  let publicIface = new Collection(array);
+
+  Object.defineProperty(obj, propName, {
+    configurable: true,
+    enumerable: true,
+
+    set: function set(itemOrItems) {
+      array.splice(0, array.length);
+      publicIface.add(itemOrItems);
+    },
+
+    get: function get() {
+      return publicIface;
+    }
+  });
+};
+
+/**
+ * A collection is ordered, like an array, but its items are unique, like a set.
+ *
+ * @param array
+ *        The collection is backed by an array.  If this is given, it will be
+ *        used as the backing array.  This way the caller can fully control the
+ *        collection.  Otherwise a new empty array will be used, and no one but
+ *        the collection will have access to it.
+ */
+function Collection(array) {
+  array = array || [];
+
+  /**
+   * Provides iteration over the collection.  Items are yielded in the order
+   * they were added.
+   */
+  this.__iterator__ = function Collection___iterator__() {
+    let items = array.slice();
+    for (let i = 0; i < items.length; i++)
+      yield items[i];
+  };
+
+  /**
+   * The number of items in the collection.
+   */
+  this.__defineGetter__("length", function Collection_get_length() {
+    return array.length;
+  });
+
+  /**
+   * Adds a single item or an array of items to the collection.  Any items
+   * already contained in the collection are ignored.
+   *
+   * @param  itemOrItems
+   *         An item or array of items.
+   * @return The collection.
+   */
+  this.add = function Collection_add(itemOrItems) {
+    let items = toArray(itemOrItems);
+    for (let i = 0; i < items.length; i++) {
+      let item = items[i];
+      if (array.indexOf(item) < 0)
+        array.push(item);
+    }
+    return this;
+  };
+
+  /**
+   * Removes a single item or an array of items from the collection.  Any items
+   * not contained in the collection are ignored.
+   *
+   * @param  itemOrItems
+   *         An item or array of items.
+   * @return The collection.
+   */
+  this.remove = function Collection_remove(itemOrItems) {
+    let items = toArray(itemOrItems);
+    for (let i = 0; i < items.length; i++) {
+      let idx = array.indexOf(items[i]);
+      if (idx >= 0)
+        array.splice(idx, 1);
+    }
+    return this;
+  };
+};
+
+function toArray(itemOrItems) {
+  let isArr = itemOrItems &&
+              itemOrItems.constructor &&
+              itemOrItems.constructor.name === "Array";
+  return isArr ? itemOrItems : [itemOrItems];
+}
diff --git a/toolkit/jetpack/sdk/util/contract.js b/toolkit/jetpack/sdk/util/contract.js
new file mode 100644
index 000000000..c689ea601
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/contract.js
@@ -0,0 +1,55 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { validateOptions: valid } = require("../deprecated/api-utils");
+const method = require("method/core");
+
+// Function takes property validation rules and returns function that given
+// an `options` object will return validated / normalized options back. If
+// option(s) are invalid validator will throw exception described by rules.
+// Returned will also have contain `rules` property with a given validation
+// rules and `properties` function that can be used to generate validated
+// property getter and setters can be mixed into prototype. For more details
+// see `properties` function below.
+function contract(rules) {
+  const validator = (instance, options) => {
+    return valid(options || instance || {}, rules);
+  };
+  validator.rules = rules
+  validator.properties = function(modelFor) {
+    return properties(modelFor, rules);
+  }
+  return validator;
+}
+exports.contract = contract
+
+// Function takes `modelFor` instance state model accessor functions and
+// a property validation rules and generates object with getters and setters
+// that can be mixed into prototype. Property accessors update model for the
+// given instance. If you wish to react to property updates you can always
+// override setters to put specific logic.
+function properties(modelFor, rules) {
+  let descriptor = Object.keys(rules).reduce(function(descriptor, name) {
+    descriptor[name] = {
+      get: function() { return modelFor(this)[name] },
+      set: function(value) {
+        let change = {};
+        change[name] = value;
+        modelFor(this)[name] = valid(change, rules)[name];
+      }
+    }
+    return descriptor
+  }, {});
+  return Object.create(Object.prototype, descriptor);
+}
+exports.properties = properties;
+
+const validate = method("contract/validate");
+exports.validate = validate;
diff --git a/toolkit/jetpack/sdk/util/deprecate.js b/toolkit/jetpack/sdk/util/deprecate.js
new file mode 100644
index 000000000..40f236de5
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/deprecate.js
@@ -0,0 +1,40 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { get, format } = require("../console/traceback");
+const { get: getPref } = require("../preferences/service");
+const PREFERENCE = "devtools.errorconsole.deprecation_warnings";
+
+function deprecateUsage(msg) {
+  // Print caller stacktrace in order to help figuring out which code
+  // does use deprecated thing
+  let stack = get().slice(2);
+
+  if (getPref(PREFERENCE)) 
+    console.error("DEPRECATED: " + msg + "\n" + format(stack));
+}
+exports.deprecateUsage = deprecateUsage;
+
+function deprecateFunction(fun, msg) {
+  return function deprecated() {
+    deprecateUsage(msg);
+    return fun.apply(this, arguments);
+  };
+}
+exports.deprecateFunction = deprecateFunction;
+
+function deprecateEvent(fun, msg, evtTypes) {
+  return function deprecateEvent(evtType) {
+  	if (evtTypes.indexOf(evtType) >= 0)
+      deprecateUsage(msg);
+    return fun.apply(this, arguments);
+  };
+}
+exports.deprecateEvent = deprecateEvent;
diff --git a/toolkit/jetpack/sdk/util/dispatcher.js b/toolkit/jetpack/sdk/util/dispatcher.js
new file mode 100644
index 000000000..67d29dfed
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/dispatcher.js
@@ -0,0 +1,54 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const method = require("method/core");
+
+// Utility function that is just an enhancement over `method` to
+// allow predicate based dispatch in addition to polymorphic
+// dispatch. Unfortunately polymorphic dispatch does not quite
+// cuts it in the world of XPCOM where no types / classes exist
+// and all the XUL nodes share same type / prototype.
+// Probably this is more generic and belongs some place else, but
+// we can move it later once this will be relevant.
+var dispatcher = hint => {
+  const base = method(hint);
+  // Make a map for storing predicate, implementation mappings.
+  let implementations = new Map();
+
+  // Dispatcher function goes through `predicate, implementation`
+  // pairs to find predicate that matches first argument and
+  // returns application of arguments on the associated
+  // `implementation`. If no matching predicate is found delegates
+  // to a `base` polymorphic function.
+  let dispatch = (value, ...rest) => {
+    for (let [predicate, implementation] of implementations) {
+      if (predicate(value))
+        return implementation(value, ...rest);
+    }
+
+    return base(value, ...rest);
+  };
+
+  // Expose base API.
+  dispatch.define = base.define;
+  dispatch.implement = base.implement;
+  dispatch.toString = base.toString;
+
+  // Add a `when` function to allow extending function via
+  // predicates.
+  dispatch.when = (predicate, implementation) => {
+    if (implementations.has(predicate))
+      throw TypeError("Already implemented for the given predicate");
+    implementations.set(predicate, implementation);
+  };
+
+  return dispatch;
+};
+
+exports.dispatcher = dispatcher;
diff --git a/toolkit/jetpack/sdk/util/list.js b/toolkit/jetpack/sdk/util/list.js
new file mode 100644
index 000000000..6d7d2dea9
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/list.js
@@ -0,0 +1,90 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+const { Class } = require('../core/heritage');
+const listNS = require('../core/namespace').ns();
+
+const listOptions = {
+  /**
+   * List constructor can take any number of element to populate itself.
+   * @params {Object|String|Number} element
+   * @example
+   *    List(1,2,3).length == 3 // true
+   */
+  initialize: function List() {
+    listNS(this).keyValueMap = [];
+
+    for (let i = 0, ii = arguments.length; i < ii; i++)
+      addListItem(this, arguments[i]);
+  },
+  /**
+   * Number of elements in this list.
+   * @type {Number}
+   */
+  get length() {
+    return listNS(this).keyValueMap.length;
+  },
+   /**
+    * Returns a string representing this list.
+    * @returns {String}
+    */
+  toString: function toString() {
+    return 'List(' + listNS(this).keyValueMap + ')';
+  },
+  /**
+   * Custom iterator providing `List`s enumeration behavior.
+   * We cant reuse `_iterator` that is defined by `Iterable` since it provides
+   * iteration in an arbitrary order.
+   * @see https://developer.mozilla.org/en/JavaScript/Reference/Statements/for...in
+   * @param {Boolean} onKeys
+   */
+  __iterator__: function __iterator__(onKeys, onKeyValue) {
+    let array = listNS(this).keyValueMap.slice(0),
+                i = -1;
+    for (let element of array)
+      yield onKeyValue ? [++i, element] : onKeys ? ++i : element;
+  },
+};
+listOptions[Symbol.iterator] = function iterator() {
+    return listNS(this).keyValueMap.slice(0)[Symbol.iterator]();
+};
+const List = Class(listOptions);
+exports.List = List;
+
+function addListItem(that, value) {
+  let list = listNS(that).keyValueMap,
+      index = list.indexOf(value);
+
+  if (-1 === index) {
+    try {
+      that[that.length] = value;
+    }
+    catch (e) {}
+    list.push(value);
+  }
+}
+exports.addListItem = addListItem;
+
+function removeListItem(that, element) {
+  let list = listNS(that).keyValueMap,
+      index = list.indexOf(element);
+
+  if (0 <= index) {
+    list.splice(index, 1);
+    try {
+      for (let length = list.length; index < length; index++)
+        that[index] = list[index];
+      that[list.length] = undefined;
+    }
+    catch(e){}
+  }
+}
+exports.removeListItem = removeListItem;
+
+exports.listNS = listNS;
diff --git a/toolkit/jetpack/sdk/util/match-pattern.js b/toolkit/jetpack/sdk/util/match-pattern.js
new file mode 100644
index 000000000..a0eb88b49
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/match-pattern.js
@@ -0,0 +1,113 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { URL } = require('../url');
+const cache = {};
+
+function MatchPattern(pattern) {
+  if (cache[pattern]) return cache[pattern];
+
+  if (typeof pattern.test == "function") {
+    // For compatibility with -moz-document rules, we require the RegExp's
+    // global, ignoreCase, and multiline flags to be set to false.
+    if (pattern.global) {
+      throw new Error("A RegExp match pattern cannot be set to `global` " +
+                      "(i.e. //g).");
+    }
+    if (pattern.multiline) {
+      throw new Error("A RegExp match pattern cannot be set to `multiline` " +
+                      "(i.e. //m).");
+    }
+
+    this.regexp = pattern;
+  }
+  else {
+    let firstWildcardPosition = pattern.indexOf("*");
+    let lastWildcardPosition = pattern.lastIndexOf("*");
+    if (firstWildcardPosition != lastWildcardPosition)
+      throw new Error("There can be at most one '*' character in a wildcard.");
+
+    if (firstWildcardPosition == 0) {
+      if (pattern.length == 1)
+        this.anyWebPage = true;
+      else if (pattern[1] != ".")
+        throw new Error("Expected a *.<domain name> string, got: " + pattern);
+      else
+        this.domain = pattern.substr(2);
+    }
+    else {
+      if (pattern.indexOf(":") == -1) {
+        throw new Error("When not using *.example.org wildcard, the string " +
+                        "supplied is expected to be either an exact URL to " +
+                        "match or a URL prefix. The provided string ('" +
+                        pattern + "') is unlikely to match any pages.");
+      }
+
+      if (firstWildcardPosition == -1)
+        this.exactURL = pattern;
+      else if (firstWildcardPosition == pattern.length - 1)
+        this.urlPrefix = pattern.substr(0, pattern.length - 1);
+      else {
+        throw new Error("The provided wildcard ('" + pattern + "') has a '*' " +
+                        "in an unexpected position. It is expected to be the " +
+                        "first or the last character in the wildcard.");
+      }
+    }
+  }
+
+  cache[pattern] = this;
+}
+
+MatchPattern.prototype = {
+  test: function MatchPattern_test(urlStr) {
+    try {
+      var url = URL(urlStr);
+    }
+    catch (err) {
+      return false;
+    }
+
+    // Test the URL against a RegExp pattern.  For compatibility with
+    // -moz-document rules, we require the RegExp to match the entire URL,
+    // so we not only test for a match, we also make sure the matched string
+    // is the entire URL string.
+    //
+    // Assuming most URLs don't match most match patterns, we call `test` for
+    // speed when determining whether or not the URL matches, then call `exec`
+    // for the small subset that match to make sure the entire URL matches.
+    if (this.regexp && this.regexp.test(urlStr) &&
+        this.regexp.exec(urlStr)[0] == urlStr)
+      return true;
+
+    if (this.anyWebPage && /^(https?|ftp)$/.test(url.scheme))
+      return true;
+
+    if (this.exactURL && this.exactURL == urlStr)
+      return true;
+
+    // Tests the urlStr against domain and check if
+    // wildcard submitted (*.domain.com), it only allows
+    // subdomains (sub.domain.com) or from the root (http://domain.com)
+    // and reject non-matching domains (otherdomain.com)
+    // bug 856913
+    if (this.domain && url.host &&
+         (url.host === this.domain ||
+          url.host.slice(-this.domain.length - 1) === "." + this.domain))
+      return true;
+
+    if (this.urlPrefix && 0 == urlStr.indexOf(this.urlPrefix))
+      return true;
+
+    return false;
+  },
+
+  toString: () => '[object MatchPattern]'
+};
+
+exports.MatchPattern = MatchPattern;
diff --git a/toolkit/jetpack/sdk/util/object.js b/toolkit/jetpack/sdk/util/object.js
new file mode 100644
index 000000000..9d202bb51
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/object.js
@@ -0,0 +1,104 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { flatten } = require('./array');
+
+/**
+ * Merges all the properties of all arguments into first argument. If two or
+ * more argument objects have own properties with the same name, the property
+ * is overridden, with precedence from right to left, implying, that properties
+ * of the object on the left are overridden by a same named property of the
+ * object on the right.
+ *
+ * Any argument given with "falsy" value - commonly `null` and `undefined` in
+ * case of objects - are skipped.
+ *
+ * @examples
+ *    var a = { bar: 0, a: 'a' }
+ *    var b = merge(a, { foo: 'foo', bar: 1 }, { foo: 'bar', name: 'b' });
+ *    b === a   // true
+ *    b.a       // 'a'
+ *    b.foo     // 'bar'
+ *    b.bar     // 1
+ *    b.name    // 'b'
+ */
+function merge(source) {
+  let descriptor = {};
+
+  // `Boolean` converts the first parameter to a boolean value. Any object is
+  // converted to `true` where `null` and `undefined` becames `false`. Therefore
+  // the `filter` method will keep only objects that are defined and not null.
+  Array.slice(arguments, 1).filter(Boolean).forEach(function onEach(properties) {
+    getOwnPropertyIdentifiers(properties).forEach(function(name) {
+      descriptor[name] = Object.getOwnPropertyDescriptor(properties, name);
+    });
+  });
+  return Object.defineProperties(source, descriptor);
+}
+exports.merge = merge;
+
+/**
+ * Returns an object that inherits from the first argument and contains all the
+ * properties from all following arguments.
+ * `extend(source1, source2, source3)` is equivalent of
+ * `merge(Object.create(source1), source2, source3)`.
+ */
+function extend(source) {
+  let rest = Array.slice(arguments, 1);
+  rest.unshift(Object.create(source));
+  return merge.apply(null, rest);
+}
+exports.extend = extend;
+
+function has(obj, key) {
+  return obj.hasOwnProperty(key);
+}
+exports.has = has;
+
+function each(obj, fn) {
+  for (let key in obj) has(obj, key) && fn(obj[key], key, obj);
+}
+exports.each = each;
+
+/**
+ * Like `merge`, except no property descriptors are manipulated, for use
+ * with platform objects. Identical to underscore's `extend`. Useful for
+ * merging XPCOM objects
+ */
+function safeMerge(source) {
+  Array.slice(arguments, 1).forEach(function onEach (obj) {
+    for (let prop in obj) source[prop] = obj[prop];
+  });
+  return source;
+}
+exports.safeMerge = safeMerge;
+
+/*
+ * Returns a copy of the object without omitted properties
+ */
+function omit(source, ...values) {
+  let copy = {};
+  let keys = flatten(values);
+  for (let prop in source)
+    if (!~keys.indexOf(prop))
+      copy[prop] = source[prop];
+  return copy;
+}
+exports.omit = omit;
+
+// get object's own property Symbols and/or Names, including nonEnumerables by default
+function getOwnPropertyIdentifiers(object, options = { names: true, symbols: true, nonEnumerables: true }) {
+  const symbols = !options.symbols ? [] :
+                  Object.getOwnPropertySymbols(object);
+  const names = !options.names ? [] :
+                options.nonEnumerables ? Object.getOwnPropertyNames(object) :
+                Object.keys(object);
+  return [...names, ...symbols];
+}
+exports.getOwnPropertyIdentifiers = getOwnPropertyIdentifiers;
diff --git a/toolkit/jetpack/sdk/util/rules.js b/toolkit/jetpack/sdk/util/rules.js
new file mode 100644
index 000000000..98e3109b0
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/rules.js
@@ -0,0 +1,53 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Class } = require('../core/heritage');
+const { MatchPattern } = require('./match-pattern');
+const { emit } = require('../event/core');
+const { EventTarget } = require('../event/target');
+const { List, addListItem, removeListItem } = require('./list');
+
+// Should deprecate usage of EventEmitter/compose
+const Rules = Class({
+  implements: [
+    EventTarget,
+    List
+  ],
+  add: function(...rules) {
+    return [].concat(rules).forEach(function onAdd(rule) {
+      addListItem(this, rule);
+      emit(this, 'add', rule);
+    }, this);
+  },
+  remove: function(...rules) {
+    return [].concat(rules).forEach(function onRemove(rule) {
+      removeListItem(this, rule);
+      emit(this, 'remove', rule);
+    }, this);
+  },
+  get: function(rule) {
+    let found = false;
+    for (let i in this) if (this[i] === rule) found = true;
+    return found;
+  },
+  // Returns true if uri matches atleast one stored rule
+  matchesAny: function(uri) {
+    return !!filterMatches(this, uri).length;
+  },
+  toString: () => '[object Rules]'
+});
+exports.Rules = Rules;
+
+function filterMatches(instance, uri) {
+  let matches = [];
+  for (let i in instance) {
+    if (new MatchPattern(instance[i]).test(uri)) matches.push(instance[i]);
+  }
+  return matches;
+}
diff --git a/toolkit/jetpack/sdk/util/sequence.js b/toolkit/jetpack/sdk/util/sequence.js
new file mode 100644
index 000000000..28e3de255
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/sequence.js
@@ -0,0 +1,593 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+// Disclamer:
+// In this module we'll have some common argument / variable names
+// to hint their type or behavior.
+//
+// - `f` stands for "function" that is intended to be side effect
+//   free.
+// - `p` stands for "predicate" that is function which returns logical
+//   true or false and is intended to be side effect free.
+// - `x` / `y` single item of the sequence.
+// - `xs` / `ys` sequence of `x` / `y` items where `x` / `y` signifies
+//    type of the items in sequence, so sequence is not of the same item.
+// - `_` used for argument(s) or variable(s) who's values are ignored.
+
+const { complement, flip, identity } = require("../lang/functional");
+const { isArray, isArguments, isMap, isSet, isGenerator,
+        isString, isBoolean, isNumber } = require("../lang/type");
+
+const Sequence = function Sequence(iterator) {
+  if (!isGenerator(iterator)) {
+    throw TypeError("Expected generator argument");
+  }
+
+  this[Symbol.iterator] = iterator;
+};
+exports.Sequence = Sequence;
+
+const polymorphic = dispatch => x =>
+  x === null ? dispatch.null(null) :
+  x === void(0) ? dispatch.void(void(0)) :
+  isArray(x) ? (dispatch.array || dispatch.indexed)(x) :
+  isString(x) ? (dispatch.string || dispatch.indexed)(x) :
+  isArguments(x) ? (dispatch.arguments || dispatch.indexed)(x) :
+  isMap(x) ? dispatch.map(x) :
+  isSet(x) ? dispatch.set(x) :
+  isNumber(x) ? dispatch.number(x) :
+  isBoolean(x) ? dispatch.boolean(x) :
+  dispatch.default(x);
+
+const nogen = function*() {};
+const empty = () => new Sequence(nogen);
+exports.empty = empty;
+
+const seq = polymorphic({
+  null: empty,
+  void: empty,
+  array: identity,
+  string: identity,
+  arguments: identity,
+  map: identity,
+  set: identity,
+  default: x => x instanceof Sequence ? x : new Sequence(x)
+});
+exports.seq = seq;
+
+// Function to cast seq to string.
+const string = (...etc) => "".concat(...etc);
+exports.string = string;
+
+// Function for casting seq to plain object.
+const object = (...pairs) => {
+  let result = {};
+  for (let [key, value] of pairs)
+    result[key] = value;
+
+  return result;
+};
+exports.object = object;
+
+// Takes `getEnumerator` function that returns `nsISimpleEnumerator`
+// and creates lazy sequence of it's items. Note that function does
+// not take `nsISimpleEnumerator` itslef because that would allow
+// single iteration, which would not be consistent with rest of the
+// lazy sequences.
+const fromEnumerator = getEnumerator => seq(function* () {
+  const enumerator = getEnumerator();
+  while (enumerator.hasMoreElements())
+   yield enumerator.getNext();
+});
+exports.fromEnumerator = fromEnumerator;
+
+// Takes `object` and returns lazy sequence of own `[key, value]`
+// pairs (does not include inherited and non enumerable keys).
+const pairs = polymorphic({
+  null: empty,
+  void: empty,
+  map: identity,
+  indexed: indexed => seq(function* () {
+    const count = indexed.length;
+    let index = 0;
+    while (index < count) {
+      yield [index, indexed[index]];
+      index = index + 1;
+    }
+  }),
+  default: object => seq(function* () {
+    for (let key of Object.keys(object))
+      yield [key, object[key]];
+  })
+});
+exports.pairs = pairs;
+
+const names = polymorphic({
+  null: empty,
+  void: empty,
+  default: object => seq(function*() {
+    for (let name of Object.getOwnPropertyNames(object)) {
+      yield name;
+    }
+  })
+});
+exports.names = names;
+
+const symbols = polymorphic({
+  null: empty,
+  void: empty,
+  default: object => seq(function* () {
+    for (let symbol of Object.getOwnPropertySymbols(object)) {
+      yield symbol;
+    }
+  })
+});
+exports.symbols = symbols;
+
+const keys = polymorphic({
+  null: empty,
+  void: empty,
+  indexed: indexed => seq(function* () {
+    const count = indexed.length;
+    let index = 0;
+    while (index < count) {
+      yield index;
+      index = index + 1;
+    }
+  }),
+  map: map => seq(function* () {
+    for (let [key, _] of map)
+      yield key;
+  }),
+  default: object => seq(function* () {
+    for (let key of Object.keys(object))
+      yield key;
+  })
+});
+exports.keys = keys;
+
+
+const values = polymorphic({
+  null: empty,
+  void: empty,
+  set: identity,
+  indexed: indexed => seq(function* () {
+    const count = indexed.length;
+    let index = 0;
+    while (index < count) {
+      yield indexed[index];
+      index = index + 1;
+    }
+  }),
+  map: map => seq(function* () {
+    for (let [_, value] of map) yield value;
+  }),
+  default: object => seq(function* () {
+    for (let key of Object.keys(object)) yield object[key];
+  })
+});
+exports.values = values;
+
+
+
+// Returns a lazy sequence of `x`, `f(x)`, `f(f(x))` etc.
+// `f` must be free of side-effects. Note that returned
+// sequence is infinite so it must be consumed partially.
+//
+// Implements clojure iterate:
+// http://clojuredocs.org/clojure_core/clojure.core/iterate
+const iterate = (f, x) => seq(function* () {
+  let state = x;
+  while (true) {
+    yield state;
+    state = f(state);
+  }
+});
+exports.iterate = iterate;
+
+// Returns a lazy sequence of the items in sequence for which `p(item)`
+// returns `true`. `p` must be free of side-effects.
+//
+// Implements clojure filter:
+// http://clojuredocs.org/clojure_core/clojure.core/filter
+const filter = (p, sequence) => seq(function* () {
+  if (sequence !== null && sequence !== void(0)) {
+    for (let item of sequence) {
+      if (p(item))
+        yield item;
+    }
+  }
+});
+exports.filter = filter;
+
+// Returns a lazy sequence consisting of the result of applying `f` to the
+// set of first items of each sequence, followed by applying f to the set
+// of second items in each sequence, until any one of the sequences is
+// exhausted. Any remaining items in other sequences are ignored. Function
+// `f` should accept number-of-sequences arguments.
+//
+// Implements clojure map:
+// http://clojuredocs.org/clojure_core/clojure.core/map
+const map = (f, ...sequences) => seq(function* () {
+  const count = sequences.length;
+  // Optimize a single sequence case
+  if (count === 1) {
+    let [sequence] = sequences;
+    if (sequence !== null && sequence !== void(0)) {
+      for (let item of sequence)
+        yield f(item);
+    }
+  }
+  else {
+    // define args array that will be recycled on each
+    // step to aggregate arguments to be passed to `f`.
+    let args = [];
+    // define inputs to contain started generators.
+    let inputs = [];
+
+    let index = 0;
+    while (index < count) {
+      inputs[index] = sequences[index][Symbol.iterator]();
+      index = index + 1;
+    }
+
+    // Run loop yielding of applying `f` to the set of
+    // items at each step until one of the `inputs` is
+    // exhausted.
+    let done = false;
+    while (!done) {
+      let index = 0;
+      let value = void(0);
+      while (index < count && !done) {
+        ({ done, value } = inputs[index].next());
+
+        // If input is not exhausted yet store value in args.
+        if (!done) {
+          args[index] = value;
+          index = index + 1;
+        }
+      }
+
+      // If none of the inputs is exhasted yet, `args` contain items
+      // from each input so we yield application of `f` over them.
+      if (!done)
+        yield f(...args);
+    }
+  }
+});
+exports.map = map;
+
+// Returns a lazy sequence of the intermediate values of the reduction (as
+// per reduce) of sequence by `f`, starting with `initial` value if provided.
+//
+// Implements clojure reductions:
+// http://clojuredocs.org/clojure_core/clojure.core/reductions
+const reductions = (...params) => {
+  const count = params.length;
+  let hasInitial = false;
+  let f, initial, source;
+  if (count === 2) {
+    [f, source] = params;
+  }
+  else if (count === 3) {
+    [f, initial, source] = params;
+    hasInitial = true;
+  }
+  else {
+    throw Error("Invoked with wrong number of arguments: " + count);
+  }
+
+  const sequence = seq(source);
+
+  return seq(function* () {
+    let started = hasInitial;
+    let result = void(0);
+
+    // If initial is present yield it.
+    if (hasInitial)
+      yield (result = initial);
+
+    // For each item of the sequence accumulate new result.
+    for (let item of sequence) {
+      // If nothing has being yield yet set result to first
+      // item and yield it.
+      if (!started) {
+        started = true;
+        yield (result = item);
+      }
+      // Otherwise accumulate new result and yield it.
+      else {
+        yield (result = f(result, item));
+      }
+    }
+
+    // If nothing has being yield yet it's empty sequence and no
+    // `initial` was provided in which case we need to yield `f()`.
+    if (!started)
+      yield f();
+  });
+};
+exports.reductions = reductions;
+
+// `f` should be a function of 2 arguments. If `initial` is not supplied,
+// returns the result of applying `f` to the first 2 items in sequence, then
+// applying `f` to that result and the 3rd item, etc. If sequence contains no
+// items, `f` must accept no arguments as well, and reduce returns the
+// result of calling f with no arguments. If sequence has only 1 item, it
+// is returned and `f` is not called. If `initial` is supplied, returns the
+// result of applying `f` to `initial` and the first item in  sequence, then
+// applying `f` to that result and the 2nd item, etc. If sequence contains no
+// items, returns `initial` and `f` is not called.
+//
+// Implements clojure reduce:
+// http://clojuredocs.org/clojure_core/clojure.core/reduce
+const reduce = (...args) => {
+  const xs = reductions(...args);
+  let x;
+  for (x of xs) void(0);
+  return x;
+};
+exports.reduce = reduce;
+
+const each = (f, sequence) => {
+  for (let x of seq(sequence)) void(f(x));
+};
+exports.each = each;
+
+
+const inc = x => x + 1;
+// Returns the number of items in the sequence. `count(null)` && `count()`
+// returns `0`. Also works on strings, arrays, Maps & Sets.
+
+// Implements clojure count:
+// http://clojuredocs.org/clojure_core/clojure.core/count
+const count = polymorphic({
+  null: _ => 0,
+  void: _ => 0,
+  indexed: indexed => indexed.length,
+  map: map => map.size,
+  set: set => set.size,
+  default: xs => reduce(inc, 0, xs)
+});
+exports.count = count;
+
+// Returns `true` if sequence has no items.
+
+// Implements clojure empty?:
+// http://clojuredocs.org/clojure_core/clojure.core/empty_q
+const isEmpty = sequence => {
+  // Treat `null` and `undefined` as empty sequences.
+  if (sequence === null || sequence === void(0))
+    return true;
+
+  // If contains any item non empty so return `false`.
+  for (let _ of sequence)
+    return false;
+
+  // If has not returned yet, there was nothing to iterate
+  // so it's empty.
+  return true;
+};
+exports.isEmpty = isEmpty;
+
+const and = (a, b) => a && b;
+
+// Returns true if `p(x)` is logical `true` for every `x` in sequence, else
+// `false`.
+//
+// Implements clojure every?:
+// http://clojuredocs.org/clojure_core/clojure.core/every_q
+const isEvery = (p, sequence) => {
+  if (sequence !== null && sequence !== void(0)) {
+    for (let item of sequence) {
+      if (!p(item))
+        return false;
+    }
+  }
+  return true;
+};
+exports.isEvery = isEvery;
+
+// Returns the first logical true value of (p x) for any x in sequence,
+// else `null`.
+//
+// Implements clojure some:
+// http://clojuredocs.org/clojure_core/clojure.core/some
+const some = (p, sequence) => {
+  if (sequence !== null && sequence !== void(0)) {
+    for (let item of sequence) {
+      if (p(item))
+        return true;
+    }
+  }
+  return null;
+};
+exports.some = some;
+
+// Returns a lazy sequence of the first `n` items in sequence, or all items if
+// there are fewer than `n`.
+//
+// Implements clojure take:
+// http://clojuredocs.org/clojure_core/clojure.core/take
+const take = (n, sequence) => n <= 0 ? empty() : seq(function* () {
+  let count = n;
+  for (let item of sequence) {
+    yield item;
+    count = count - 1;
+    if (count === 0) break;
+  }
+});
+exports.take = take;
+
+// Returns a lazy sequence of successive items from sequence while
+// `p(item)` returns `true`. `p` must be free of side-effects.
+//
+// Implements clojure take-while:
+// http://clojuredocs.org/clojure_core/clojure.core/take-while
+const takeWhile = (p, sequence) => seq(function* () {
+  for (let item of sequence) {
+    if (!p(item))
+      break;
+
+    yield item;
+  }
+});
+exports.takeWhile = takeWhile;
+
+// Returns a lazy sequence of all but the first `n` items in
+// sequence.
+//
+// Implements clojure drop:
+// http://clojuredocs.org/clojure_core/clojure.core/drop
+const drop = (n, sequence) => seq(function* () {
+  if (sequence !== null && sequence !== void(0)) {
+    let count = n;
+    for (let item of sequence) {
+      if (count > 0)
+        count = count - 1;
+      else
+        yield item;
+    }
+  }
+});
+exports.drop = drop;
+
+// Returns a lazy sequence of the items in sequence starting from the
+// first item for which `p(item)` returns falsy value.
+//
+// Implements clojure drop-while:
+// http://clojuredocs.org/clojure_core/clojure.core/drop-while
+const dropWhile = (p, sequence) => seq(function* () {
+  let keep = false;
+  for (let item of sequence) {
+    keep = keep || !p(item);
+    if (keep) yield item;
+  }
+});
+exports.dropWhile = dropWhile;
+
+// Returns a lazy sequence representing the concatenation of the
+// suplied sequences.
+//
+// Implements clojure conact:
+// http://clojuredocs.org/clojure_core/clojure.core/concat
+const concat = (...sequences) => seq(function* () {
+  for (let sequence of sequences)
+    for (let item of sequence)
+      yield item;
+});
+exports.concat = concat;
+
+// Returns the first item in the sequence.
+//
+// Implements clojure first:
+// http://clojuredocs.org/clojure_core/clojure.core/first
+const first = sequence => {
+  if (sequence !== null && sequence !== void(0)) {
+    for (let item of sequence)
+      return item;
+  }
+  return null;
+};
+exports.first = first;
+
+// Returns a possibly empty sequence of the items after the first.
+//
+// Implements clojure rest:
+// http://clojuredocs.org/clojure_core/clojure.core/rest
+const rest = sequence => drop(1, sequence);
+exports.rest = rest;
+
+// Returns the value at the index. Returns `notFound` or `undefined`
+// if index is out of bounds.
+const nth = (xs, n, notFound) => {
+  if (n >= 0) {
+    if (isArray(xs) || isArguments(xs) || isString(xs)) {
+      return n < xs.length ? xs[n] : notFound;
+    }
+    else if (xs !== null && xs !== void(0)) {
+      let count = n;
+      for (let x of xs) {
+        if (count <= 0)
+          return x;
+
+        count = count - 1;
+      }
+    }
+  }
+  return notFound;
+};
+exports.nth = nth;
+
+// Return the last item in sequence, in linear time.
+// If `sequence` is an array or string or arguments
+// returns in constant time.
+// Implements clojure last:
+// http://clojuredocs.org/clojure_core/clojure.core/last
+const last = polymorphic({
+  null: _ => null,
+  void: _ => null,
+  indexed: indexed => indexed[indexed.length - 1],
+  map: xs => reduce((_, x) => x, xs),
+  set: xs => reduce((_, x) => x, xs),
+  default: xs => reduce((_, x) => x, xs)
+});
+exports.last = last;
+
+// Return a lazy sequence of all but the last `n` (default 1) items
+// from the give `xs`.
+//
+// Implements clojure drop-last:
+// http://clojuredocs.org/clojure_core/clojure.core/drop-last
+const dropLast = flip((xs, n=1) => seq(function* () {
+  let ys = [];
+  for (let x of xs) {
+    ys.push(x);
+    if (ys.length > n)
+      yield ys.shift();
+  }
+}));
+exports.dropLast = dropLast;
+
+// Returns a lazy sequence of the elements of `xs` with duplicates
+// removed
+//
+// Implements clojure distinct
+// http://clojuredocs.org/clojure_core/clojure.core/distinct
+const distinct = sequence => seq(function* () {
+  let items = new Set();
+  for (let item of sequence) {
+    if (!items.has(item)) {
+      items.add(item);
+      yield item;
+    }
+  }
+});
+exports.distinct = distinct;
+
+// Returns a lazy sequence of the items in `xs` for which
+// `p(x)` returns false. `p` must be free of side-effects.
+//
+// Implements clojure remove
+// http://clojuredocs.org/clojure_core/clojure.core/remove
+const remove = (p, xs) => filter(complement(p), xs);
+exports.remove = remove;
+
+// Returns the result of applying concat to the result of
+// `map(f, xs)`. Thus function `f` should return a sequence.
+//
+// Implements clojure mapcat
+// http://clojuredocs.org/clojure_core/clojure.core/mapcat
+const mapcat = (f, sequence) => seq(function* () {
+  const sequences = map(f, sequence);
+  for (let sequence of sequences)
+    for (let item of sequence)
+      yield item;
+});
+exports.mapcat = mapcat;
diff --git a/toolkit/jetpack/sdk/util/uuid.js b/toolkit/jetpack/sdk/util/uuid.js
new file mode 100644
index 000000000..6d0f2de53
--- /dev/null
+++ b/toolkit/jetpack/sdk/util/uuid.js
@@ -0,0 +1,19 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Cc, Ci, components: { ID: parseUUID } } = require('chrome');
+const { generateUUID } = Cc['@mozilla.org/uuid-generator;1'].
+                          getService(Ci.nsIUUIDGenerator);
+
+// Returns `uuid`. If `id` is passed then it's parsed to `uuid` and returned
+// if not then new one is generated.
+exports.uuid = function uuid(id) {
+  return id ? parseUUID(id) : generateUUID();
+};
diff --git a/toolkit/jetpack/sdk/view/core.js b/toolkit/jetpack/sdk/view/core.js
new file mode 100644
index 000000000..5e82e9b5d
--- /dev/null
+++ b/toolkit/jetpack/sdk/view/core.js
@@ -0,0 +1,26 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+var { Ci } = require("chrome");
+var method = require("../../method/core");
+
+// Returns DOM node associated with a view for
+// the given `value`. If `value` has no view associated
+// it returns `null`. You can implement this method for
+// this type to define what the result should be for it.
+var getNodeView = method("getNodeView");
+getNodeView.define(x =>
+                     x instanceof Ci.nsIDOMNode ? x :
+                     x instanceof Ci.nsIDOMWindow ? x :
+                     null);
+exports.getNodeView = getNodeView;
+exports.viewFor = getNodeView;
+
+var getActiveView = method("getActiveView");
+exports.getActiveView = getActiveView;
diff --git a/toolkit/jetpack/sdk/webextension.js b/toolkit/jetpack/sdk/webextension.js
new file mode 100644
index 000000000..d1c4385e2
--- /dev/null
+++ b/toolkit/jetpack/sdk/webextension.js
@@ -0,0 +1,43 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "experimental"
+};
+
+let webExtension;
+let waitForWebExtensionAPI;
+
+module.exports = {
+  initFromBootstrapAddonParam(data) {
+    if (webExtension) {
+      throw new Error("'sdk/webextension' module has been already initialized");
+    }
+
+    webExtension = data.webExtension;
+  },
+
+  startup() {
+    if (!webExtension) {
+      return Promise.reject(new Error(
+        "'sdk/webextension' module is currently disabled. " +
+        "('hasEmbeddedWebExtension' option is missing or set to false)"
+      ));
+    }
+
+    // NOTE: calling `startup` more than once raises an "Embedded Extension already started"
+    // error, but given that SDK addons are going to have access to the startup method through
+    // an SDK module that can be required in any part of the addon, it will be nicer if any
+    // additional startup calls return the startup promise instead of raising an exception,
+    // so that the SDK addon can access the API object in the other addon modules without the
+    // need to manually pass this promise around.
+    if (!waitForWebExtensionAPI) {
+      waitForWebExtensionAPI = webExtension.startup();
+    }
+
+    return waitForWebExtensionAPI;
+  }
+};
diff --git a/toolkit/jetpack/sdk/window/browser.js b/toolkit/jetpack/sdk/window/browser.js
new file mode 100644
index 000000000..380b5a486
--- /dev/null
+++ b/toolkit/jetpack/sdk/window/browser.js
@@ -0,0 +1,54 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { Class } = require('../core/heritage');
+const { windowNS } = require('./namespace');
+const { on, off, once } = require('../event/core');
+const { method } = require('../lang/functional');
+const { getWindowTitle } = require('./utils');
+const unload = require('../system/unload');
+const { EventTarget } = require('../event/target');
+const { isPrivate } = require('../private-browsing/utils');
+const { isWindowPrivate, isFocused } = require('../window/utils');
+const { viewFor } = require('../view/core');
+
+const ERR_FENNEC_MSG = 'This method is not yet supported by Fennec, consider using require("sdk/tabs") instead';
+
+const BrowserWindow = Class({
+  initialize: function initialize(options) {
+    EventTarget.prototype.initialize.call(this, options);
+    windowNS(this).window = options.window;
+  },
+  activate: function activate() {
+    // TODO
+    return null;
+  },
+  close: function() {
+    throw new Error(ERR_FENNEC_MSG);
+    return null;
+  },
+  get title() {
+    return getWindowTitle(windowNS(this).window);
+  },
+  // NOTE: Fennec only has one window, which is assumed below
+  // TODO: remove assumption below
+  // NOTE: tabs requires windows
+  get tabs() {
+    return require('../tabs');
+  },
+  get activeTab() {
+    return require('../tabs').activeTab;
+  },
+  on: method(on),
+  removeListener: method(off),
+  once: method(once)
+});
+exports.BrowserWindow = BrowserWindow;
+
+const getWindowView = window => windowNS(window).window;
+
+viewFor.define(BrowserWindow, getWindowView);
+isPrivate.define(BrowserWindow, (window) => isWindowPrivate(viewFor(window).window));
+isFocused.define(BrowserWindow, (window) => isFocused(viewFor(window).window));
diff --git a/toolkit/jetpack/sdk/window/events.js b/toolkit/jetpack/sdk/window/events.js
new file mode 100644
index 000000000..b1d3a1f3e
--- /dev/null
+++ b/toolkit/jetpack/sdk/window/events.js
@@ -0,0 +1,68 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { Ci, Cu } = require("chrome");
+const { observe } = require("../event/chrome");
+const { open } = require("../event/dom");
+const { windows } = require("../window/utils");
+const { filter, merge, map, expand } = require("../event/utils");
+
+function documentMatches(weakWindow, event) {
+  let window = weakWindow.get();
+  return window && event.target === window.document;
+}
+
+function makeStrictDocumentFilter(window) {
+  // Note: Do not define a closure within this function.  Otherwise
+  //       you may leak the window argument.
+  let weak = Cu.getWeakReference(window);
+  return documentMatches.bind(null, weak);
+}
+
+function toEventWithDefaultViewTarget({type, target}) {
+  return { type: type, target: target.defaultView }
+}
+
+// Function registers single shot event listeners for relevant window events
+// that forward events to exported event stream.
+function eventsFor(window) {
+  // NOTE: Do no use pass a closure from this function into a stream
+  //       transform function.  You will capture the window in the
+  //       closure and leak the window until the event stream is
+  //       completely closed.
+  let interactive = open(window, "DOMContentLoaded", { capture: true });
+  let complete = open(window, "load", { capture: true });
+  let states = merge([interactive, complete]);
+  let changes = filter(states, makeStrictDocumentFilter(window));
+  return map(changes, toEventWithDefaultViewTarget);
+}
+
+// Create our event channels.  We do this in a separate function to
+// minimize the chance of leaking intermediate objects on the global.
+function makeEvents() {
+  // In addition to observing windows that are open we also observe windows
+  // that are already already opened in case they're in process of loading.
+  var opened = windows(null, { includePrivate: true });
+  var currentEvents = merge(opened.map(eventsFor));
+
+  // Register system event listeners for top level window open / close.
+  function rename({type, target, data}) {
+    return { type: rename[type], target: target, data: data }
+  }
+  rename.domwindowopened = "open";
+  rename.domwindowclosed = "close";
+
+  var openEvents = map(observe("domwindowopened"), rename);
+  var closeEvents = map(observe("domwindowclosed"), rename);
+  var futureEvents = expand(openEvents, ({target}) => eventsFor(target));
+
+  return merge([currentEvents, futureEvents, openEvents, closeEvents]);
+}
+
+exports.events = makeEvents();
diff --git a/toolkit/jetpack/sdk/window/helpers.js b/toolkit/jetpack/sdk/window/helpers.js
new file mode 100644
index 000000000..56cfcaba7
--- /dev/null
+++ b/toolkit/jetpack/sdk/window/helpers.js
@@ -0,0 +1,81 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { defer, all } = require('../core/promise');
+const events = require('../system/events');
+const { open: openWindow, onFocus, getToplevelWindow,
+        isInteractive, isStartupFinished, getOuterId } = require('./utils');
+const { Ci } = require("chrome");
+
+function open(uri, options) {
+  return promise(openWindow.apply(null, arguments), 'load').then(focus);
+}
+exports.open = open;
+
+function close(window) {
+  let deferred = defer();
+  let toplevelWindow = getToplevelWindow(window);
+  let outerId = getOuterId(toplevelWindow);
+  events.on("outer-window-destroyed", function onclose({subject}) {
+    let id = subject.QueryInterface(Ci.nsISupportsPRUint64).data;
+    if (id == outerId) {
+      events.off("outer-window-destroyed", onclose);
+      deferred.resolve();
+    }
+  }, true);
+  window.close();
+  return deferred.promise;
+}
+exports.close = close;
+
+function focus(window) {
+  let p = onFocus(window);
+  window.focus();
+  return p;
+}
+exports.focus = focus;
+
+function ready(window) {
+  let { promise: result, resolve } = defer();
+
+  if (isInteractive(window))
+    resolve(window);
+  else
+    resolve(promise(window, 'DOMContentLoaded'));
+
+  return result;
+}
+exports.ready = ready;
+
+function startup(window) {
+  let { promise: result, resolve } = defer();
+
+  if (isStartupFinished(window)) {
+    resolve(window);
+  } else {
+    events.on("browser-delayed-startup-finished", function listener({subject}) {
+      if (subject === window) {
+        events.off("browser-delayed-startup-finished", listener);
+        resolve(window);
+      }
+    });
+  }
+
+  return result;
+}
+exports.startup = startup;
+
+function promise(target, evt, capture) {
+  let deferred = defer();
+  capture = !!capture;
+
+  target.addEventListener(evt, function eventHandler() {
+    target.removeEventListener(evt, eventHandler, capture);
+    deferred.resolve(target);
+  }, capture);
+
+  return deferred.promise;
+}
+exports.promise = promise;
diff --git a/toolkit/jetpack/sdk/window/namespace.js b/toolkit/jetpack/sdk/window/namespace.js
new file mode 100644
index 000000000..b486f888d
--- /dev/null
+++ b/toolkit/jetpack/sdk/window/namespace.js
@@ -0,0 +1,6 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+exports.windowNS = require('../core/namespace').ns();
diff --git a/toolkit/jetpack/sdk/window/utils.js b/toolkit/jetpack/sdk/window/utils.js
new file mode 100644
index 000000000..db91a0fed
--- /dev/null
+++ b/toolkit/jetpack/sdk/window/utils.js
@@ -0,0 +1,460 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'unstable'
+};
+
+const { Cc, Ci } = require('chrome');
+const array = require('../util/array');
+const { defer } = require('sdk/core/promise');
+const { dispatcher } = require("../util/dispatcher");
+
+const windowWatcher = Cc['@mozilla.org/embedcomp/window-watcher;1'].
+                       getService(Ci.nsIWindowWatcher);
+const appShellService = Cc['@mozilla.org/appshell/appShellService;1'].
+                        getService(Ci.nsIAppShellService);
+const WM = Cc['@mozilla.org/appshell/window-mediator;1'].
+           getService(Ci.nsIWindowMediator);
+const io = Cc['@mozilla.org/network/io-service;1'].
+           getService(Ci.nsIIOService);
+const FM = Cc["@mozilla.org/focus-manager;1"].
+              getService(Ci.nsIFocusManager);
+
+const XUL_NS = 'http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul';
+
+const prefs = require("../preferences/service");
+const BROWSER = 'navigator:browser',
+      URI_BROWSER = prefs.get('browser.chromeURL', null),
+      NAME = '_blank',
+      FEATURES = 'chrome,all,dialog=no,non-private';
+
+function isWindowPrivate(win) {
+  if (!win)
+    return false;
+
+  // if the pbService is undefined, the PrivateBrowsingUtils.jsm is available,
+  // and the app is Firefox, then assume per-window private browsing is
+  // enabled.
+  try {
+    return win.QueryInterface(Ci.nsIInterfaceRequestor)
+                  .getInterface(Ci.nsIWebNavigation)
+                  .QueryInterface(Ci.nsILoadContext)
+                  .usePrivateBrowsing;
+  }
+  catch(e) {}
+
+  // Sometimes the input is not a nsIDOMWindow.. but it is still a winodw.
+  try {
+    return !!win.docShell.QueryInterface(Ci.nsILoadContext).usePrivateBrowsing;
+  }
+  catch (e) {}
+
+  return false;
+}
+exports.isWindowPrivate = isWindowPrivate;
+
+function getMostRecentBrowserWindow() {
+  return getMostRecentWindow(BROWSER);
+}
+exports.getMostRecentBrowserWindow = getMostRecentBrowserWindow;
+
+function getHiddenWindow() {
+  return appShellService.hiddenDOMWindow;
+}
+exports.getHiddenWindow = getHiddenWindow;
+
+function getMostRecentWindow(type) {
+  return WM.getMostRecentWindow(type);
+}
+exports.getMostRecentWindow = getMostRecentWindow;
+
+/**
+ * Returns the ID of the window's current inner window.
+ */
+function getInnerId(window) {
+  return window.QueryInterface(Ci.nsIInterfaceRequestor).
+                getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID;
+};
+exports.getInnerId = getInnerId;
+
+/**
+ * Returns the ID of the window's outer window.
+ */
+function getOuterId(window) {
+  return window.QueryInterface(Ci.nsIInterfaceRequestor).
+                getInterface(Ci.nsIDOMWindowUtils).outerWindowID;
+};
+exports.getOuterId = getOuterId;
+
+/**
+ * Returns window by the outer window id.
+ */
+const getByOuterId = WM.getOuterWindowWithId;
+exports.getByOuterId = getByOuterId;
+
+const getByInnerId = WM.getCurrentInnerWindowWithId;
+exports.getByInnerId = getByInnerId;
+
+/**
+ * Returns `nsIXULWindow` for the given `nsIDOMWindow`.
+ */
+function getXULWindow(window) {
+  return window.QueryInterface(Ci.nsIInterfaceRequestor).
+    getInterface(Ci.nsIWebNavigation).
+    QueryInterface(Ci.nsIDocShellTreeItem).
+    treeOwner.QueryInterface(Ci.nsIInterfaceRequestor).
+    getInterface(Ci.nsIXULWindow);
+};
+exports.getXULWindow = getXULWindow;
+
+function getDOMWindow(xulWindow) {
+  return xulWindow.QueryInterface(Ci.nsIInterfaceRequestor).
+    getInterface(Ci.nsIDOMWindow);
+}
+exports.getDOMWindow = getDOMWindow;
+
+/**
+ * Returns `nsIBaseWindow` for the given `nsIDOMWindow`.
+ */
+function getBaseWindow(window) {
+  return window.QueryInterface(Ci.nsIInterfaceRequestor).
+    getInterface(Ci.nsIWebNavigation).
+    QueryInterface(Ci.nsIDocShell).
+    QueryInterface(Ci.nsIDocShellTreeItem).
+    treeOwner.
+    QueryInterface(Ci.nsIBaseWindow);
+}
+exports.getBaseWindow = getBaseWindow;
+
+/**
+ * Returns the `nsIDOMWindow` toplevel window for any child/inner window
+ */
+function getToplevelWindow(window) {
+  return window.QueryInterface(Ci.nsIInterfaceRequestor)
+               .getInterface(Ci.nsIWebNavigation)
+               .QueryInterface(Ci.nsIDocShellTreeItem)
+               .rootTreeItem
+               .QueryInterface(Ci.nsIInterfaceRequestor)
+               .getInterface(Ci.nsIDOMWindow);
+}
+exports.getToplevelWindow = getToplevelWindow;
+
+function getWindowDocShell(window) {
+  return window.gBrowser.docShell;
+}
+exports.getWindowDocShell = getWindowDocShell;
+
+function getWindowLoadingContext(window) {
+  return getWindowDocShell(window).
+         QueryInterface(Ci.nsILoadContext);
+}
+exports.getWindowLoadingContext = getWindowLoadingContext;
+
+const isTopLevel = window => window && getToplevelWindow(window) === window;
+exports.isTopLevel = isTopLevel;
+
+/**
+ * Takes hash of options and serializes it to a features string that
+ * can be used passed to `window.open`. For more details on features string see:
+ * https://developer.mozilla.org/en/DOM/window.open#Position_and_size_features
+ */
+function serializeFeatures(options) {
+  return Object.keys(options).reduce(function(result, name) {
+    let value = options[name];
+
+    // the chrome and private features are special
+    if ((name == 'private' || name == 'chrome' || name == 'all'))
+      return result + ((value === true) ? ',' + name : '');
+
+    return result + ',' + name + '=' +
+           (value === true ? 'yes' : value === false ? 'no' : value);
+  }, '').substr(1);
+}
+
+/**
+ * Opens a top level window and returns it's `nsIDOMWindow` representation.
+ * @params {String} uri
+ *    URI of the document to be loaded into window.
+ * @params {nsIDOMWindow} options.parent
+ *    Used as parent for the created window.
+ * @params {String} options.name
+ *    Optional name that is assigned to the window.
+ * @params {Object} options.features
+ *    Map of key, values like: `{ width: 10, height: 15, chrome: true, private: true }`.
+ */
+function open(uri, options) {
+  uri = uri || URI_BROWSER;
+  options = options || {};
+
+  if (!uri)
+    throw new Error('browser.chromeURL is undefined, please provide an explicit uri');
+
+  if (['chrome', 'resource', 'data'].indexOf(io.newURI(uri, null, null).scheme) < 0)
+    throw new Error('only chrome, resource and data uris are allowed');
+
+  let newWindow = windowWatcher.
+    openWindow(options.parent || null,
+               uri,
+               options.name || null,
+               options.features ? serializeFeatures(options.features) : null,
+               options.args || null);
+
+  return newWindow;
+}
+exports.open = open;
+
+function onFocus(window) {
+  let { resolve, promise } = defer();
+
+  if (isFocused(window)) {
+    resolve(window);
+  }
+  else {
+    window.addEventListener("focus", function focusListener() {
+      window.removeEventListener("focus", focusListener, true);
+      resolve(window);
+    }, true);
+  }
+
+  return promise;
+}
+exports.onFocus = onFocus;
+
+var isFocused = dispatcher("window-isFocused");
+isFocused.when(x => x instanceof Ci.nsIDOMWindow, (window) => {
+  const FM = Cc["@mozilla.org/focus-manager;1"].
+                getService(Ci.nsIFocusManager);
+
+  let childTargetWindow = {};
+  FM.getFocusedElementForWindow(window, true, childTargetWindow);
+  childTargetWindow = childTargetWindow.value;
+
+  let focusedChildWindow = {};
+  if (FM.activeWindow) {
+    FM.getFocusedElementForWindow(FM.activeWindow, true, focusedChildWindow);
+    focusedChildWindow = focusedChildWindow.value;
+  }
+
+  return (focusedChildWindow === childTargetWindow);
+});
+exports.isFocused = isFocused;
+
+/**
+ * Opens a top level window and returns it's `nsIDOMWindow` representation.
+ * Same as `open` but with more features
+ * @param {Object} options
+ *
+ */
+function openDialog(options) {
+  options = options || {};
+
+  let features = options.features || FEATURES;
+  let featureAry = features.toLowerCase().split(',');
+
+  if (!!options.private) {
+    // add private flag if private window is desired
+    if (!array.has(featureAry, 'private')) {
+      featureAry.push('private');
+    }
+
+    // remove the non-private flag ig a private window is desired
+    let nonPrivateIndex = featureAry.indexOf('non-private');
+    if (nonPrivateIndex >= 0) {
+      featureAry.splice(nonPrivateIndex, 1);
+    }
+
+    features = featureAry.join(',');
+  }
+
+  let browser = getMostRecentBrowserWindow();
+
+  // if there is no browser then do nothing
+  if (!browser)
+    return undefined;
+
+  let newWindow = browser.openDialog.apply(
+      browser,
+      array.flatten([
+        options.url || URI_BROWSER,
+        options.name || NAME,
+        features,
+        options.args || null
+      ])
+  );
+
+  return newWindow;
+}
+exports.openDialog = openDialog;
+
+/**
+ * Returns an array of all currently opened windows.
+ * Note that these windows may still be loading.
+ */
+function windows(type, options) {
+  options = options || {};
+  let list = [];
+  let winEnum = WM.getEnumerator(type);
+  while (winEnum.hasMoreElements()) {
+    let window = winEnum.getNext().QueryInterface(Ci.nsIDOMWindow);
+    // Only add non-private windows when pb permission isn't set,
+    // unless an option forces the addition of them.
+    if (!window.closed && (options.includePrivate || !isWindowPrivate(window))) {
+      list.push(window);
+    }
+  }
+  return list;
+}
+exports.windows = windows;
+
+/**
+ * Check if the given window is interactive.
+ * i.e. if its "DOMContentLoaded" event has already been fired.
+ * @params {nsIDOMWindow} window
+ */
+const isInteractive = window =>
+  window.document.readyState === "interactive" ||
+  isDocumentLoaded(window) ||
+  // XUL documents stays '"uninitialized"' until it's `readyState` becomes
+  // `"complete"`.
+  isXULDocumentWindow(window) && window.document.readyState === "interactive";
+exports.isInteractive = isInteractive;
+
+/**
+ * Check if the given browser window has finished the startup.
+ * @params {nsIDOMWindow} window
+ */
+const isStartupFinished = (window) =>
+  isBrowser(window) &&
+  window.gBrowserInit &&
+  window.gBrowserInit.delayedStartupFinished;
+
+exports.isStartupFinished = isStartupFinished;
+
+const isXULDocumentWindow = ({document}) =>
+  document.documentElement &&
+  document.documentElement.namespaceURI === XUL_NS;
+
+/**
+ * Check if the given window is completely loaded.
+ * i.e. if its "load" event has already been fired and all possible DOM content
+ * is done loading (the whole DOM document, images content, ...)
+ * @params {nsIDOMWindow} window
+ */
+function isDocumentLoaded(window) {
+  return window.document.readyState == "complete";
+}
+exports.isDocumentLoaded = isDocumentLoaded;
+
+function isBrowser(window) {
+  try {
+    return window.document.documentElement.getAttribute("windowtype") === BROWSER;
+  }
+  catch (e) {}
+  return false;
+};
+exports.isBrowser = isBrowser;
+
+function getWindowTitle(window) {
+  return window && window.document ? window.document.title : null;
+}
+exports.getWindowTitle = getWindowTitle;
+
+function isXULBrowser(window) {
+  return !!(isBrowser(window) && window.XULBrowserWindow);
+}
+exports.isXULBrowser = isXULBrowser;
+
+/**
+ * Returns the most recent focused window
+ */
+function getFocusedWindow() {
+  let window = WM.getMostRecentWindow(BROWSER);
+
+  return window ? window.document.commandDispatcher.focusedWindow : null;
+}
+exports.getFocusedWindow = getFocusedWindow;
+
+/**
+ * Returns the focused browser window if any, or the most recent one.
+ * Opening new window, updates most recent window, but focus window
+ * changes later; so most recent window and focused window are not always
+ * the same.
+ */
+function getFocusedBrowser() {
+  let window = FM.activeWindow;
+  return isBrowser(window) ? window : getMostRecentBrowserWindow()
+}
+exports.getFocusedBrowser = getFocusedBrowser;
+
+/**
+ * Returns the focused element in the most recent focused window
+ */
+function getFocusedElement() {
+  let window = WM.getMostRecentWindow(BROWSER);
+
+  return window ? window.document.commandDispatcher.focusedElement : null;
+}
+exports.getFocusedElement = getFocusedElement;
+
+function getFrames(window) {
+  return Array.slice(window.frames).reduce(function(frames, frame) {
+    return frames.concat(frame, getFrames(frame));
+  }, []);
+}
+exports.getFrames = getFrames;
+
+function getScreenPixelsPerCSSPixel(window) {
+  return window.QueryInterface(Ci.nsIInterfaceRequestor).
+                getInterface(Ci.nsIDOMWindowUtils).screenPixelsPerCSSPixel;
+}
+exports.getScreenPixelsPerCSSPixel = getScreenPixelsPerCSSPixel;
+
+function getOwnerBrowserWindow(node) {
+  /**
+  Takes DOM node and returns browser window that contains it.
+  **/
+  let window = getToplevelWindow(node.ownerDocument.defaultView);
+  // If anchored window is browser then it's target browser window.
+  return isBrowser(window) ? window : null;
+}
+exports.getOwnerBrowserWindow = getOwnerBrowserWindow;
+
+function getParentWindow(window) {
+  try {
+    return window.QueryInterface(Ci.nsIInterfaceRequestor)
+      .getInterface(Ci.nsIWebNavigation)
+      .QueryInterface(Ci.nsIDocShellTreeItem).parent
+      .QueryInterface(Ci.nsIInterfaceRequestor)
+      .getInterface(Ci.nsIDOMWindow);
+  }
+  catch (e) {}
+  return null;
+}
+exports.getParentWindow = getParentWindow;
+
+
+function getParentFrame(window) {
+  try {
+    return window.QueryInterface(Ci.nsIInterfaceRequestor)
+      .getInterface(Ci.nsIWebNavigation)
+      .QueryInterface(Ci.nsIDocShellTreeItem).parent
+      .QueryInterface(Ci.nsIInterfaceRequestor)
+      .getInterface(Ci.nsIDOMWindow);
+  }
+  catch (e) {}
+  return null;
+}
+exports.getParentWindow = getParentWindow;
+
+// The element in which the window is embedded, or `null`
+// if the window is top-level. Similar to `window.frameElement`
+// but can cross chrome-content boundries.
+const getFrameElement = target =>
+  (target instanceof Ci.nsIDOMDocument ? target.defaultView : target).
+  QueryInterface(Ci.nsIInterfaceRequestor).
+  getInterface(Ci.nsIDOMWindowUtils).
+  containerElement;
+exports.getFrameElement = getFrameElement;
diff --git a/toolkit/jetpack/sdk/windows.js b/toolkit/jetpack/sdk/windows.js
new file mode 100644
index 000000000..06dbe70b2
--- /dev/null
+++ b/toolkit/jetpack/sdk/windows.js
@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+module.metadata = {
+  'stability': 'stable'
+};
+
+const { isBrowser } = require('./window/utils');
+const { modelFor } = require('./model/core');
+const { viewFor } = require('./view/core');
+
+
+if (require('./system/xul-app').is('Fennec')) {
+  module.exports = require('./windows/fennec');
+}
+else {
+  module.exports = require('./windows/firefox');
+}
+
+
+const browsers = module.exports.browserWindows;
+
+//
+modelFor.when(isBrowser, view => {
+  for (let model of browsers) {
+    if (viewFor(model) === view)
+      return model;
+  }
+  return null;
+});
diff --git a/toolkit/jetpack/sdk/windows/fennec.js b/toolkit/jetpack/sdk/windows/fennec.js
new file mode 100644
index 000000000..3c3b6c313
--- /dev/null
+++ b/toolkit/jetpack/sdk/windows/fennec.js
@@ -0,0 +1,83 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { Class } = require('../core/heritage');
+const { BrowserWindow } = require('../window/browser');
+const { WindowTracker } = require('../deprecated/window-utils');
+const { isBrowser, getMostRecentBrowserWindow } = require('../window/utils');
+const { windowNS } = require('../window/namespace');
+const { on, off, once, emit } = require('../event/core');
+const { method } = require('../lang/functional');
+const { EventTarget } = require('../event/target');
+const { List, addListItem } = require('../util/list');
+
+const ERR_FENNEC_MSG = 'This method is not yet supported by Fennec, consider using require("sdk/tabs") instead';
+
+// NOTE: On Fennec there is only one window.
+
+var BrowserWindows = Class({
+  implements: [ List ],
+  extends: EventTarget,
+  initialize: function() {
+    List.prototype.initialize.apply(this);
+  },
+  get activeWindow() {
+    let window = getMostRecentBrowserWindow();
+    return window ? getBrowserWindow({window: window}) : null;
+  },
+  open: function open(options) {
+    throw new Error(ERR_FENNEC_MSG);
+    return null;
+  }
+});
+const browserWindows = exports.browserWindows = BrowserWindows();
+
+
+/**
+ * Gets a `BrowserWindow` for the given `chromeWindow` if previously
+ * registered, `null` otherwise.
+ */
+function getRegisteredWindow(chromeWindow) {
+  for (let window of browserWindows) {
+    if (chromeWindow === windowNS(window).window)
+      return window;
+  }
+
+  return null;
+}
+
+/**
+ * Gets a `BrowserWindow` for the provided window options obj
+ * @params {Object} options
+ *    Options that are passed to the the `BrowserWindow`
+ * @returns {BrowserWindow}
+ */
+function getBrowserWindow(options) {
+  let window = null;
+
+  // if we have a BrowserWindow already then use it
+  if ('window' in options)
+    window = getRegisteredWindow(options.window);
+  if (window)
+    return window;
+
+  // we don't have a BrowserWindow yet, so create one
+  window = BrowserWindow(options);
+  addListItem(browserWindows, window);
+  return window;
+}
+
+WindowTracker({
+  onTrack: function onTrack(chromeWindow) {
+    if (!isBrowser(chromeWindow)) return;
+    let window = getBrowserWindow({ window: chromeWindow });
+    emit(browserWindows, 'open', window);
+  },
+  onUntrack: function onUntrack(chromeWindow) {
+    if (!isBrowser(chromeWindow)) return;
+    let window = getBrowserWindow({ window: chromeWindow });
+    emit(browserWindows, 'close', window);
+  }
+});
diff --git a/toolkit/jetpack/sdk/windows/firefox.js b/toolkit/jetpack/sdk/windows/firefox.js
new file mode 100644
index 000000000..1eb1d8488
--- /dev/null
+++ b/toolkit/jetpack/sdk/windows/firefox.js
@@ -0,0 +1,224 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Class } = require('../core/heritage');
+const { observer } = require('./observer');
+const { isBrowser, getMostRecentBrowserWindow, windows, open, getInnerId,
+        getWindowTitle, getToplevelWindow, isFocused, isWindowPrivate } = require('../window/utils');
+const { List, addListItem, removeListItem } = require('../util/list');
+const { viewFor } = require('../view/core');
+const { modelFor } = require('../model/core');
+const { emit, emitOnObject, setListeners } = require('../event/core');
+const { once } = require('../dom/events');
+const { EventTarget } = require('../event/target');
+const { getSelectedTab } = require('../tabs/utils');
+const { Cc, Ci } = require('chrome');
+const { Options } = require('../tabs/common');
+const system = require('../system/events');
+const { ignoreWindow, isPrivate, isWindowPBSupported } = require('../private-browsing/utils');
+const { data, isPrivateBrowsingSupported } = require('../self');
+const { setImmediate } = require('../timers');
+
+const supportPrivateWindows = isPrivateBrowsingSupported && isWindowPBSupported;
+
+const modelsFor = new WeakMap();
+const viewsFor = new WeakMap();
+
+const Window = Class({
+  implements: [EventTarget],
+  initialize: function(domWindow) {
+    modelsFor.set(domWindow, this);
+    viewsFor.set(this, domWindow);
+  },
+
+  get title() {
+    return getWindowTitle(viewsFor.get(this));
+  },
+
+  activate: function() {
+    viewsFor.get(this).focus();
+  },
+
+  close: function(callback) {
+    let domWindow = viewsFor.get(this);
+
+    if (callback) {
+      // We want to catch the close event immediately after the close events are
+      // emitted everywhere but without letting the event loop spin. Registering
+      // for the same events as windowEventListener but afterwards does this
+      let listener = (event, closedWin) => {
+        if (event != "close" || closedWin != domWindow)
+          return;
+
+        observer.off("*", listener);
+        callback();
+      }
+
+      observer.on("*", listener);
+    }
+
+    domWindow.close();
+  }
+});
+
+const windowTabs = new WeakMap();
+
+const BrowserWindow = Class({
+  extends: Window,
+
+  get tabs() {
+    let tabs = windowTabs.get(this);
+    if (tabs)
+      return tabs;
+
+    return new WindowTabs(this);
+  }
+});
+
+const WindowTabs = Class({
+  implements: [EventTarget],
+  extends: List,
+  initialize: function(window) {
+    List.prototype.initialize.call(this);
+    windowTabs.set(window, this);
+    viewsFor.set(this, viewsFor.get(window));
+
+    // Make sure the tabs module has loaded and found all existing tabs
+    const tabs = require('../tabs');
+
+    for (let tab of tabs) {
+      if (tab.window == window)
+        addListItem(this, tab);
+    }
+  },
+
+  get activeTab() {
+    return modelFor(getSelectedTab(viewsFor.get(this)));
+  },
+
+  open: function(options) {
+    options = Options(options);
+
+    let domWindow = viewsFor.get(this);
+    let { Tab } = require('../tabs/tab-firefox');
+
+    // The capturing listener will see the TabOpen event before
+    // sdk/tabs/observer giving us time to set up the tab and listeners before
+    // the real open event is fired
+    let listener = event => {
+      new Tab(event.target, options);
+    };
+
+    once(domWindow, "TabOpen", listener, true);
+    domWindow.gBrowser.addTab(options.url);
+  }
+});
+
+const BrowserWindows = Class({
+  implements: [EventTarget],
+  extends: List,
+  initialize: function() {
+    List.prototype.initialize.call(this);
+  },
+
+  get activeWindow() {
+    let domWindow = getMostRecentBrowserWindow();
+    if (ignoreWindow(domWindow))
+      return null;
+    return modelsFor.get(domWindow);
+  },
+
+  open: function(options) {
+    if (typeof options == "string")
+      options = { url: options };
+
+    let { url, isPrivate } = options;
+    if (url)
+      url = data.url(url);
+
+    let args = Cc["@mozilla.org/supports-string;1"].
+               createInstance(Ci.nsISupportsString);
+    args.data = url;
+
+    let features = {
+      chrome: true,
+      all: true,
+      dialog: false
+    };
+    features.private = supportPrivateWindows && isPrivate;
+
+    let domWindow = open(null, {
+      parent: null,
+      name: "_blank",
+      features,
+      args
+    })
+
+    let window = makeNewWindow(domWindow, true);
+    setListeners(window, options);
+    return window;
+  }
+});
+
+const browserWindows = new BrowserWindows();
+exports.browserWindows = browserWindows;
+
+function windowEmit(window, event, ...args) {
+  if (window instanceof BrowserWindow && (event == "open" || event == "close"))
+    emitOnObject(window, event, browserWindows, window, ...args);
+  else
+    emit(window, event, window, ...args);
+
+  if (window instanceof BrowserWindow)
+    emit(browserWindows, event, window, ...args);
+}
+
+function makeNewWindow(domWindow, browserHint = false) {
+  if (browserHint || isBrowser(domWindow))
+    return new BrowserWindow(domWindow);
+  else
+    return new Window(domWindow);
+}
+
+for (let domWindow of windows(null, {includePrivate: supportPrivateWindows})) {
+  let window = makeNewWindow(domWindow);
+  if (window instanceof BrowserWindow)
+    addListItem(browserWindows, window);
+}
+
+var windowEventListener = (event, domWindow, ...args) => {
+  let toplevelWindow = getToplevelWindow(domWindow);
+
+  if (ignoreWindow(toplevelWindow))
+    return;
+
+  let window = modelsFor.get(toplevelWindow);
+  if (!window)
+    window = makeNewWindow(toplevelWindow);
+
+  if (isBrowser(toplevelWindow)) {
+    if (event == "open")
+      addListItem(browserWindows, window);
+    else if (event == "close")
+      removeListItem(browserWindows, window);
+  }
+
+  windowEmit(window, event, ...args);
+
+  // The window object shouldn't be reachable after closed
+  if (event == "close") {
+    viewsFor.delete(window);
+    modelsFor.delete(toplevelWindow);
+  }
+};
+observer.on("*", windowEventListener);
+
+viewFor.define(BrowserWindow, window => {
+  return viewsFor.get(window);
+})
+
+const isBrowserWindow = (x) => x instanceof BrowserWindow;
+isPrivate.when(isBrowserWindow, (w) => isWindowPrivate(viewsFor.get(w)));
+isFocused.when(isBrowserWindow, (w) => isFocused(viewsFor.get(w)));
diff --git a/toolkit/jetpack/sdk/windows/observer.js b/toolkit/jetpack/sdk/windows/observer.js
new file mode 100644
index 000000000..5ba2535f1
--- /dev/null
+++ b/toolkit/jetpack/sdk/windows/observer.js
@@ -0,0 +1,53 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { EventTarget } = require("../event/target");
+const { emit } = require("../event/core");
+const { WindowTracker, windowIterator } = require("../deprecated/window-utils");
+const { DOMEventAssembler } = require("../deprecated/events/assembler");
+const { Class } = require("../core/heritage");
+const { Cu } = require("chrome");
+
+// Event emitter objects used to register listeners and emit events on them
+// when they occur.
+const Observer = Class({
+  initialize() {
+    // Using `WindowTracker` to track window events.
+    WindowTracker({
+      onTrack: chromeWindow => {
+        emit(this, "open", chromeWindow);
+        this.observe(chromeWindow);
+      },
+      onUntrack: chromeWindow => {
+        emit(this, "close", chromeWindow);
+        this.ignore(chromeWindow);
+      }
+    });
+  },
+  implements: [EventTarget, DOMEventAssembler],
+  /**
+   * Events that are supported and emitted by the module.
+   */
+  supportedEventsTypes: [ "activate", "deactivate" ],
+  /**
+   * Function handles all the supported events on all the windows that are
+   * observed. Method is used to proxy events to the listeners registered on
+   * this event emitter.
+   * @param {Event} event
+   *    Keyboard event being emitted.
+   */
+  handleEvent(event) {
+    // Ignore events from windows in the child process as they can't be top-level
+    if (Cu.isCrossProcessWrapper(event.target))
+      return;
+    emit(this, event.type, event.target, event);
+  }
+});
+
+exports.observer = new Observer();
diff --git a/toolkit/jetpack/sdk/windows/tabs-fennec.js b/toolkit/jetpack/sdk/windows/tabs-fennec.js
new file mode 100644
index 000000000..0ef5ec9f5
--- /dev/null
+++ b/toolkit/jetpack/sdk/windows/tabs-fennec.js
@@ -0,0 +1,172 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+'use strict';
+
+const { Class } = require('../core/heritage');
+const { Tab } = require('../tabs/tab');
+const { browserWindows } = require('./fennec');
+const { windowNS } = require('../window/namespace');
+const { tabsNS, tabNS } = require('../tabs/namespace');
+const { openTab, getTabs, getSelectedTab, getTabForBrowser: getRawTabForBrowser,
+        getTabContentWindow } = require('../tabs/utils');
+const { Options } = require('../tabs/common');
+const { getTabForBrowser, getTabForRawTab } = require('../tabs/helpers');
+const { on, once, off, emit } = require('../event/core');
+const { method } = require('../lang/functional');
+const { EVENTS } = require('../tabs/events');
+const { EventTarget } = require('../event/target');
+const { when: unload } = require('../system/unload');
+const { windowIterator } = require('../deprecated/window-utils');
+const { List, addListItem, removeListItem } = require('../util/list');
+const { isPrivateBrowsingSupported, data } = require('../self');
+const { isTabPBSupported, ignoreWindow } = require('../private-browsing/utils');
+
+const mainWindow = windowNS(browserWindows.activeWindow).window;
+
+const ERR_FENNEC_MSG = 'This method is not yet supported by Fennec';
+
+const supportPrivateTabs = isPrivateBrowsingSupported && isTabPBSupported;
+
+const Tabs = Class({
+  implements: [ List ],
+  extends: EventTarget,
+  initialize: function initialize(options) {
+    let tabsInternals = tabsNS(this);
+    let window = tabsNS(this).window = options.window || mainWindow;
+
+    EventTarget.prototype.initialize.call(this, options);
+    List.prototype.initialize.apply(this, getTabs(window).map(Tab));
+
+    // TabOpen event
+    window.BrowserApp.deck.addEventListener(EVENTS.open.dom, onTabOpen, false);
+
+    // TabSelect
+    window.BrowserApp.deck.addEventListener(EVENTS.activate.dom, onTabSelect, false);
+  },
+  get activeTab() {
+    return getTabForRawTab(getSelectedTab(tabsNS(this).window));
+  },
+  open: function(options) {
+    options = Options(options);
+    let activeWin = browserWindows.activeWindow;
+
+    if (options.isPinned) {
+      console.error(ERR_FENNEC_MSG); // TODO
+    }
+
+    let url = options.url ? data.url(options.url) : options.url;
+    let rawTab = openTab(windowNS(activeWin).window, url, {
+      inBackground: options.inBackground,
+      isPrivate: supportPrivateTabs && options.isPrivate
+    });
+
+    // by now the tab has been created
+    let tab = getTabForRawTab(rawTab);
+
+    if (options.onClose)
+      tab.on('close', options.onClose);
+
+    if (options.onOpen) {
+      // NOTE: on Fennec this will be true
+      if (tabNS(tab).opened)
+        options.onOpen(tab);
+
+      tab.on('open', options.onOpen);
+    }
+
+    if (options.onReady)
+      tab.on('ready', options.onReady);
+
+    if (options.onLoad)
+      tab.on('load', options.onLoad);
+
+    if (options.onPageShow)
+      tab.on('pageshow', options.onPageShow);
+
+    if (options.onActivate)
+      tab.on('activate', options.onActivate);
+
+    return tab;
+  }
+});
+var gTabs = exports.tabs = Tabs(mainWindow);
+
+function tabsUnloader(event, window) {
+  window = window || (event && event.target);
+  if (!(window && window.BrowserApp))
+    return;
+  window.BrowserApp.deck.removeEventListener(EVENTS.open.dom, onTabOpen, false);
+  window.BrowserApp.deck.removeEventListener(EVENTS.activate.dom, onTabSelect, false);
+}
+
+// unload handler
+unload(function() {
+  for (let window in windowIterator()) {
+    tabsUnloader(null, window);
+  }
+});
+
+function addTab(tab) {
+  addListItem(gTabs, tab);
+  return tab;
+}
+
+function removeTab(tab) {
+  removeListItem(gTabs, tab);
+  return tab;
+}
+
+// TabOpen
+function onTabOpen(event) {
+  let browser = event.target;
+
+  // Eventually ignore private tabs
+  if (ignoreWindow(browser.contentWindow))
+    return;
+
+  let tab = getTabForBrowser(browser);
+  if (tab === null) {
+    let rawTab = getRawTabForBrowser(browser);
+
+    // create a Tab instance for this new tab
+    tab = addTab(Tab(rawTab));
+  }
+
+  tabNS(tab).opened = true;
+
+  tab.on('ready', () => emit(gTabs, 'ready', tab));
+  tab.once('close', onTabClose);
+
+  tab.on('pageshow', (_tab, persisted) =>
+    emit(gTabs, 'pageshow', tab, persisted));
+
+  emit(tab, 'open', tab);
+  emit(gTabs, 'open', tab);
+}
+
+// TabSelect
+function onTabSelect(event) {
+  let browser = event.target;
+
+  // Eventually ignore private tabs
+  if (ignoreWindow(browser.contentWindow))
+    return;
+
+  // Set value whenever new tab becomes active.
+  let tab = getTabForBrowser(browser);
+  emit(tab, 'activate', tab);
+  emit(gTabs, 'activate', tab);
+
+  for (let t of gTabs) {
+    if (t === tab) continue;
+    emit(t, 'deactivate', t);
+    emit(gTabs, 'deactivate', t);
+  }
+}
+
+// TabClose
+function onTabClose(tab) {
+  removeTab(tab);
+  emit(gTabs, EVENTS.close.name, tab);
+}
diff --git a/toolkit/jetpack/sdk/worker/utils.js b/toolkit/jetpack/sdk/worker/utils.js
new file mode 100644
index 000000000..fca19be63
--- /dev/null
+++ b/toolkit/jetpack/sdk/worker/utils.js
@@ -0,0 +1,19 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+'use strict';
+
+module.metadata = {
+  'stability': 'deprecated'
+};
+
+const {
+  requiresAddonGlobal, attach, detach, destroy, WorkerHost
+} = require('../content/utils');
+
+exports.WorkerHost = WorkerHost;
+exports.detach = detach;
+exports.attach = attach;
+exports.destroy = destroy;
+exports.requiresAddonGlobal = requiresAddonGlobal;
diff --git a/toolkit/jetpack/sdk/zip/utils.js b/toolkit/jetpack/sdk/zip/utils.js
new file mode 100644
index 000000000..e600380cb
--- /dev/null
+++ b/toolkit/jetpack/sdk/zip/utils.js
@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+const { Cc, Ci } = require("chrome");
+
+function getZipReader(aFile) {
+  return new Promise(resolve => {
+    let zipReader = Cc["@mozilla.org/libjar/zip-reader;1"].
+                        createInstance(Ci.nsIZipReader);
+    zipReader.open(aFile);
+    resolve(zipReader);
+  });
+};
+exports.getZipReader = getZipReader;
diff --git a/toolkit/jetpack/test.js b/toolkit/jetpack/test.js
new file mode 100644
index 000000000..f0219f0a4
--- /dev/null
+++ b/toolkit/jetpack/test.js
@@ -0,0 +1,11 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+module.exports = require("sdk/test");
diff --git a/toolkit/jetpack/toolkit/loader.js b/toolkit/jetpack/toolkit/loader.js
new file mode 100644
index 000000000..4c22550d8
--- /dev/null
+++ b/toolkit/jetpack/toolkit/loader.js
@@ -0,0 +1,1147 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+;((factory) => { // Module boilerplate :(
+  if (typeof(require) === 'function') { // CommonJS
+    require("chrome").Cu.import(module.uri, exports);
+  }
+  else if (~String(this).indexOf('BackstagePass')) { // JSM
+    let module = { uri: __URI__, id: "toolkit/loader", exports: Object.create(null) }
+    factory(module);
+    Object.assign(this, module.exports);
+    this.EXPORTED_SYMBOLS = Object.getOwnPropertyNames(module.exports);
+  }
+  else {
+    throw Error("Loading environment is not supported");
+  }
+})(module => {
+
+'use strict';
+
+module.metadata = {
+  "stability": "unstable"
+};
+
+const { classes: Cc, Constructor: CC, interfaces: Ci, utils: Cu,
+        results: Cr, manager: Cm } = Components;
+const systemPrincipal = CC('@mozilla.org/systemprincipal;1', 'nsIPrincipal')();
+const { loadSubScript } = Cc['@mozilla.org/moz/jssubscript-loader;1'].
+                     getService(Ci.mozIJSSubScriptLoader);
+const { addObserver, notifyObservers } = Cc['@mozilla.org/observer-service;1'].
+                        getService(Ci.nsIObserverService);
+const { XPCOMUtils } = Cu.import("resource://gre/modules/XPCOMUtils.jsm", {});
+const { NetUtil } = Cu.import("resource://gre/modules/NetUtil.jsm", {});
+const { join: pathJoin, normalize, dirname } = Cu.import("resource://gre/modules/osfile/ospath_unix.jsm");
+
+XPCOMUtils.defineLazyServiceGetter(this, "resProto",
+                                   "@mozilla.org/network/protocol;1?name=resource",
+                                   "nsIResProtocolHandler");
+XPCOMUtils.defineLazyServiceGetter(this, "zipCache",
+                                   "@mozilla.org/libjar/zip-reader-cache;1",
+                                   "nsIZipReaderCache");
+
+XPCOMUtils.defineLazyGetter(this, "XulApp", () => {
+  let xulappURI = module.uri.replace("toolkit/loader.js",
+                                     "sdk/system/xul-app.jsm");
+  return Cu.import(xulappURI, {});
+});
+
+// Define some shortcuts.
+const bind = Function.call.bind(Function.bind);
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const prototypeOf = Object.getPrototypeOf;
+const getOwnIdentifiers = x => [...Object.getOwnPropertyNames(x),
+                                ...Object.getOwnPropertySymbols(x)];
+
+const NODE_MODULES = new Set([
+  "assert",
+  "buffer_ieee754",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "_debugger",
+  "dgram",
+  "dns",
+  "domain",
+  "events",
+  "freelist",
+  "fs",
+  "http",
+  "https",
+  "_linklist",
+  "module",
+  "net",
+  "os",
+  "path",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "sys",
+  "timers",
+  "tls",
+  "tty",
+  "url",
+  "util",
+  "vm",
+  "zlib",
+]);
+
+const COMPONENT_ERROR = '`Components` is not available in this context.\n' +
+  'Functionality provided by Components may be available in an SDK\n' +
+  'module: https://developer.mozilla.org/en-US/Add-ons/SDK \n\n' +
+  'However, if you still need to import Components, you may use the\n' +
+  '`chrome` module\'s properties for shortcuts to Component properties:\n\n' +
+  'Shortcuts: \n' +
+  '    Cc = Components' + '.classes \n' +
+  '    Ci = Components' + '.interfaces \n' +
+  '    Cu = Components' + '.utils \n' +
+  '    CC = Components' + '.Constructor \n' +
+  'Example: \n' +
+  '    let { Cc, Ci } = require(\'chrome\');\n';
+
+// Workaround for bug 674195. Freezing objects from other compartments fail,
+// so we use `Object.freeze` from the same component instead.
+function freeze(object) {
+  if (prototypeOf(object) === null) {
+      Object.freeze(object);
+  }
+  else {
+    prototypeOf(prototypeOf(object.isPrototypeOf)).
+      constructor. // `Object` from the owner compartment.
+      freeze(object);
+  }
+  return object;
+}
+
+// Returns map of given `object`-s own property descriptors.
+const descriptor = iced(function descriptor(object) {
+  let value = {};
+  getOwnIdentifiers(object).forEach(function(name) {
+    value[name] = getOwnPropertyDescriptor(object, name)
+  });
+  return value;
+});
+Loader.descriptor = descriptor;
+
+// Freeze important built-ins so they can't be used by untrusted code as a
+// message passing channel.
+freeze(Object);
+freeze(Object.prototype);
+freeze(Function);
+freeze(Function.prototype);
+freeze(Array);
+freeze(Array.prototype);
+freeze(String);
+freeze(String.prototype);
+
+// This function takes `f` function sets it's `prototype` to undefined and
+// freezes it. We need to do this kind of deep freeze with all the exposed
+// functions so that untrusted code won't be able to use them a message
+// passing channel.
+function iced(f) {
+  if (!Object.isFrozen(f)) {
+    f.prototype = undefined;
+  }
+  return freeze(f);
+}
+
+// Defines own properties of given `properties` object on the given
+// target object overriding any existing property with a conflicting name.
+// Returns `target` object. Note we only export this function because it's
+// useful during loader bootstrap when other util modules can't be used &
+// thats only case where this export should be used.
+const override = iced(function override(target, source) {
+  let properties = descriptor(target)
+  let extension = descriptor(source || {})
+  getOwnIdentifiers(extension).forEach(function(name) {
+    properties[name] = extension[name];
+  });
+  return Object.defineProperties({}, properties);
+});
+Loader.override = override;
+
+function sourceURI(uri) { return String(uri).split(" -> ").pop(); }
+Loader.sourceURI = iced(sourceURI);
+
+function isntLoaderFrame(frame) { return frame.fileName !== module.uri }
+
+function parseURI(uri) { return String(uri).split(" -> ").pop(); }
+Loader.parseURI = parseURI;
+
+function parseStack(stack) {
+  let lines = String(stack).split("\n");
+  return lines.reduce(function(frames, line) {
+    if (line) {
+      let atIndex = line.indexOf("@");
+      let columnIndex = line.lastIndexOf(":");
+      let lineIndex = line.lastIndexOf(":", columnIndex - 1);
+      let fileName = parseURI(line.slice(atIndex + 1, lineIndex));
+      let lineNumber = parseInt(line.slice(lineIndex + 1, columnIndex));
+      let columnNumber = parseInt(line.slice(columnIndex + 1));
+      let name = line.slice(0, atIndex).split("(").shift();
+      frames.unshift({
+        fileName: fileName,
+        name: name,
+        lineNumber: lineNumber,
+        columnNumber: columnNumber
+      });
+    }
+    return frames;
+  }, []);
+}
+Loader.parseStack = parseStack;
+
+function serializeStack(frames) {
+  return frames.reduce(function(stack, frame) {
+    return frame.name + "@" +
+           frame.fileName + ":" +
+           frame.lineNumber + ":" +
+           frame.columnNumber + "\n" +
+           stack;
+  }, "");
+}
+Loader.serializeStack = serializeStack;
+
+class DefaultMap extends Map {
+  constructor(createItem, items = undefined) {
+    super(items);
+
+    this.createItem = createItem;
+  }
+
+  get(key) {
+    if (!this.has(key)) {
+      this.set(key, this.createItem(key));
+    }
+
+    return super.get(key);
+  }
+}
+
+const urlCache = {
+  /**
+   * Returns a list of fully-qualified URLs for entries within the zip
+   * file at the given URI which are either directories or files with a
+   * .js or .json extension.
+   *
+   * @param {nsIJARURI} uri
+   * @param {string} baseURL
+   *        The original base URL, prior to resolution.
+   *
+   * @returns {Set<string>}
+   */
+  getZipFileContents(uri, baseURL) {
+    // Make sure the path has a trailing slash, and strip off the leading
+    // slash, so that we can easily check whether it is a path prefix.
+    let basePath = addTrailingSlash(uri.JAREntry).slice(1);
+    let file = uri.JARFile.QueryInterface(Ci.nsIFileURL).file;
+
+    let enumerator = zipCache.getZip(file).findEntries("(*.js|*.json|*/)");
+
+    let results = new Set();
+    for (let entry of XPCOMUtils.IterStringEnumerator(enumerator)) {
+      if (entry.startsWith(basePath)) {
+        let path = entry.slice(basePath.length);
+
+        results.add(baseURL + path);
+      }
+    }
+
+    return results;
+  },
+
+  zipContentsCache: new DefaultMap(baseURL => {
+    let uri = NetUtil.newURI(baseURL);
+
+    if (baseURL.startsWith("resource:")) {
+      uri = NetUtil.newURI(resProto.resolveURI(uri));
+    }
+
+    if (uri instanceof Ci.nsIJARURI) {
+      return urlCache.getZipFileContents(uri, baseURL);
+    }
+
+    return null;
+  }),
+
+  filesCache: new DefaultMap(url => {
+    try {
+      let uri = NetUtil.newURI(url).QueryInterface(Ci.nsIFileURL);
+
+      return uri.file.exists();
+    } catch (e) {
+      return false;
+    }
+  }),
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsISupportsWeakReference]),
+
+  observe() {
+    // Clear any module resolution caches when the startup cache is flushed,
+    // since it probably means we're loading new copies of extensions.
+    this.zipContentsCache.clear();
+    this.filesCache.clear();
+  },
+
+  /**
+   * Returns the base URL for the given URL, if one can be determined. For
+   * a resource: URL, this is the root of the resource package. For a jar:
+   * URL, it is the root of the JAR file. Otherwise, null is returned.
+   *
+   * @param {string} url
+   * @returns {string?}
+   */
+  getBaseURL(url) {
+    // By using simple string matching for the common case of resource: URLs
+    // backed by jar: URLs, we can avoid creating any nsIURI objects for the
+    // common case where the JAR contents are already cached.
+    if (url.startsWith("resource://")) {
+      return /^resource:\/\/[^\/]+\//.exec(url)[0];
+    }
+
+    let uri = NetUtil.newURI(url);
+    if (uri instanceof Ci.nsIJARURI) {
+      return `jar:${uri.JARFile.spec}!/`;
+    }
+
+    return null;
+  },
+
+  /**
+   * Returns true if the target of the given URL exists as a local file,
+   * or as an entry in a local zip file.
+   *
+   * @param {string} url
+   * @returns {boolean}
+   */
+  exists(url) {
+    if (!/\.(?:js|json)$/.test(url)) {
+      url = addTrailingSlash(url);
+    }
+
+    let baseURL = this.getBaseURL(url);
+    let scripts = baseURL && this.zipContentsCache.get(baseURL);
+    if (scripts) {
+      return scripts.has(url);
+    }
+
+    return this.filesCache.get(url);
+  },
+}
+addObserver(urlCache, "startupcache-invalidate", true);
+
+function readURI(uri) {
+  let nsURI = NetUtil.newURI(uri);
+  if (nsURI.scheme == "resource") {
+    // Resolve to a real URI, this will catch any obvious bad paths without
+    // logging assertions in debug builds, see bug 1135219
+    uri = resProto.resolveURI(nsURI);
+  }
+
+  let stream = NetUtil.newChannel({
+    uri: NetUtil.newURI(uri, 'UTF-8'),
+    loadUsingSystemPrincipal: true}
+  ).open2();
+  let count = stream.available();
+  let data = NetUtil.readInputStreamToString(stream, count, {
+    charset: 'UTF-8'
+  });
+
+  stream.close();
+
+  return data;
+}
+
+// Combines all arguments into a resolved, normalized path
+function join(base, ...paths) {
+  // If this is an absolute URL, we need to normalize only the path portion,
+  // or we wind up stripping too many slashes and producing invalid URLs.
+  let match = /^((?:resource|file|chrome)\:\/\/[^\/]*|jar:[^!]+!)(.*)/.exec(base);
+  if (match) {
+    return match[1] + normalize(pathJoin(match[2], ...paths));
+  }
+
+  return normalize(pathJoin(base, ...paths));
+}
+Loader.join = join;
+
+// Function takes set of options and returns a JS sandbox. Function may be
+// passed set of options:
+//  - `name`: A string value which identifies the sandbox in about:memory. Will
+//    throw exception if omitted.
+// - `principal`: String URI or `nsIPrincipal` for the sandbox. Defaults to
+//    system principal.
+// - `prototype`: Ancestor for the sandbox that will be created. Defaults to
+//    `{}`.
+// - `wantXrays`: A Boolean value indicating whether code outside the sandbox
+//    wants X-ray vision with respect to objects inside the sandbox. Defaults
+//    to `true`.
+// - `sandbox`: A sandbox to share JS compartment with. If omitted new
+//    compartment will be created.
+// - `metadata`: A metadata object associated with the sandbox. It should
+//    be JSON-serializable.
+// For more details see:
+// https://developer.mozilla.org/en/Components.utils.Sandbox
+const Sandbox = iced(function Sandbox(options) {
+  // Normalize options and rename to match `Cu.Sandbox` expectations.
+  options = {
+    // Do not expose `Components` if you really need them (bad idea!) you
+    // still can expose via prototype.
+    wantComponents: false,
+    sandboxName: options.name,
+    principal: 'principal' in options ? options.principal : systemPrincipal,
+    wantXrays: 'wantXrays' in options ? options.wantXrays : true,
+    wantGlobalProperties: 'wantGlobalProperties' in options ?
+                          options.wantGlobalProperties : [],
+    sandboxPrototype: 'prototype' in options ? options.prototype : {},
+    invisibleToDebugger: 'invisibleToDebugger' in options ?
+                         options.invisibleToDebugger : false,
+    metadata: 'metadata' in options ? options.metadata : {},
+    waiveIntereposition: !!options.waiveIntereposition
+  };
+
+  if (options.metadata && options.metadata.addonID) {
+    options.addonId = options.metadata.addonID;
+  }
+
+  let sandbox = Cu.Sandbox(options.principal, options);
+
+  // Each sandbox at creation gets set of own properties that will be shadowing
+  // ones from it's prototype. We override delete such `sandbox` properties
+  // to avoid shadowing.
+  delete sandbox.Iterator;
+  delete sandbox.Components;
+  delete sandbox.importFunction;
+  delete sandbox.debug;
+
+  return sandbox;
+});
+Loader.Sandbox = Sandbox;
+
+// Evaluates code from the given `uri` into given `sandbox`. If
+// `options.source` is passed, then that code is evaluated instead.
+// Optionally following options may be given:
+// - `options.encoding`: Source encoding, defaults to 'UTF-8'.
+// - `options.line`: Line number to start count from for stack traces.
+//    Defaults to 1.
+// - `options.version`: Version of JS used, defaults to '1.8'.
+const evaluate = iced(function evaluate(sandbox, uri, options) {
+  let { source, line, version, encoding } = override({
+    encoding: 'UTF-8',
+    line: 1,
+    version: '1.8',
+    source: null
+  }, options);
+
+  return source ? Cu.evalInSandbox(source, sandbox, version, uri, line)
+                : loadSubScript(uri, sandbox, encoding);
+});
+Loader.evaluate = evaluate;
+
+// Populates `exports` of the given CommonJS `module` object, in the context
+// of the given `loader` by evaluating code associated with it.
+const load = iced(function load(loader, module) {
+  let { sandboxes, globals, loadModuleHook } = loader;
+  let require = Require(loader, module);
+
+  // We expose set of properties defined by `CommonJS` specification via
+  // prototype of the sandbox. Also globals are deeper in the prototype
+  // chain so that each module has access to them as well.
+  let descriptors = descriptor({
+    require: require,
+    module: module,
+    exports: module.exports,
+    get Components() {
+      // Expose `Components` property to throw error on usage with
+      // additional information
+      throw new ReferenceError(COMPONENT_ERROR);
+    }
+  });
+
+  let sandbox;
+  if ((loader.useSharedGlobalSandbox || isSystemURI(module.uri)) &&
+      loader.sharedGlobalBlocklist.indexOf(module.id) == -1) {
+    // Create a new object in this sandbox, that will be used as
+    // the scope object for this particular module
+    sandbox = new loader.sharedGlobalSandbox.Object();
+    // Inject all expected globals in the scope object
+    getOwnIdentifiers(globals).forEach(function(name) {
+      descriptors[name] = getOwnPropertyDescriptor(globals, name)
+      descriptors[name].configurable = true;
+    });
+    Object.defineProperties(sandbox, descriptors);
+  }
+  else {
+    sandbox = Sandbox({
+      name: module.uri,
+      prototype: Object.create(globals, descriptors),
+      wantXrays: false,
+      wantGlobalProperties: module.id == "sdk/indexed-db" ? ["indexedDB"] : [],
+      invisibleToDebugger: loader.invisibleToDebugger,
+      metadata: {
+        addonID: loader.id,
+        URI: module.uri
+      }
+    });
+  }
+  sandboxes[module.uri] = sandbox;
+
+  try {
+    evaluate(sandbox, module.uri);
+  }
+  catch (error) {
+    let { message, fileName, lineNumber } = error;
+    let stack = error.stack || Error().stack;
+    let frames = parseStack(stack).filter(isntLoaderFrame);
+    let toString = String(error);
+    let file = sourceURI(fileName);
+
+    // Note that `String(error)` where error is from subscript loader does
+    // not puts `:` after `"Error"` unlike regular errors thrown by JS code.
+    // If there is a JS stack then this error has already been handled by an
+    // inner module load.
+    if (/^Error opening input stream/.test(String(error))) {
+      let caller = frames.slice(0).pop();
+      fileName = caller.fileName;
+      lineNumber = caller.lineNumber;
+      message = "Module `" + module.id + "` is not found at " + module.uri;
+      toString = message;
+    }
+    // Workaround for a Bug 910653. Errors thrown by subscript loader
+    // do not include `stack` field and above created error won't have
+    // fileName or lineNumber of the module being loaded, so we ensure
+    // it does.
+    else if (frames[frames.length - 1].fileName !== file) {
+      frames.push({ fileName: file, lineNumber: lineNumber, name: "" });
+    }
+
+    let prototype = typeof(error) === "object" ? error.constructor.prototype :
+                    Error.prototype;
+
+    throw Object.create(prototype, {
+      message: { value: message, writable: true, configurable: true },
+      fileName: { value: fileName, writable: true, configurable: true },
+      lineNumber: { value: lineNumber, writable: true, configurable: true },
+      stack: { value: serializeStack(frames), writable: true, configurable: true },
+      toString: { value: () => toString, writable: true, configurable: true },
+    });
+  }
+
+  if (loadModuleHook) {
+    module = loadModuleHook(module, require);
+  }
+
+  if (loader.checkCompatibility) {
+    let err = XulApp.incompatibility(module);
+    if (err) {
+      throw err;
+    }
+  }
+
+  if (module.exports && typeof(module.exports) === 'object')
+    freeze(module.exports);
+
+  return module;
+});
+Loader.load = load;
+
+// Utility function to normalize module `uri`s so they have `.js` extension.
+function normalizeExt(uri) {
+  return isJSURI(uri) ? uri :
+         isJSONURI(uri) ? uri :
+         isJSMURI(uri) ? uri :
+         uri + '.js';
+}
+
+// Strips `rootURI` from `string` -- used to remove absolute resourceURI
+// from a relative path
+function stripBase(rootURI, string) {
+  return string.replace(rootURI, './');
+}
+
+// Utility function to join paths. In common case `base` is a
+// `requirer.uri` but in some cases it may be `baseURI`. In order to
+// avoid complexity we require `baseURI` with a trailing `/`.
+const resolve = iced(function resolve(id, base) {
+  if (!isRelative(id))
+    return id;
+
+  let baseDir = dirname(base);
+  if (!baseDir)
+    return normalize(id);
+
+  let resolved = join(baseDir, id);
+
+  // Joining and normalizing removes the './' from relative files.
+  // We need to ensure the resolution still has the root
+  if (isRelative(base))
+    resolved = './' + resolved;
+
+  return resolved;
+});
+Loader.resolve = resolve;
+
+// Attempts to load `path` and then `path.js`
+// Returns `path` with valid file, or `undefined` otherwise
+function resolveAsFile(path) {
+  // Append '.js' to path name unless it's another support filetype
+  path = normalizeExt(path);
+  if (urlCache.exists(path)) {
+    return path;
+  }
+
+  return null;
+}
+
+// Attempts to load `path/package.json`'s `main` entry,
+// followed by `path/index.js`, or `undefined` otherwise
+function resolveAsDirectory(path) {
+  try {
+    // If `path/package.json` exists, parse the `main` entry
+    // and attempt to load that
+    let manifestPath = addTrailingSlash(path) + 'package.json';
+
+    let main = (urlCache.exists(manifestPath) &&
+                getManifestMain(JSON.parse(readURI(manifestPath))));
+    if (main) {
+      let found = resolveAsFile(join(path, main));
+      if (found) {
+        return found
+      }
+    }
+  } catch (e) {}
+
+  return resolveAsFile(addTrailingSlash(path) + 'index.js');
+}
+
+function resolveRelative(rootURI, modulesDir, id) {
+  let fullId = join(rootURI, modulesDir, id);
+
+  let resolvedPath = (resolveAsFile(fullId) ||
+                      resolveAsDirectory(fullId));
+  if (resolvedPath) {
+    return stripBase(rootURI, resolvedPath);
+  }
+
+  return null;
+}
+
+// From `resolve` module
+// https://github.com/substack/node-resolve/blob/master/lib/node-modules-paths.js
+function* getNodeModulePaths(rootURI, start) {
+  let moduleDir = 'node_modules';
+
+  let parts = start.split('/');
+  while (parts.length) {
+    let leaf = parts.pop();
+    let path = join(...parts, leaf, moduleDir);
+    if (leaf !== moduleDir && urlCache.exists(join(rootURI, path))) {
+      yield path;
+    }
+  }
+
+  if (urlCache.exists(join(rootURI, moduleDir))) {
+    yield moduleDir;
+  }
+}
+
+// Node-style module lookup
+// Takes an id and path and attempts to load a file using node's resolving
+// algorithm.
+// `id` should already be resolved relatively at this point.
+// http://nodejs.org/api/modules.html#modules_all_together
+const nodeResolve = iced(function nodeResolve(id, requirer, { rootURI }) {
+  // Resolve again
+  id = Loader.resolve(id, requirer);
+
+  // If this is already an absolute URI then there is no resolution to do
+  if (isAbsoluteURI(id)) {
+    return null;
+  }
+
+  // we assume that extensions are correct, i.e., a directory doesnt't have '.js'
+  // and a js file isn't named 'file.json.js'
+  let resolvedPath;
+
+  if ((resolvedPath = resolveRelative(rootURI, "", id))) {
+    return resolvedPath;
+  }
+
+  // If the requirer is an absolute URI then the node module resolution below
+  // won't work correctly as we prefix everything with rootURI
+  if (isAbsoluteURI(requirer)) {
+    return null;
+  }
+
+  // If manifest has dependencies, attempt to look up node modules
+  // in the `dependencies` list
+  for (let modulesDir of getNodeModulePaths(rootURI, dirname(requirer))) {
+    if ((resolvedPath = resolveRelative(rootURI, modulesDir, id))) {
+      return resolvedPath;
+    }
+  }
+
+  // We would not find lookup for things like `sdk/tabs`, as that's part of
+  // the alias mapping. If during `generateMap`, the runtime lookup resolves
+  // with `resolveURI` -- if during runtime, then `resolve` will throw.
+  return null;
+});
+
+Loader.nodeResolve = nodeResolve;
+
+function addTrailingSlash(path) {
+  return path.replace(/\/*$/, "/");
+}
+
+const resolveURI = iced(function resolveURI(id, mapping) {
+  // Do not resolve if already a resource URI
+  if (isAbsoluteURI(id))
+    return normalizeExt(id);
+
+  for (let [path, uri] of mapping) {
+    // Strip off any trailing slashes to make comparisons simpler
+    let stripped = path.replace(/\/+$/, "");
+
+    // We only want to match path segments explicitly. Examples:
+    // * "foo/bar" matches for "foo/bar"
+    // * "foo/bar" matches for "foo/bar/baz"
+    // * "foo/bar" does not match for "foo/bar-1"
+    // * "foo/bar/" does not match for "foo/bar"
+    // * "foo/bar/" matches for "foo/bar/baz"
+    //
+    // Check for an empty path, an exact match, or a substring match
+    // with the next character being a forward slash.
+    if(stripped === "" || id === stripped || id.startsWith(stripped + "/")) {
+      return normalizeExt(id.replace(path, uri));
+    }
+  }
+  return null;
+});
+Loader.resolveURI = resolveURI;
+
+// Creates version of `require` that will be exposed to the given `module`
+// in the context of the given `loader`. Each module gets own limited copy
+// of `require` that is allowed to load only a modules that are associated
+// with it during link time.
+const Require = iced(function Require(loader, requirer) {
+  let {
+    modules, mapping, resolve: loaderResolve, load,
+    manifest, rootURI, isNative, requireMap,
+    requireHook
+  } = loader;
+
+  if (isSystemURI(requirer.uri)) {
+    // Built-in modules don't require the expensive module resolution
+    // algorithm used by SDK add-ons, so give them the more efficient standard
+    // resolve instead.
+    isNative = false;
+    loaderResolve = Loader.resolve;
+  }
+
+  function require(id) {
+    if (!id) // Throw if `id` is not passed.
+      throw Error('You must provide a module name when calling require() from '
+                  + requirer.id, requirer.uri);
+
+    if (requireHook) {
+      return requireHook(id, _require);
+    }
+
+    return _require(id);
+  }
+
+  function _require(id) {
+    let { uri, requirement } = getRequirements(id);
+    let module = null;
+    // If module is already cached by loader then just use it.
+    if (uri in modules) {
+      module = modules[uri];
+    }
+    else if (isJSMURI(uri)) {
+      module = modules[uri] = Module(requirement, uri);
+      module.exports = Cu.import(uri, {});
+      freeze(module);
+    }
+    else if (isJSONURI(uri)) {
+      let data;
+
+      // First attempt to load and parse json uri
+      // ex: `test.json`
+      // If that doesn't exist, check for `test.json.js`
+      // for node parity
+      try {
+        data = JSON.parse(readURI(uri));
+        module = modules[uri] = Module(requirement, uri);
+        module.exports = data;
+        freeze(module);
+      }
+      catch (err) {
+        // If error thrown from JSON parsing, throw that, do not
+        // attempt to find .json.js file
+        if (err && /JSON\.parse/.test(err.message))
+          throw err;
+        uri = uri + '.js';
+      }
+    }
+
+    // If not yet cached, load and cache it.
+    // We also freeze module to prevent it from further changes
+    // at runtime.
+    if (!(uri in modules)) {
+      // Many of the loader's functionalities are dependent
+      // on modules[uri] being set before loading, so we set it and
+      // remove it if we have any errors.
+      module = modules[uri] = Module(requirement, uri);
+      try {
+        freeze(load(loader, module));
+      }
+      catch (e) {
+        // Clear out modules cache so we can throw on a second invalid require
+        delete modules[uri];
+        // Also clear out the Sandbox that was created
+        delete loader.sandboxes[uri];
+        throw e;
+      }
+    }
+
+    return module.exports;
+  }
+
+  // Resolution function taking a module name/path and
+  // returning a resourceURI and a `requirement` used by the loader.
+  // Used by both `require` and `require.resolve`.
+  function getRequirements(id) {
+    if (!id) // Throw if `id` is not passed.
+      throw Error('you must provide a module name when calling require() from '
+                  + requirer.id, requirer.uri);
+
+    let requirement, uri;
+
+    // TODO should get native Firefox modules before doing node-style lookups
+    // to save on loading time
+    if (isNative) {
+      // If a requireMap is available from `generateMap`, use that to
+      // immediately resolve the node-style mapping.
+      // TODO: write more tests for this use case
+      if (requireMap && requireMap[requirer.id])
+        requirement = requireMap[requirer.id][id];
+
+      let { overrides } = manifest.jetpack;
+      for (let key in overrides) {
+        // ignore any overrides using relative keys
+        if (/^[.\/]/.test(key)) {
+          continue;
+        }
+
+        // If the override is for x -> y,
+        // then using require("x/lib/z") to get reqire("y/lib/z")
+        // should also work
+        if (id == key || id.startsWith(key + "/")) {
+          id = overrides[key] + id.substr(key.length);
+          id = id.replace(/^[.\/]+/, "");
+        }
+      }
+
+      // For native modules, we want to check if it's a module specified
+      // in 'modules', like `chrome`, or `@loader` -- if it exists,
+      // just set the uri to skip resolution
+      if (!requirement && modules[id])
+        uri = requirement = id;
+
+      // If no requireMap was provided, or resolution not found in
+      // the requireMap, and not a npm dependency, attempt a runtime lookup
+      if (!requirement && !NODE_MODULES.has(id)) {
+        // If `isNative` defined, this is using the new, native-style
+        // loader, not cuddlefish, so lets resolve using node's algorithm
+        // and get back a path that needs to be resolved via paths mapping
+        // in `resolveURI`
+        requirement = loaderResolve(id, requirer.id, {
+          manifest: manifest,
+          rootURI: rootURI
+        });
+      }
+
+      // If not found in the map, not a node module, and wasn't able to be
+      // looked up, it's something
+      // found in the paths most likely, like `sdk/tabs`, which should
+      // be resolved relatively if needed using traditional resolve
+      if (!requirement) {
+        requirement = isRelative(id) ? Loader.resolve(id, requirer.id) : id;
+      }
+    }
+    else if (modules[id]) {
+      uri = requirement = id;
+    }
+    else if (requirer) {
+      // Resolve `id` to its requirer if it's relative.
+      requirement = loaderResolve(id, requirer.id);
+    }
+    else {
+      requirement = id;
+    }
+
+    // Resolves `uri` of module using loaders resolve function.
+    uri = uri || resolveURI(requirement, mapping);
+
+    // Throw if `uri` can not be resolved.
+    if (!uri) {
+      throw Error('Module: Can not resolve "' + id + '" module required by ' +
+                  requirer.id + ' located at ' + requirer.uri, requirer.uri);
+    }
+
+    return { uri: uri, requirement: requirement };
+  }
+
+  // Expose the `resolve` function for this `Require` instance
+  require.resolve = _require.resolve = function resolve(id) {
+    let { uri } = getRequirements(id);
+    return uri;
+  }
+
+  // This is like webpack's require.context.  It returns a new require
+  // function that prepends the prefix to any requests.
+  require.context = prefix => {
+    return id => {
+      return require(prefix + id);
+    };
+  };
+
+  // Make `require.main === module` evaluate to true in main module scope.
+  require.main = loader.main === requirer ? requirer : undefined;
+  return iced(require);
+});
+Loader.Require = Require;
+
+const main = iced(function main(loader, id) {
+  // If no main entry provided, and native loader is used,
+  // read the entry in the manifest
+  if (!id && loader.isNative)
+    id = getManifestMain(loader.manifest);
+  let uri = resolveURI(id, loader.mapping);
+  let module = loader.main = loader.modules[uri] = Module(id, uri);
+  return loader.load(loader, module).exports;
+});
+Loader.main = main;
+
+// Makes module object that is made available to CommonJS modules when they
+// are evaluated, along with `exports` and `require`.
+const Module = iced(function Module(id, uri) {
+  return Object.create(null, {
+    id: { enumerable: true, value: id },
+    exports: { enumerable: true, writable: true, value: Object.create(null),
+               configurable: true },
+    uri: { value: uri }
+  });
+});
+Loader.Module = Module;
+
+// Takes `loader`, and unload `reason` string and notifies all observers that
+// they should cleanup after them-self.
+const unload = iced(function unload(loader, reason) {
+  // subject is a unique object created per loader instance.
+  // This allows any code to cleanup on loader unload regardless of how
+  // it was loaded. To handle unload for specific loader subject may be
+  // asserted against loader.destructor or require('@loader/unload')
+  // Note: We don not destroy loader's module cache or sandboxes map as
+  // some modules may do cleanup in subsequent turns of event loop. Destroying
+  // cache may cause module identity problems in such cases.
+  let subject = { wrappedJSObject: loader.destructor };
+  notifyObservers(subject, 'sdk:loader:destroy', reason);
+});
+Loader.unload = unload;
+
+// Function makes new loader that can be used to load CommonJS modules
+// described by a given `options.manifest`. Loader takes following options:
+// - `globals`: Optional map of globals, that all module scopes will inherit
+//   from. Map is also exposed under `globals` property of the returned loader
+//   so it can be extended further later. Defaults to `{}`.
+// - `modules` Optional map of built-in module exports mapped by module id.
+//   These modules will incorporated into module cache. Each module will be
+//   frozen.
+// - `resolve` Optional module `id` resolution function. If given it will be
+//   used to resolve module URIs, by calling it with require term, requirer
+//   module object (that has `uri` property) and `baseURI` of the loader.
+//   If `resolve` does not returns `uri` string exception will be thrown by
+//   an associated `require` call.
+function Loader(options) {
+  if (options.sharedGlobalBlacklist && !options.sharedGlobalBlocklist) {
+    options.sharedGlobalBlocklist = options.sharedGlobalBlacklist;
+  }
+  let {
+    modules, globals, resolve, paths, rootURI, manifest, requireMap, isNative,
+    metadata, sharedGlobal, sharedGlobalBlocklist, checkCompatibility, waiveIntereposition
+  } = override({
+    paths: {},
+    modules: {},
+    globals: {
+      get console() {
+        // Import Console.jsm from here to prevent loading it until someone uses it
+        let { ConsoleAPI } = Cu.import("resource://gre/modules/Console.jsm");
+        let console = new ConsoleAPI({
+          consoleID: options.id ? "addon/" + options.id : ""
+        });
+        Object.defineProperty(this, "console", { value: console });
+        return this.console;
+      }
+    },
+    checkCompatibility: false,
+    resolve: options.isNative ?
+      // Make the returned resolve function have the same signature
+      (id, requirer) => Loader.nodeResolve(id, requirer, { rootURI: rootURI }) :
+      Loader.resolve,
+    sharedGlobalBlocklist: ["sdk/indexed-db"],
+    waiveIntereposition: false
+  }, options);
+
+  // Create overrides defaults, none at the moment
+  if (typeof manifest != "object" || !manifest) {
+    manifest = {};
+  }
+  if (typeof manifest.jetpack != "object" || !manifest.jetpack) {
+    manifest.jetpack = {
+      overrides: {}
+    };
+  }
+  if (typeof manifest.jetpack.overrides != "object" || !manifest.jetpack.overrides) {
+    manifest.jetpack.overrides = {};
+  }
+
+  // We create an identity object that will be dispatched on an unload
+  // event as subject. This way unload listeners will be able to assert
+  // which loader is unloaded. Please note that we intentionally don't
+  // use `loader` as subject to prevent a loader access leakage through
+  // observer notifications.
+  let destructor = freeze(Object.create(null));
+
+  // Make mapping array that is sorted from longest path to shortest path.
+  let mapping = Object.keys(paths)
+                      .sort((a, b) => b.length - a.length)
+                      .map(path => [path, paths[path]]);
+
+  // Define pseudo modules.
+  modules = override({
+    '@loader/unload': destructor,
+    '@loader/options': options,
+    'chrome': { Cc: Cc, Ci: Ci, Cu: Cu, Cr: Cr, Cm: Cm,
+                CC: bind(CC, Components), components: Components,
+                // `ChromeWorker` has to be inject in loader global scope.
+                // It is done by bootstrap.js:loadSandbox for the SDK.
+                ChromeWorker: ChromeWorker
+    }
+  }, modules);
+
+  const builtinModuleExports = modules;
+  modules = {};
+  for (let id of Object.keys(builtinModuleExports)) {
+    // We resolve `uri` from `id` since modules are cached by `uri`.
+    let uri = resolveURI(id, mapping);
+    // In native loader, the mapping will not contain values for
+    // pseudomodules -- store them as their ID rather than the URI
+    if (isNative && !uri)
+      uri = id;
+    let module = Module(id, uri);
+
+    // Lazily expose built-in modules in order to
+    // allow them to be loaded lazily.
+    Object.defineProperty(module, "exports", {
+      enumerable: true,
+      get: function() {
+        return builtinModuleExports[id];
+      }
+    });
+
+    modules[uri] = freeze(module);
+  }
+
+  // Create the unique sandbox we will be using for all modules,
+  // so that we prevent creating a new comportment per module.
+  // The side effect is that all modules will share the same
+  // global objects.
+  let sharedGlobalSandbox = Sandbox({
+    name: "Addon-SDK",
+    wantXrays: false,
+    wantGlobalProperties: [],
+    invisibleToDebugger: options.invisibleToDebugger || false,
+    metadata: {
+      addonID: options.id,
+      URI: "Addon-SDK"
+    },
+    prototype: options.sandboxPrototype || {}
+  });
+
+  // Loader object is just a representation of a environment
+  // state. We freeze it and mark make it's properties non-enumerable
+  // as they are pure implementation detail that no one should rely upon.
+  let returnObj = {
+    destructor: { enumerable: false, value: destructor },
+    globals: { enumerable: false, value: globals },
+    mapping: { enumerable: false, value: mapping },
+    // Map of module objects indexed by module URIs.
+    modules: { enumerable: false, value: modules },
+    metadata: { enumerable: false, value: metadata },
+    useSharedGlobalSandbox: { enumerable: false, value: !!sharedGlobal },
+    sharedGlobalSandbox: { enumerable: false, value: sharedGlobalSandbox },
+    sharedGlobalBlocklist: { enumerable: false, value: sharedGlobalBlocklist },
+    sharedGlobalBlacklist: { enumerable: false, value: sharedGlobalBlocklist },
+    // Map of module sandboxes indexed by module URIs.
+    sandboxes: { enumerable: false, value: {} },
+    resolve: { enumerable: false, value: resolve },
+    // ID of the addon, if provided.
+    id: { enumerable: false, value: options.id },
+    // Whether the modules loaded should be ignored by the debugger
+    invisibleToDebugger: { enumerable: false,
+                           value: options.invisibleToDebugger || false },
+    load: { enumerable: false, value: options.load || load },
+    checkCompatibility: { enumerable: false, value: checkCompatibility },
+    requireHook: { enumerable: false, value: options.requireHook },
+    loadModuleHook: { enumerable: false, value: options.loadModuleHook },
+    // Main (entry point) module, it can be set only once, since loader
+    // instance can have only one main module.
+    main: new function() {
+      let main;
+      return {
+        enumerable: false,
+        get: function() { return main; },
+        // Only set main if it has not being set yet!
+        set: function(module) { main = main || module; }
+      }
+    }
+  };
+
+  if (isNative) {
+    returnObj.isNative = { enumerable: false, value: true };
+    returnObj.manifest = { enumerable: false, value: manifest };
+    returnObj.requireMap = { enumerable: false, value: requireMap };
+    returnObj.rootURI = { enumerable: false, value: addTrailingSlash(rootURI) };
+  }
+
+  return freeze(Object.create(null, returnObj));
+};
+Loader.Loader = Loader;
+
+var isSystemURI = uri => /^resource:\/\/(gre|devtools|testing-common)\//.test(uri);
+
+var isJSONURI = uri => uri.endsWith('.json');
+var isJSMURI = uri => uri.endsWith('.jsm');
+var isJSURI = uri => uri.endsWith('.js');
+var isAbsoluteURI = uri => uri.startsWith("resource://") ||
+                           uri.startsWith("chrome://") ||
+                           uri.startsWith("file://");
+var isRelative = id => id.startsWith(".");
+
+// Default `main` entry to './index.js' and ensure is relative,
+// since node allows 'lib/index.js' without relative `./`
+function getManifestMain(manifest) {
+  let main = manifest.main || './index.js';
+  return isRelative(main) ? main : './' + main;
+}
+
+module.exports = iced(Loader);
+});
diff --git a/toolkit/jetpack/toolkit/require.js b/toolkit/jetpack/toolkit/require.js
new file mode 100644
index 000000000..dc3d26ab2
--- /dev/null
+++ b/toolkit/jetpack/toolkit/require.js
@@ -0,0 +1,91 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const make = (exports, rootURI, components) => {
+  const { Loader: { Loader, Require, Module, main } } =
+        components.utils.import(rootURI + "toolkit/loader.js", {});
+
+  const loader = Loader({
+    id: "toolkit/require",
+    rootURI: rootURI,
+    isNative: true,
+    paths: {
+     "": rootURI,
+     "devtools/": "resource://devtools/"
+    }
+  });
+
+  // Implement require.unload(uri) that can be used to unload
+  // already loaded module which is convinient during development phase.
+  const unload = uri => {
+    delete loader.sandboxes[uri];
+    delete loader.modules[uri];
+  };
+
+  const builtins = new Set(Object.keys(loader.modules));
+
+  // Below we define `require` & `require.resolve` that resolve passed
+  // module id relative to the caller URI. This is not perfect but good
+  // enough for common case & there is always an option to pass absolute
+  // id when that
+  // but presumably well enough to cover
+
+  const require = (id, options={}) => {
+    const { reload, all } = options;
+    const requirerURI = components.stack.caller.filename;
+    const requirer = Module(requirerURI, requirerURI);
+    const require = Require(loader, requirer);
+    if (reload) {
+      // To load JS code into modules, loader uses `mozIJSSubScriptLoader`
+      // which uses startup cache to avoid reading source from the same URI
+      // more than once. Unless we invalidate statup cache changes to a module
+      // won't be reflected even after reload. Therefor we must dispatch an
+      // nsIObserverService notification that causes cache invalidation.
+      // Note: This is not ideal since it destroys whole cache, but since there
+      // is no way to invalidate individual entries, we assume performance hit
+      // during development is acceptable.
+      components.classes["@mozilla.org/observer-service;1"].
+        getService(components.interfaces.nsIObserverService).
+        notifyObservers({}, "startupcache-invalidate", null);
+
+      if (all) {
+        for (let uri of Object.keys(loader.sandboxes)) {
+          unload(uri);
+        }
+      }
+      else {
+        unload(require.resolve(id));
+      }
+    }
+    return require(id);
+  };
+
+  require.resolve = id => {
+    const requirerURI = components.stack.caller.filename;
+    const requirer = Module(requirerURI, requirerURI);
+    return Require(loader, requirer).resolve(id);
+  };
+
+  exports.require = require;
+}
+
+// If loaded in the context of commonjs module, reload as JSM into an
+// exports object.
+if (typeof(require) === "function" && typeof(module) === "object") {
+  require("chrome").Cu.import(module.uri, module.exports);
+}
+// If loaded in the context of JSM make a loader & require and define
+// new symbols as exported ones.
+else if (typeof(__URI__) === "string" && this["Components"]) {
+  const builtin = Object.keys(this);
+  const uri = __URI__.replace("toolkit/require.js", "");
+  make(this, uri, this["Components"]);
+
+  this.EXPORTED_SYMBOLS = Object.
+                            keys(this).
+                            filter($ => builtin.indexOf($) < 0);
+}
+else {
+  throw Error("Loading require.js in this environment isn't supported")
+}
diff --git a/toolkit/moz.build b/toolkit/moz.build
index 8fe5126ca..f3159137c 100644
--- a/toolkit/moz.build
+++ b/toolkit/moz.build
@@ -9,6 +9,7 @@ DIRS += [
     'content',
     'forgetaboutsite',
     'identity',
+    'jetpack',
     'locales',
     'modules',
     'mozapps/downloads',
diff --git a/toolkit/toolkit.mozbuild b/toolkit/toolkit.mozbuild
index 0f5b6e997..439282525 100644
--- a/toolkit/toolkit.mozbuild
+++ b/toolkit/toolkit.mozbuild
@@ -157,8 +157,6 @@ DIRS += [
 if 'gtk' in CONFIG['MOZ_WIDGET_TOOLKIT']:
     DIRS += ['/toolkit/system/gnome']
 
-DIRS += ['/addon-sdk']
-
 if CONFIG['ENABLE_MARIONETTE'] or CONFIG['MOZ_WIDGET_TOOLKIT'] not in ('gonk', 'android'):
     DIRS += [
         '/testing/firefox-ui',