replace references to jetpack-core with references to api-utils
authorMyk Melez <myk@mozilla.org>
Tue, 30 Nov 2010 15:54:10 -0800
changeset 1155 6fb01e485626ee49bb477bf8c11f4b8c0a271699
parent 1154 85c9f9686fb239036c02cced82b4ef34ebf5aecf
child 1156 d9dc2d7ccafffa583f07d31a5ded5ba1e6ef2f44
push id474
push userbwarner@mozilla.com
push dateWed, 01 Dec 2010 15:10:18 +0000
replace references to jetpack-core with references to api-utils
packages/addon-kit/docs/context-menu.md
packages/addon-kit/docs/page-mod.md
packages/addon-kit/docs/simple-storage.md
packages/addon-kit/lib/simple-storage.js
packages/addon-kit/package.json
packages/addon-kit/tests/test-simple-storage.js
packages/api-utils/docs/content.md
packages/api-utils/docs/content/symbiont.md
packages/api-utils/docs/content/worker.md
packages/api-utils/docs/file.md
packages/api-utils/lib/content/worker.js
packages/api-utils/lib/list.js
packages/api-utils/package.json
packages/development-mode/package.json
packages/test-harness/package.json
packages/test-harness/tests/test-packaging.js
python-lib/cuddlefish/manifest.py
python-lib/cuddlefish/packaging.py
python-lib/cuddlefish/preflight.py
python-lib/cuddlefish/tests/static-files/packages/aardvark/package.json
python-lib/cuddlefish/tests/test_manifest.py
python-lib/cuddlefish/tests/test_packaging.py
python-lib/cuddlefish/tests/test_server.py
static-files/md/dev-guide/best-practices.md
static-files/md/dev-guide/events.md
static-files/md/dev-guide/packaging.md
static-files/md/dev-guide/troubleshooting.md
static-files/md/dev-guide/web-content.md
static-files/md/dev-guide/xpi.md
--- a/packages/addon-kit/docs/context-menu.md
+++ b/packages/addon-kit/docs/context-menu.md
@@ -98,17 +98,17 @@ following types.  Each is a constructor 
     <td>
       This context occurs when the menu is invoked on pages with particular
       URLs.  <code>matchPattern</code> is a match pattern string or an array of
       match pattern strings.  When <code>matchPattern</code> is an array, the
       context occurs when the menu is invoked on a page whose URL matches any of
       the patterns.  These are the same match pattern strings that you use with
       the <a href="#module/addon-kit/page-mod"><code>page-mod</code></a>
       <code>include</code> property.
-      <a href="#module/jetpack-core/match-pattern">Read more about patterns</a>.
+      <a href="#module/api-utils/match-pattern">Read more about patterns</a>.
     </td>
   </tr>
   <tr>
     <td>
       array
     </td>
     <td>
       An array of any of the other types.  This context occurs when all contexts
@@ -450,13 +450,13 @@ top-level context menu.
 <api name="URLContext">
 @class
 <api name="URLContext">
 @constructor
   Creates a context that matches pages with particular URLs.  See Specifying
   Contexts above.
 @param matchPattern {string,array}
   A [match pattern] string or an array of match pattern strings.
-  [match pattern]: #module/jetpack-core/match-pattern
+  [match pattern]: #module/api-utils/match-pattern
 </api>
 </api>
 
-[self]: #module/jetpack-core/self
+[self]: #module/api-utils/self
--- a/packages/addon-kit/docs/page-mod.md
+++ b/packages/addon-kit/docs/page-mod.md
@@ -24,17 +24,17 @@ scripts that execute in the content proc
 communicate between the content scripts and the main add-on script. For more
 details on content scripting see the tutorial on [interacting with web
 content](#guide/web-content).
 
 To create a PageMod the add-on developer supplies:
 
 * a set of rules to select the desired subset of web pages based on their URL.
 Each rule is specified using the
-[match-pattern](#module/jetpack-core/match-pattern) syntax.
+[match-pattern](#module/api-utils/match-pattern) syntax.
 
 * a set of content scripts to execute in the context of the desired pages.
 
 * a value for the onAttach option: this value is a function which will be
 called when a page is loaded that matches the ruleset. This is used to set up a
 communication channel between the add-on code and the content script.
 
 All these parameters are optional except for the ruleset, which must include
@@ -163,17 +163,17 @@ scripts in the context of any pages matc
 Creates a PageMod.
 @param options {object}
   Options for the PageMod, with the following keys:
   @prop include {string,array}
     A match pattern string or an array of match pattern strings.  These define
     the pages to which the PageMod applies.  See the [match-pattern] module for
     a description of match pattern syntax.
     At least one match pattern must be supplied.
-    [match-pattern]: #module/jetpack-core/match-pattern
+    [match-pattern]: #module/api-utils/match-pattern
   @prop [contentScriptFile] {string,array}
     The local file URLs of content scripts to load.  Content scripts specified
     by this option are loaded *before* those specified by the `contentScript`
     option. Optional.
   @prop [contentScript] {string,array}
     The texts of content scripts to load.  Content scripts specified by this
     option are loaded *after* those specified by the `contentScriptFile` option.
     Optional.
@@ -196,18 +196,18 @@ content scripts](#pagemod-content-script
 
 <api name="include">
 @property {List}
 A [List] of match pattern strings.  These define the pages to which the page mod
 applies.  See the [match-pattern] module for a description of match patterns.
 Rules can be added to the list by calling its `add` method and removed by
 calling its `remove` method.
 
-[List]: https://jetpack.mozillalabs.com/sdk/latest/docs/#module/jetpack-core/list
-[match-pattern]: #module/jetpack-core/match-pattern
+[List]: https://jetpack.mozillalabs.com/sdk/latest/docs/#module/api-utils/list
+[match-pattern]: #module/api-utils/match-pattern
 </api>
 
 <api name="destroy">
 @method
 Stops the page mod from making any more modifications.  Once destroyed the page
 mod can no longer be used.  Note that modifications already made to open pages
 will not be undone.
 </api>
--- a/packages/addon-kit/docs/simple-storage.md
+++ b/packages/addon-kit/docs/simple-storage.md
@@ -91,17 +91,17 @@ Private Browsing
 
 If your storage is related to your users' Web history, personal information, or
 other sensitive data, your extension should respect [private browsing
 mode][SUMO].  While private browsing mode is active, you should not store any
 sensitive data.
 
 Because any kind of data can be placed into simple storage, support for private
 browsing is not built into the module.  Instead, use the `private-browsing`
-module in the `jetpack-core` package to check private browsing status and
+module in the `api-utils` package to check private browsing status and
 respond accordingly.
 
 For example, the URLs your users visit should not be stored during private
 browsing.  If your extension records the URL of the selected tab, here's how you
 might handle that:
 
     simpleStorage.storage.history = [];
     var privateBrowsing = require("private-browsing");
--- a/packages/addon-kit/lib/simple-storage.js
+++ b/packages/addon-kit/lib/simple-storage.js
@@ -42,20 +42,20 @@ const {Cc,Ci} = require("chrome");
 const file = require("file");
 const prefs = require("preferences-service");
 const jpSelf = require("self");
 const timer = require("timer");
 const unload = require("unload");
 const { EventEmitter } = require("events");
 const { Trait } = require("traits");
 
-const WRITE_PERIOD_PREF = "jetpack.jetpack-core.simple-storage.writePeriod";
+const WRITE_PERIOD_PREF = "jetpack.api-utils.simple-storage.writePeriod";
 const WRITE_PERIOD_DEFAULT = 300000; // 5 minutes
 
-const QUOTA_PREF = "jetpack.jetpack-core.simple-storage.quota";
+const QUOTA_PREF = "jetpack.api-utils.simple-storage.quota";
 const QUOTA_DEFAULT = 5242880; // 5 MiB
 
 
 // simpleStorage.storage
 exports.__defineGetter__("storage", function () manager.root);
 exports.__defineSetter__("storage", function (val) manager.root = val);
 
 // simpleStorage.quotaUsage
--- a/packages/addon-kit/package.json
+++ b/packages/addon-kit/package.json
@@ -4,10 +4,10 @@
     "keywords": ["javascript", "engine", "platform", "xulrunner"],
     "author": "Atul Varma (http://toolness.com/) <atul@mozilla.com>",
     "contributors": [
         "Myk Melez (http://melez.com/) <myk@mozilla.org>",
         "Daniel Aquino <mr.danielaquino@gmail.com>"
     ],
     "version": "0.10pre",
     "license": "MPL 1.1/GPL 2.0/LGPL 2.1",
-    "dependencies": ["jetpack-core"]
+    "dependencies": ["api-utils"]
 }
--- a/packages/addon-kit/tests/test-simple-storage.js
+++ b/packages/addon-kit/tests/test-simple-storage.js
@@ -36,17 +36,17 @@
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 const file = require("file");
 const prefs = require("preferences-service");
 
-const QUOTA_PREF = "jetpack.jetpack-core.simple-storage.quota";
+const QUOTA_PREF = "jetpack.api-utils.simple-storage.quota";
 
 let {Cc,Ci} = require("chrome");
 let storeFile = Cc["@mozilla.org/file/directory_service;1"].
                 getService(Ci.nsIProperties).
                 get("ProfD", Ci.nsIFile);
 storeFile.append("jetpack");
 storeFile.append(packaging.jetpackID);
 storeFile.append("simple-storage");
--- a/packages/api-utils/docs/content.md
+++ b/packages/api-utils/docs/content.md
@@ -1,11 +1,11 @@
 <!-- contributed by Irakli Gozalishvili [gozala@mozilla.com] -->
 
 The `content` module exports three different traits [Loader], [Worker] and
 [Symbiont]. None of this traits is intended to be used directly by programs.
 Rather, they are intended to be used by other modules that provide high
 level APIs to programs or libraries.
 
-[Loader]:#module/jetpack-core/content/loader
-[Worker]:#module/jetpack-core/content/worker
-[Symbiont]:#module/jetpack-core/content/symbiont
+[Loader]:#module/api-utils/content/loader
+[Worker]:#module/api-utils/content/worker
+[Symbiont]:#module/api-utils/content/symbiont
 
--- a/packages/api-utils/docs/content/symbiont.md
+++ b/packages/api-utils/docs/content/symbiont.md
@@ -31,36 +31,36 @@ Examples
         // the page is loaded.
         this._frame = getMyFrame();
         this._init(options)
       }
     });
 
 See the [panel] module for a real-world example of usage of this module.
 
-[panel]:#module/jetpack-core/panel
+[panel]:#module/api-utils/panel
 
 Reference
 ---------
 
 <api name="Symbiont">
 @class
 Symbiont is composed from the [Worker] trait, therefore instances
 of Symbiont and their descendants expose all the public properties
 exposed by [Worker] along with additional public properties that
 are listed below:
 
-[Worker]:#module/jetpack-core/content/worker
+[Worker]:#module/api-utils/content/worker
 <api name="Symbiont">
 @constructor
 Creates a content symbiont.
 @param options {object}
   Options for the constructor. Includes all the keys that [Worker] constructor
   accepts and few additional:
-[Worker]:#module/jetpack-core/panel
+[Worker]:#module/api-utils/panel
   @prop [frame] {object}
     The host application frame in which the page is loaded.
     If frame is not provided hidden one will be created.
   @prop [contentScriptWhen] {string}
     When to load the content scripts.  Optional.
     Possible values are "start" (default), which loads them as soon as
     the window object for the page has been created, and "ready", which loads
     them once the DOM content of the page has been loaded.
--- a/packages/api-utils/docs/content/worker.md
+++ b/packages/api-utils/docs/content/worker.md
@@ -40,17 +40,17 @@ that occurs in one of the content script
         })
       },
       onMessage: function(msg) {
         console.log(msg);
       }
     });
     worker.postMessage({ name: 'worker'});
 
-[EventEmitter]:#module/jetpack-core/events
+[EventEmitter]:#module/api-utils/events
 <api name="Worker">
 @constructor
 Creates a content worker.
 @param options {object}
 Options for the constructor, with the following keys:
   @prop window {object}
     The content window to create JavaScript sandbox for communication with.
   @prop [contentScriptFile] {string,array}
--- a/packages/api-utils/docs/file.md
+++ b/packages/api-utils/docs/file.md
@@ -61,18 +61,18 @@ The `file` module provides access to the
   An optional string, each character of which describes a characteristic of the
   returned stream.  If the string contains `"r"`, the file is opened in
   read-only mode.  `"w"` opens the file in write-only mode.  `"b"` opens the
   file in binary mode.  If `"b"` is not present, the file is opened in text
   mode, and its contents are assumed to be UTF-8.  If *`mode`* is not given,
   `"r"` is assumed, and the file is opened in read-only text mode.
 @returns {stream}
   A stream that can be used to access or modify the contents of the file.  See
-  [`text-streams`](#module/jetpack-core/text-streams) and
-  [`byte-streams`](#module/jetpack-core/byte-streams) for more information.
+  [`text-streams`](#module/api-utils/text-streams) and
+  [`byte-streams`](#module/api-utils/byte-streams) for more information.
   Opened files should always be closed after use by calling `close` on the
   returned stream.
 </api>
 
 <api name="read">
 @function
   Opens a file in text mode and returns a string containing its entire contents.
 @param path {string}
--- a/packages/api-utils/lib/content/worker.js
+++ b/packages/api-utils/lib/content/worker.js
@@ -289,17 +289,17 @@ const WorkerGlobalScope = AsyncEventEmit
       }
     }
   }
 });
 
 /**
  * Message-passing facility for communication between code running
  * in the content and add-on process.
- * @see https://jetpack.mozillalabs.com/sdk/latest/docs/#module/jetpack-core/content/worker
+ * @see https://jetpack.mozillalabs.com/sdk/latest/docs/#module/api-utils/content/worker
  */
 const Worker = AsyncEventEmitter.compose({
   on: Trait.required,
   _asyncEmit: Trait.required,
   _removeAllListeners: Trait.required,
 
   /**
    * Sends a message to the worker's global scope. Method takes single
--- a/packages/api-utils/lib/list.js
+++ b/packages/api-utils/lib/list.js
@@ -34,17 +34,17 @@
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 "use strict";
 
 const { Trait } = require('traits');
 
 /**
- * @see https://jetpack.mozillalabs.com/sdk/latest/docs/#module/jetpack-core/list
+ * @see https://jetpack.mozillalabs.com/sdk/latest/docs/#module/api-utils/list
  */
 const Iterable = Trait.compose({
   /**
    * Hash map of key-values to iterate over.
    * Note: That this property can be a getter if you need dynamic behavior.
    * @type {Object}
    */
   _keyValueMap: Trait.required,
--- a/packages/api-utils/package.json
+++ b/packages/api-utils/package.json
@@ -1,10 +1,10 @@
 {
-    "name": "jetpack-core",
+    "name": "api-utils",
     "description": "Foundational infrastructure and utilities.",
     "keywords": ["javascript", "engine", "platform", "xulrunner",
                  "jetpack-low-level"],
     "author": "Atul Varma (http://toolness.com/) <atul@mozilla.com>",
     "contributors": [
         "Myk Melez (http://melez.com/) <myk@mozilla.org>",
         "Daniel Aquino <mr.danielaquino@gmail.com>"
     ],
--- a/packages/development-mode/package.json
+++ b/packages/development-mode/package.json
@@ -1,11 +1,11 @@
 {
     "name": "development-mode",
     "description": "Adds Add-on SDK development functionality to a program.",
     "keywords": ["jetpack-low-level"],
     "author": "Atul Varma (http://toolness.com/)",
     "version": "0.10pre",
     "license": "MPL 1.1/GPL 2.0/LGPL 2.1",
     "main": "main",
-    "dependencies": ["jetpack-core", "test-harness"],
+    "dependencies": ["api-utils", "test-harness"],
     "id": "anonid0-development-mode"
 }
--- a/packages/test-harness/package.json
+++ b/packages/test-harness/package.json
@@ -1,9 +1,9 @@
 {
     "name": "test-harness",
     "description": "A harness for running Jetpack tests.",
     "author": "Atul Varma (http://toolness.com/)",
     "keywords": ["jetpack-low-level"],
     "version": "0.10pre",
     "license": "MPL 1.1/GPL 2.0/LGPL 2.1",
-    "dependencies": ["jetpack-core"]
+    "dependencies": ["api-utils"]
 }
--- a/packages/test-harness/tests/test-packaging.js
+++ b/packages/test-harness/tests/test-packaging.js
@@ -40,17 +40,17 @@ exports.testPackagingGetModuleInfo = fun
   test.assertEqual(info.name, 'run-tests',
                    'info.name works');
   test.assertEqual(info.packageName, 'test-harness',
                    'info.packageName works');
   test.assertEqual(info.packageData, packaging.getURLForData(""),
                    'info.packageData works');
   test.assert("observer-service" in info.dependencies);
   test.assertEqual(info.dependencies["observer-service"].url,
-                   "resource://testpkgs-jetpack-core-lib/observer-service.js");
+                   "resource://testpkgs-api-utils-lib/observer-service.js");
   test.assert(info.needsChrome,
               'module "run-tests" needs chrome');
 
   var myInfo = packaging.getModuleInfo(__url__);
   test.assert('dependencies' in myInfo,
               'modules that are tests contain dependency info');
   test.assert(myInfo.needsChrome,
               'modules that are tests contain needsChrome info');
--- a/python-lib/cuddlefish/manifest.py
+++ b/python-lib/cuddlefish/manifest.py
@@ -101,17 +101,17 @@ def scan_module(fn, lines, stderr=sys.st
 
 def scan_package(prefix, resource_url, pkg_name, section, dirname,
                  stderr=sys.stderr):
     manifest = {}
     has_problems = False
     for dirpath, dirnames, filenames in os.walk(dirname):
         for fn in [fn for fn in filenames if fn.endswith(".js")]:
             modname = os.path.splitext(fn)[0]
-            # turn "packages/jetpack-core/lib/content/foo" into "content/foo"
+            # turn "packages/api-utils/lib/content/foo" into "content/foo"
             reldir = dirpath[len(dirname)+1:]
             if reldir:
                 modname = "/".join(reldir.split(os.sep) + [modname])
             absfn = os.path.join(dirpath, fn)
             hashhex = hashlib.sha256(open(absfn,"rb").read()).hexdigest()
             lines = open(absfn).readlines()
             requires, chrome, problems = scan_module(absfn, lines, stderr)
             url = "%s%s.js" % (resource_url, modname)
@@ -155,17 +155,17 @@ def update_manifest_with_fileinfo(deps, 
             if (source,looking_for) in m:
                 # got it
                 i['e10s-adapter'] = m[ (source,looking_for) ]
                 break
 
         for reqname in i.requires:
             # now where will this requirement come from? This code tries to
             # duplicate the behavior of the LocalFileSystem.resolveModule
-            # method in packages/jetpack-core/lib/securable-module.js . Our
+            # method in packages/api-utils/lib/securable-module.js . Our
             # goal is to find a specific .js file, at link time, and record
             # as much information as we can about it in the manifest. Some of
             # this information is destined for the runtime, which will
             # complain if it appears to be loading a module that differs from
             # the one the linker found. The rest of the information is
             # intended for external code-review tools, so the humans reading
             # through the code can confidently exclude common modules that
             # were reviewed earlier.
--- a/python-lib/cuddlefish/packaging.py
+++ b/python-lib/cuddlefish/packaging.py
@@ -3,17 +3,17 @@ import sys
 import re
 
 import simplejson as json
 from cuddlefish.bunch import Bunch
 from manifest import scan_package, update_manifest_with_fileinfo
 
 MANIFEST_NAME = 'package.json'
 
-DEFAULT_LOADER = 'jetpack-core'
+DEFAULT_LOADER = 'api-utils'
 
 DEFAULT_PROGRAM_MODULE = 'main'
 
 DEFAULT_ICON = 'icon.png'
 
 METADATA_PROPS = ['name', 'description', 'keywords', 'author',
                   'contributors', 'license', 'url', 'icon']
 
--- a/python-lib/cuddlefish/preflight.py
+++ b/python-lib/cuddlefish/preflight.py
@@ -35,17 +35,17 @@ def vk_to_jid(vk):
     # even better: windows has a maximum path length limitation of 256
     # characters:
     #  http://msdn.microsoft.com/en-us/library/aa365247%28VS.85%29.aspx
     # (unless all paths are prefixed with "\\?\", I kid you not). The
     # typical install will put add-on code in a directory like:
     # C:\Documents and Settings\<username>\Application Data\Mozilla\Firefox\Profiles\232353483.default\extensions\$JID\...
     # (which is 108 chars long without the $JID).
     # Then the unpacked XPI contains packaged resources like:
-    #  resources/$JID-jetpack-core-lib/main.js   (35 chars plus the $JID)
+    #  resources/$JID-api-utils-lib/main.js   (35 chars plus the $JID)
     #
     # We hash the pubkey into a 160 bit string, base64 encode that (with
     # AB instead of +/ to be path-safe), then bundle it into
     # "jid0-XYZ@jetpack". This gives us 40 characters. The resulting
     # main.js will have a path length of 224 characters, leaving us 32
     # characters of margin.
 
     # if length were no issue, we'd prefer to use this:
--- a/python-lib/cuddlefish/tests/static-files/packages/aardvark/package.json
+++ b/python-lib/cuddlefish/tests/static-files/packages/aardvark/package.json
@@ -1,4 +1,4 @@
 {
   "description": "A package w/ a main module; can be built into an extension.",
-  "dependencies": ["jetpack-core", "barbeque"]
+  "dependencies": ["api-utils", "barbeque"]
 }
--- a/python-lib/cuddlefish/tests/test_manifest.py
+++ b/python-lib/cuddlefish/tests/test_manifest.py
@@ -192,55 +192,55 @@ class Package(unittest.TestCase):
                                               "foo", "lib", path)
         update_manifest_with_fileinfo(["foo"], "foo", manifest)
         self.assertEqual(manifest['resource:foo/bar.js']['e10s-adapter'],
                          'resource:foo/bar-e10s-adapter.js')
         self.assertFalse(manifest['resource:foo/bar-e10s-adapter.js']['e10s-adapter'])
         self.assertFalse(manifest['resource:foo/foo.js']['e10s-adapter'])
 
     def test_bug_596573(self):
-        jp_tests = "packages/jetpack-core/tests"
+        jp_tests = "packages/api-utils/tests"
         manifest, has_problems = scan_package("prefix", "resource:foo",
-                                              "jetpack-core", "tests", jp_tests)
+                                              "api-utils", "tests", jp_tests)
         found = [i.name for i in manifest.values()
                  if i.name == "interoperablejs-read-only/compliance/" +
                                "nested/a/b/c/d"]
         self.failUnless(len(found) == 1)
         
     def test_jetpack_core(self):
-        # this has a side-effect of asserting that all the SDK's jetpack-core
+        # this has a side-effect of asserting that all the SDK's api-utils
         # modules are clean.
-        jp_core = "packages/jetpack-core/lib"
+        jp_core = "packages/api-utils/lib"
         assert os.path.isdir(jp_core) # we expect to be run from the SDK top
         stderr = StringIO()
         manifest, has_problems = scan_package("prefix-", "resource:foo/",
-                                              "jetpack-core", "lib",
+                                              "api-utils", "lib",
                                               jp_core, stderr)
         stderr.seek(0)
         err = stderr.readlines()
         self.failUnlessEqual(err, [], "".join(err))
         self.failUnlessEqual(has_problems, False)
-        update_manifest_with_fileinfo(["jetpack-core"], "jetpack-core",
+        update_manifest_with_fileinfo(["api-utils"], "api-utils",
                                       manifest)
 
         # look at a few samples from the manifest: this depends upon the
         # behavior of other files in the SDK, so when those files change
         # (specifically when they move or add dependencies), this test must
         # be updated
         self.failUnless("resource:foo/tab-browser.js" in manifest, manifest.keys())
         tb = manifest["resource:foo/tab-browser.js"]
         self.failUnlessEqual(tb.chrome, True)
         self.failUnlessEqual(tb.name, "tab-browser")
-        self.failUnlessEqual(tb.packageName, "jetpack-core")
+        self.failUnlessEqual(tb.packageName, "api-utils")
         self.failUnless("window-utils" in tb.requires, tb.requires.values())
         self.failUnlessEqual(tb.requires["window-utils"].url,
                              "resource:foo/window-utils.js")
         self.failUnlessEqual(tb.sectionName, "lib")
         self.failUnlessEqual(tb.zipname,
-                             "resources/prefix-jetpack-core-lib/tab-browser.js")
+                             "resources/prefix-api-utils-lib/tab-browser.js")
         h = tb.hash
         self.failUnless(re.search(r'^[0-9a-f]{64}$', h), h)
         # don't assert the actual value, since that will change each time
         # page-mod.js changes
 
         self.failUnless("resource:foo/api-utils.js" in manifest, manifest.keys())
 
 if __name__ == '__main__':
--- a/python-lib/cuddlefish/tests/test_packaging.py
+++ b/python-lib/cuddlefish/tests/test_packaging.py
@@ -28,13 +28,13 @@ class PackagingTests(unittest.TestCase):
         configs = get_configs('foo', 'bug-588661-files')
         self.assertEqual(configs.build.loader,
                          'resource://guid-foo-lib/foo-loader.js')
 
     def test_basic(self):
         configs = get_configs('aardvark')
         packages = configs.pkg_cfg.packages
 
-        self.assertTrue('jetpack-core' in packages)
+        self.assertTrue('api-utils' in packages)
         self.assertTrue('aardvark' in packages)
-        self.assertTrue('jetpack-core' in packages.aardvark.dependencies)
-        self.assertEqual(packages['jetpack-core'].loader, 'lib/loader.js')
+        self.assertTrue('api-utils' in packages.aardvark.dependencies)
+        self.assertEqual(packages['api-utils'].loader, 'lib/loader.js')
         self.assertTrue(packages.aardvark.main == 'main')
--- a/python-lib/cuddlefish/tests/test_server.py
+++ b/python-lib/cuddlefish/tests/test_server.py
@@ -42,27 +42,27 @@ class UnprivilegedServerTests(unittest.T
 
     def test_api_404(self):
         self.assertEqual(self.request('/api/bleh'), '404 Not Found')
 
     def test_unknown_package_404(self):
         self.assertEqual(self.request('/packages/bleh'), '404 Not Found')
 
     def test_package_file_404(self):
-        self.assertEqual(self.request('/packages/jetpack-core/bleh'),
+        self.assertEqual(self.request('/packages/api-utils/bleh'),
                          '404 Not Found')
 
     def test_package_file_200(self):
-        readme = self.request('/packages/jetpack-core/README.md')
+        readme = self.request('/packages/api-utils/README.md')
         self.assertTrue('Jetpack Core' in readme)
 
     def test_packages_index_json_200(self):
         info = server.json.loads(self.request('/packages/index.json'))
         self.assertEqual(type(info), dict)
-        self.assertTrue('jetpack-core' in info)
+        self.assertTrue('api-utils' in info)
 
     def test_404_on_blank_path(self):
         self.assertEqual(self.request(''), '404 Not Found')
 
     def test_ensure_index_returned_on_root_path(self):
         self.assertTrue('<html>' in self.request('/'))
 
 if __name__ == '__main__':
--- a/static-files/md/dev-guide/best-practices.md
+++ b/static-files/md/dev-guide/best-practices.md
@@ -51,12 +51,12 @@ For more information on the security asp
     3. Potential ways in which the module's functionality might
        be attenuated to reduce authority
 
 The current best practices are illustrated well by the [xhr module
 documentation], the [xhr module source code], and the [xhr module test
 suite].
 
   [Security Roadmap]: #guide/security-roadmap
-  [xhr module documentation]: #module/jetpack-core/xhr
-  [xhr module source code]: packages/jetpack-core/lib/xhr.js
-  [xhr module test suite]: packages/jetpack-core/tests/test-xhr.js
+  [xhr module documentation]: #module/api-utils/xhr
+  [xhr module source code]: packages/api-utils/lib/xhr.js
+  [xhr module test suite]: packages/api-utils/tests/test-xhr.js
   [Chrome Object Wrappers]: https://wiki.mozilla.org/XPConnect_Chrome_Object_Wrapper
--- a/static-files/md/dev-guide/events.md
+++ b/static-files/md/dev-guide/events.md
@@ -1,10 +1,10 @@
 The Add-on SDK supports event-driven programming through its
-[`EventEmitter`](#module/jetpack-core/events) framework. Objects emit events
+[`EventEmitter`](#module/api-utils/events) framework. Objects emit events
 on state changes that might be of interest to add-on code, such as browser
 windows opening, pages loading, network requests completing, and mouse clicks.
 By registering a listener function to an event emitter an add-on can receive
 notifications of these events.
 
 The interface exposed by an event emitter consists of two functions:
 
 * **`on(type, listener)`**: register a listener
--- a/static-files/md/dev-guide/packaging.md
+++ b/static-files/md/dev-guide/packaging.md
@@ -178,9 +178,9 @@ on the left-hand side of this page.
 
 Once you're ready, move on to the next section: [Programs].
 
   [CommonJS Specification]: http://wiki.commonjs.org/wiki/Modules/1.0
   [syntax guide]: http://daringfireball.net/projects/markdown/syntax
   [Markdown]: http://daringfireball.net/projects/markdown/
   [Programs]: #guide/programs
   [Globals]: #guide/globals
-  [unit-test]: #module/jetpack-core/unit-test
+  [unit-test]: #module/api-utils/unit-test
--- a/static-files/md/dev-guide/troubleshooting.md
+++ b/static-files/md/dev-guide/troubleshooting.md
@@ -107,17 +107,17 @@ something like this:
     Using binary at '/Applications/Firefox.app/Contents/MacOS/firefox-bin'.
     Using profile at '/var/folders/FL/FLC+17D+ERKgQe4K+HC9pE+++TI/-Tmp-/tmpu26K_5.mozrunner'.
     .info: My ID is 6724fc1b-3ec4-40e2-8583-8061088b3185
     ..
     3 of 3 tests passed.
     OK
     Total time: 4.036381 seconds
     Program terminated successfully.
-    Testing all available packages: nsjetpack, test-harness, jetpack-core, development-mode.
+    Testing all available packages: nsjetpack, test-harness, api-utils, development-mode.
     Using binary at '/Applications/Firefox.app/Contents/MacOS/firefox-bin'.
     Using profile at '/var/folders/FL/FLC+17D+ERKgQe4K+HC9pE+++TI/-Tmp-/tmp-dzeaA.mozrunner'.
     .........................................................................  
     .........................................................................  
     .........................................................................  
     .........................................................................  
     .........................................................................  
     .........................................................................  
--- a/static-files/md/dev-guide/web-content.md
+++ b/static-files/md/dev-guide/web-content.md
@@ -43,17 +43,17 @@ a set of APIs to support working with co
 tutorial provides a basic guide to these APIs.
 
 The diagram below shows an overview of the main components and their
 relationships. The gray fill represents code written by the add-on developer.
 
 ![Content script overview](media/content-scripting-overview.jpg)
 
 This might sound complicated but it doesn't need to be. The following add-on
-uses the [page-mod](#module/jetpack-core/page-mod) module to replace the
+uses the [page-mod](#module/api-utils/page-mod) module to replace the
 content of any web page in the `.co.uk` domain by executing a content script
 in the context of that page:
 
     var pageMod = require("page-mod");
 
     pageMod.add(new pageMod.PageMod({
       include: ["*.co.uk"],
       contentScriptWhen: 'ready',
@@ -256,17 +256,17 @@ This is the complete add-on script:
     });
 
 This code supplies two content scripts to the panel's constructor in the
 contentScriptFile option: the jQuery library and the script that intercepts
 mouse clicks.
 
 It also supplies a function to the `onMessage` option which passes the message
 parameter (the story URL) into the `addTab` function from the
-[tab-browser](#module/jetpack-core/tab-browser) module. This is the target for
+[tab-browser](#module/api-utils/tab-browser) module. This is the target for
 messages from any content scripts associated with the panel.
 
 This is the content script that intercepts the link clicks:
 
     $(window).click(function (event) {
       var t = event.target;
 
       // Don't intercept the click if it isn't on a link.
--- a/static-files/md/dev-guide/xpi.md
+++ b/static-files/md/dev-guide/xpi.md
@@ -19,35 +19,35 @@ packages, structured like so:
     aardvark/lib/main.js:
       exports.main = function(options, callbacks) {
         console.log("1 + 1 =", require("bar-module").add(1, 1));
         callbacks.quit();
       };
     aardvark/package.json:
       {
         "description": "A package w/ a main module; can be built into an extension.",
-        "dependencies": ["jetpack-core", "barbeque"]
+        "dependencies": ["api-utils", "barbeque"]
+      }
+    api-utils/lib/loader.js:
+      // This module will be imported by the XPCOM harness/boostrapper
+      // via Components.utils.import() and is responsible for creating a
+      // CommonJS module loader.
+    api-utils/package.json:
+      {
+        "description": "A foundational package that provides a CommonJS module loader implementation.",
+        "loader": "lib/loader.js"
       }
     barbeque/lib/bar-module.js:
       exports.add = function add(a, b) {
         return a + b;
       };
     barbeque/package.json:
       {
         "description": "A package used by 'aardvark' as a library."
       }
-    jetpack-core/lib/loader.js:
-      // This module will be imported by the XPCOM harness/boostrapper
-      // via Components.utils.import() and is responsible for creating a
-      // CommonJS module loader.
-    jetpack-core/package.json:
-      {
-        "description": "A foundational package that provides a CommonJS module loader implementation.",
-        "loader": "lib/loader.js"
-      }
 
 Note that our `packages` directory could actually contain more
 packages, too. This doesn't affect the generated XPI, however, because
 only packages cited as dependencies by `aardvark`'s `package.json` will
 ultimately be included in the XPI.
 
 The XPI Template
 ----------------
@@ -76,108 +76,108 @@ auto-generated files:
     >>> document_dir('xpi-output')
     install.rdf:
       <RDF><!-- Extension metadata is here. --></RDF>
     components/harness.js:
       // This file contains XPCOM code that bootstraps an SDK-based add-on
       // by loading its harness-options.json, registering all its resource
       // directories, executing its loader, and then executing its program's
       // main() function.
+    resources/guid-api-utils-lib/:
+    <BLANKLINE>
+    resources/guid-api-utils-lib/loader.js:
+      // This module will be imported by the XPCOM harness/boostrapper
+      // via Components.utils.import() and is responsible for creating a
+      // CommonJS module loader.
     resources/guid-aardvark-lib/:
     <BLANKLINE>
     resources/guid-aardvark-lib/main.js:
       exports.main = function(options, callbacks) {
         console.log("1 + 1 =", require("bar-module").add(1, 1));
         callbacks.quit();
       };
     resources/guid-barbeque-lib/:
     <BLANKLINE>
     resources/guid-barbeque-lib/bar-module.js:
       exports.add = function add(a, b) {
         return a + b;
       };
-    resources/guid-jetpack-core-lib/:
-    <BLANKLINE>
-    resources/guid-jetpack-core-lib/loader.js:
-      // This module will be imported by the XPCOM harness/boostrapper
-      // via Components.utils.import() and is responsible for creating a
-      // CommonJS module loader.
     harness-options.json:
       {
-       "loader": "resource://guid-jetpack-core-lib/loader.js", 
+       "loader": "resource://guid-api-utils-lib/loader.js", 
        "main": "main", 
        "manifest": {
         "resource://guid-aardvark-lib/main.js": {
          "chrome": false, 
          "e10s-adapter": null, 
          "hash": "a592cf3cf924f2c77e0728d97131138fcb7495c77f5202ac55c2e0c77ef903c2", 
          "name": "main", 
          "packageName": "aardvark", 
          "requires": {
           "bar-module": {
            "url": "resource://guid-barbeque-lib/bar-module.js"
           }
          }, 
          "sectionName": "lib", 
          "zipname": "resources/guid-aardvark-lib/main.js"
         }, 
+        "resource://guid-api-utils-lib/loader.js": {
+         "chrome": false, 
+         "e10s-adapter": null, 
+         "hash": "efac9dc700a56e693ac75ab81955c11e6874ddc83d92c11177d643601eaac346", 
+         "name": "loader", 
+         "packageName": "api-utils", 
+         "requires": {}, 
+         "sectionName": "lib", 
+         "zipname": "resources/guid-api-utils-lib/loader.js"
+        }, 
         "resource://guid-barbeque-lib/bar-module.js": {
          "chrome": false, 
          "e10s-adapter": null, 
          "hash": "2515f8623e793571f1dffc4828de14a00a3da9be666147f8cebb3b3f1929e4d6", 
          "name": "bar-module", 
          "packageName": "barbeque", 
          "requires": {}, 
          "sectionName": "lib", 
          "zipname": "resources/guid-barbeque-lib/bar-module.js"
-        }, 
-        "resource://guid-jetpack-core-lib/loader.js": {
-         "chrome": false, 
-         "e10s-adapter": null, 
-         "hash": "efac9dc700a56e693ac75ab81955c11e6874ddc83d92c11177d643601eaac346", 
-         "name": "loader", 
-         "packageName": "jetpack-core", 
-         "requires": {}, 
-         "sectionName": "lib", 
-         "zipname": "resources/guid-jetpack-core-lib/loader.js"
         }
        }, 
        "packageData": {}, 
        "resourcePackages": {
         "guid-aardvark-lib": "aardvark", 
-        "guid-barbeque-lib": "barbeque", 
-        "guid-jetpack-core-lib": "jetpack-core"
+        "guid-api-utils-lib": "api-utils", 
+        "guid-barbeque-lib": "barbeque"
        }, 
        "resources": {
         "guid-aardvark-lib": [
          "resources", 
          "guid-aardvark-lib"
         ], 
+        "guid-api-utils-lib": [
+         "resources", 
+         "guid-api-utils-lib"
+        ], 
         "guid-barbeque-lib": [
          "resources", 
          "guid-barbeque-lib"
-        ], 
-        "guid-jetpack-core-lib": [
-         "resources", 
-         "guid-jetpack-core-lib"
         ]
        }, 
        "rootPaths": [
-        "resource://guid-jetpack-core-lib/", 
+        "resource://guid-api-utils-lib/", 
         "resource://guid-barbeque-lib/", 
         "resource://guid-aardvark-lib/"
        ]
       }
 
 It can be observed from the listing above that the `barbeque` package's `lib`
 directory will be mapped to `resource://guid-barbeque-lib/` when the XPI is
 loaded.
 
-Similarly, the `lib` directories of `jetpack-core` and `aardvark` will be
-mapped to `resource://guid-jetpack-core-lib/` and
+Similarly, the `lib` directories of `api-utils` and `aardvark` will be
+mapped to `resource://guid-api-utils-lib/` and
 `resource://guid-aardvark-lib/`, respectively.
 
 In an actual XPI built by the SDK, the string `"guid"` in these
 examples is a unique identifier that the SDK prepends to all
 `resource:` URIs to namespace the XPI's resources so they don't
 collide with anything else, including other extensions built by the
 SDK and containing the same packages. This GUID is built from the
 [Program ID](#guide/program-id).