diff --git a/CHANGES.md b/CHANGES.md
index 428488f6..9ac00f47 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -3,6 +3,13 @@
 ## 1.0.0 :warning: BACKWARD INCOMPATIBILITY
 
  - 1.0! :cake:
+
+## 0.10.0 :warning: BACKWARD INCOMPATIBILITY
+
+This is an intermediate release for projects transitioning to 1.0.
+This release is version 1.0 but includes many deprecation warnings to
+assist in migration to the new interface.
+
  - :warning: As of `1.0`, Q will require ECMAScript 5. Using `es5-shim`,
    nor even `es5-sham`, is not sufficient to make legacy engines
    compatible because Q requires a WeakMap shim that depends on ES5
@@ -22,11 +29,81 @@
    https://github.com/drses/weak-map.  If you are using Q as a
    `<script>`, this has been embedded in the release.  If you are using
    Q in Node.js, the dependency is taken care of by NPM.
+ - :warning: Withdrew support for SpiderMonkey style generators.  Only
+   ES6 generators are supported.
  - :warning: `Q.nextTick` is no longer supported.  Please use `asap`
    from the `asap` package directly.
  - :warning: `valueOf` has been removed.  Please use `inspect().value`
    instead.
- - :warning: Withdrew support for SpiderMonkey style generators.
+ - :warning: The promise protocol no longer supports "set", "delete",
+   and "apply" operations.  Function application is a special case of
+   "post" with an undefined method name, and an additional "thisp"
+   argument for support of "fbind". The "when" message is now called
+   simply "then".  As such, this version of Q is not compatible with
+   Q-Connection `v0.5`.
+ - `spread` now accepts an optional `progressed` argument.
+ - Promises now support vicious cycle detection.  If a deferred promise
+   ultimately depends upon its own resolution, it will be rejected with
+   the singleton vicious cycle error.
+
+Q now supports a `Promise` constructor with two forms.  `new
+Promise(callback(resolve, reject))` and `new Promise(promiseHandler)`.
+Promise handlers are a new concept and will serve as the basis for
+extensibility.
+
+Added:
+
+-   `Promise` for constructing promises of all kinds
+-   `Promise.cast`
+
+Removed. These have migration shims that simply throw errors.
+
+-   `Q.set`, `promise.set`
+-   `Q.delete`, `promise.delete`
+-   `Q.makePromise` in favor of the new `Promise` constructor and
+    promise handler.
+
+The following methods of `Q` are deprecated in favor of their
+equivalents on the `promise` prototype:
+
+-   `progress`, `thenResolve`, `thenReject`, `isPending`, `isFulfilled`,
+    `isRejected`, `dispatch`, `get`, `post`, `invoke`, `keys`
+
+Other deprecations:
+
+-   `Q.master` is no longer needed
+-   `Q.resolve` in favor of `Q` or `Promise.cast`
+-   `Q.fulfill` in favor of `Q` or `Promise.cast`
+-   `Q.isPromiseAlike` in favor of `Q.isThenable`
+-   `Q.nearer` in favor of `promise.inspect`
+-   `Q.when` in favor of `Q().then`
+-   `Q.fail` and `promise.fail` in favor of `promise.catch`
+-   `Q.fin` and `promise.fin` in favor of `promise.finally`
+-   `Q.mapply` and `promise.mapply` in favor of `promise.post`
+-   `Q.send` and `promise.send` in favor of `promise.invoke`
+-   `Q.mcall` and `promise.mcall` in favor of `promise.invoke`
+-   `Q.promise` in favor of `new Q.Promise` with a function
+-   `Q.makePromise` in favor of `new Q.Promise` with a handler object
+-   `promise.fbind` in favor of `Q.fbind`
+-   `deferred.makeNodeResolver()` in favor of
+    `require("q/node").makeNodeResolver(deferred.resolve)`
+-   `promise.passByCopy()` in favor of `Q.passByCopy(promise)`,
+    provisionally
+
+Node.js wrappers that have been moved into their own module have a
+deprecated interface in Q proper.  Notably, `promise.nodeify` has been
+retained as the only Node.js convenience method in Q and on the promise
+prototype.
+
+-   `denodify`, `nfbind`, `nbind`, `npost`, `ninvoke`
+
+But the following experimental aliases are deprecated and do not exist
+in `q/node`:
+
+-   `nsend` for `ninvoke`
+-   `nmcall` for `ninvoke`
+-   `nmapply` for `npost`
+
 
 ## 0.9.7
 
diff --git a/benchmark/compare-with-callbacks.js b/benchmark/compare-with-callbacks.js
index 97f12989..b14f25d7 100644
--- a/benchmark/compare-with-callbacks.js
+++ b/benchmark/compare-with-callbacks.js
@@ -1,5 +1,6 @@
 "use strict";
 
+var NQ = require("../node");
 var Q = require("../q");
 var fs = require("fs");
 
@@ -18,7 +19,7 @@ suite("A single simple async operation", function () {
 });
 
 suite("A fs.readFile", function () {
-    var denodeified = Q.denodeify(fs.readFile);
+    var denodeified = NQ.denodeify(fs.readFile);
 
     set("iterations", 1000);
     set("delay", 1000);
@@ -27,17 +28,17 @@ suite("A fs.readFile", function () {
         fs.readFile(__filename, done);
     });
 
-    bench("with Q.nfcall", function (done) {
-        Q.nfcall(fs.readFile, __filename).then(done);
+    bench("with NQ.nfcall", function (done) {
+        NQ.nfcall(fs.readFile, __filename).then(done);
     });
 
-    bench("with a Q.denodeify'ed version", function (done) {
+    bench("with a NQ.denodeify'ed version", function (done) {
         denodeified(__filename).then(done);
     });
 
     bench("with manual usage of deferred.makeNodeResolver", function (done) {
         var deferred = Q.defer();
-        fs.readFile(__filename, deferred.makeNodeResolver());
+        fs.readFile(__filename, NQ.makeNodeResolver(deferred.resolve));
         deferred.promise.then(done);
     });
 });
diff --git a/node.js b/node.js
new file mode 100644
index 00000000..b17874bb
--- /dev/null
+++ b/node.js
@@ -0,0 +1,135 @@
+
+var Q = require("./q");
+var NQ = exports;
+
+/**
+ * Creates a Node-style callback that will resolve or reject the deferred
+ * promise.
+ * @returns a nodeback
+ */
+NQ.makeNodeResolver = function (resolve) {
+    return function (error, value) {
+        if (error) {
+            resolve(Q.reject(error));
+        } else if (arguments.length > 2) {
+            resolve(Array.prototype.slice.call(arguments, 1));
+        } else {
+            resolve(value);
+        }
+    };
+};
+
+/**
+ * Passes a continuation to a Node function, which is called with the given
+ * arguments provided as an array, and returns a promise.
+ *
+ *      NQ.nfapply(FS.readFile, [__filename])
+ *      .then(function (content) {
+ *      })
+ *
+ */
+NQ.nfapply = function (callback, args) {
+    var deferred = Q.defer();
+    var nodeArgs = Array.prototype.slice.call(args);
+    nodeArgs.push(NQ.makeNodeResolver(deferred.resolve));
+    Q(callback).fapply(nodeArgs).catch(deferred.reject);
+    return deferred.promise;
+};
+
+/**
+ * Passes a continuation to a Node function, which is called with the given
+ * arguments provided individually, and returns a promise.
+ * @example
+ * Q.nfcall(FS.readFile, __filename)
+ * .then(function (content) {
+ * })
+ *
+ */
+NQ.nfcall = function (callback /*...args*/) {
+    var args = Array.prototype.slice.call(arguments, 1);
+    return NQ.nfapply(callback, args);
+};
+
+/**
+ * Wraps a NodeJS continuation passing function and returns an equivalent
+ * version that returns a promise.
+ * @example
+ * Q.nfbind(FS.readFile, __filename)("utf-8")
+ * .then(console.log)
+ * .done()
+ */
+NQ.nfbind =
+NQ.denodeify = function (callback /*...args*/) {
+    var baseArgs = Array.prototype.slice.call(arguments, 1);
+    return function () {
+        var nodeArgs = baseArgs.concat(Array.prototype.slice.call(arguments));
+        var deferred = Q.defer();
+        nodeArgs.push(NQ.makeNodeResolver(deferred.resolve));
+        Q(callback).fapply(nodeArgs).catch(deferred.reject);
+        return deferred.promise;
+    };
+};
+
+NQ.nbind = function (callback, thisp /*...args*/) {
+    var baseArgs = Array.prototype.slice.call(arguments, 2);
+    return function () {
+        var nodeArgs = baseArgs.concat(Array.prototype.slice.call(arguments));
+        var deferred = Q.defer();
+        nodeArgs.push(NQ.makeNodeResolver(deferred.resolve));
+        function bound() {
+            return callback.apply(thisp, arguments);
+        }
+        Q(bound).fapply(nodeArgs).catch(deferred.reject);
+        return deferred.promise;
+    };
+};
+
+/**
+ * Calls a method of a Node-style object that accepts a Node-style
+ * callback with a given array of arguments, plus a provided callback.
+ * @param object an object that has the named method
+ * @param {String} name name of the method of object
+ * @param {Array} args arguments to pass to the method; the callback
+ * will be provided by Q and appended to these arguments.
+ * @returns a promise for the value or error
+ */
+NQ.npost = function (object, name, nodeArgs) {
+    var deferred = Q.defer();
+    nodeArgs.push(NQ.makeNodeResolver(deferred.resolve));
+    Q(object).dispatch("post", [name, nodeArgs]).catch(deferred.reject);
+    return deferred.promise;
+};
+
+/**
+ * Calls a method of a Node-style object that accepts a Node-style
+ * callback, forwarding the given variadic arguments, plus a provided
+ * callback argument.
+ * @param object an object that has the named method
+ * @param {String} name name of the method of object
+ * @param ...args arguments to pass to the method; the callback will
+ * be provided by Q and appended to these arguments.
+ * @returns a promise for the value or error
+ */
+NQ.ninvoke = function (object, name /*...args*/) {
+    var nodeArgs = Array.prototype.slice.call(arguments, 2);
+    var deferred = Q.defer();
+    nodeArgs.push(NQ.makeNodeResolver(deferred.resolve));
+    Q(object).dispatch("post", [name, nodeArgs]).catch(deferred.reject);
+    return deferred.promise;
+};
+
+/**
+ * If a function would like to support both Node continuation-passing-style and
+ * promise-returning-style, it can end its internal promise chain with
+ * `nodeify(nodeback)`, forwarding the optional nodeback argument.  If the user
+ * elects to use a nodeback, the result will be sent there.  If they do not
+ * pass a nodeback, they will receive the result promise.
+ * @param object a result (or a promise for a result)
+ * @param {Function} nodeback a Node.js-style callback
+ * @returns either the promise or nothing
+ */
+NQ.nodeify = nodeify;
+function nodeify(object, nodeback) {
+    return Q(object).nodeify(nodeback);
+}
+
diff --git a/package.json b/package.json
index bb8e1dcc..8c775202 100644
--- a/package.json
+++ b/package.json
@@ -45,7 +45,7 @@
     "weak-map": "~1.0.0"
   },
   "devDependencies": {
-    "jshint": "~2.1.9",
+    "jshint": "~2.3.0",
     "cover": "*",
     "jasmine-node": "1.11.0",
     "opener": "*",
diff --git a/q.js b/q.js
index 96065319..29891f17 100644
--- a/q.js
+++ b/q.js
@@ -1,7 +1,7 @@
 // vim:ts=4:sts=4:sw=4:
 /*!
  *
- * Copyright 2009-2012 Kris Kowal under the terms of the MIT
+ * Copyright 2009-2013 Kris Kowal under the terms of the MIT
  * license found at http://github.com/kriskowal/q/raw/master/LICENSE
  *
  * With parts by Tyler Close
@@ -25,6 +25,7 @@
  * limitations under the License.
  *
  */
+/*global -WeakMap */
 "use strict";
 
 var hasStacks = false;
@@ -42,15 +43,6 @@ var qFileName;
 var asap = require("asap");
 var WeakMap = require("weak-map");
 
-// used for fallback in "allResolved"
-var noop = function () {};
-
-var object_create = Object.create || function (prototype) {
-    function Type() { }
-    Type.prototype = prototype;
-    return new Type();
-};
-
 function isObject(value) {
     return value === Object(value);
 }
@@ -70,7 +62,7 @@ function makeStackTraceLong(error, promise) {
         error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1
     ) {
         var stacks = [];
-        for (var p = promise; !!p; p = handlers.get(p).became) {
+        for (var p = promise; !!p && handlers.get(p); p = handlers.get(p).became) {
             if (p.stack) {
                 stacks.unshift(p.stack);
             }
@@ -165,7 +157,7 @@ function deprecate(callback, name, alternative) {
             console.warn(name + " is deprecated, use " + alternative +
                          " instead.", new Error("").stack);
         }
-        return callback.apply(callback, arguments);
+        return callback.apply(this, arguments);
     };
 }
 
@@ -173,32 +165,7 @@ function deprecate(callback, name, alternative) {
 
 var handlers = new WeakMap();
 
-/**
- * Constructs a promise for an immediate reference, passes promises through, or
- * coerces promises from different systems.
- * @param value immediate reference or promise
- */
-function Q(value) {
-    // If the object is already a Promise, return it directly.  This enables
-    // the resolve function to both be used to created references from objects,
-    // but to tolerably coerce non-promises to promises.
-    if (isPromise(value)) {
-        return value;
-    }
-
-    // assimilate thenables
-    if (isPromiseAlike(value)) {
-        return coerce(value);
-    } else {
-        return fulfill(value);
-    }
-}
-Q.resolve = Q;
-
-/**
- * TODO
- */
-function getHandler(promise) {
+function inspect(promise) {
     var handler = handlers.get(promise);
     if (!handler || !handler.became) {
         return handler;
@@ -219,13 +186,46 @@ function followHandler(handler) {
 
 var theViciousCycleError = new Error("Can't resolve a promise with itself");
 var theViciousCycleRejection = reject(theViciousCycleError);
-var theViciousCycleHandler = getHandler(theViciousCycleRejection);
+var theViciousCycleHandler = inspect(theViciousCycleRejection);
+
+var thenables = new WeakMap();
+
+/**
+ * Constructs a promise for an immediate reference, passes promises through, or
+ * coerces promises from different systems.
+ * @param value immediate reference or promise
+ */
+module.exports = Q;
+function Q(value) {
+    // If the object is already a Promise, return it directly.  This enables
+    // the resolve function to both be used to created references from objects,
+    // but to tolerably coerce non-promises to promises.
+    if (isPromise(value)) {
+        return value;
+    } else if (isThenable(value)) {
+        if (!thenables.has(value)) {
+            thenables.set(value, new Promise(new ThenableHandler(value)));
+        }
+        return thenables.get(value);
+    } else {
+        return new Promise(new FulfilledHandler(value));
+    }
+}
 
 /**
  * Controls whether or not long stack traces will be on
  */
 Q.longStackSupport = false;
 
+/**
+ * Constructs a rejected promise.
+ * @param reason value describing the failure
+ */
+Q.reject = reject;
+function reject(reason) {
+    return new Promise(new RejectedHandler(reason));
+}
+
 /**
  * Constructs a {promise, resolve, reject} object.
  *
@@ -238,30 +238,10 @@ Q.longStackSupport = false;
  */
 Q.defer = defer;
 function defer() {
-    // if "messages" is an "Array", that indicates that the promise has not yet
-    // been resolved.  If it is "undefined", it has been resolved.  Each
-    // element of the messages array is itself an array of complete arguments to
-    // forward to the resolved promise.  We coerce the resolution value to a
-    // promise using the `resolve` function because it handles both fully
-    // non-thenable values and other thenables gracefully.
-    var messages = [], progressListeners = [];
-
-    var deferred = object_create(defer.prototype);
-    var promise = object_create(Promise.prototype);
 
-    var handler = {
-        dispatch: function (resolve, op, operands) {
-            messages.push([resolve, op, operands]);
-            if (op === "when" && operands[1]) { // progress operand
-                progressListeners.push(operands[1]);
-            }
-        },
-        inspect: function () {
-            return { state: "pending" };
-        }
-    };
-
-    handlers.set(promise, handler);
+    var handler = new DeferredHandler();
+    var promise = new Promise(handler);
+    var deferred = new Deferred(promise);
 
     if (Q.longStackSupport && hasStacks) {
         try {
@@ -277,113 +257,104 @@ function defer() {
         }
     }
 
-    function become(newPromise) {
-        handler.became = theViciousCycleHandler;
-        var newHandler = getHandler(newPromise);
-        handler.became = newHandler;
-
-        handlers.set(promise, newHandler);
-        handler = void 0; // A dead resolver should not retain dead objects
-        promise = void 0;
-
-        messages.forEach(function (message) {
-            // TODO figure out whether this asap is necessary.  makeQ does not
-            // have it.
-            asap(function () {
-                newHandler.dispatch.apply(void 0, message);
-            });
-        });
-
-        messages = void 0;
-        progressListeners = void 0;
-    }
-
-    deferred.promise = promise;
-
-    deferred.resolve = function (value) {
-        if (!messages) {
-            return;
-        }
-
-        become(Q(value));
-    };
-
-    deferred.reject = function (reason) {
-        if (!messages) {
-            return;
-        }
-
-        become(reject(reason));
-    };
-
-    deferred.notify = function (progress) {
-        if (!messages) {
-            return;
-        }
-
-        progressListeners.forEach(function (progressListener) {
-            asap(function () {
-                progressListener(progress);
-            });
-        });
-    };
-
     return deferred;
 }
 
 /**
- * Creates a Node-style callback that will resolve or reject the deferred
- * promise.
- * @returns a nodeback
+ * Turns an array of promises into a promise for an array.  If any of
+ * the promises gets rejected, the whole array is rejected immediately.
+ * @param {Array*} an array (or promise for an array) of values (or
+ * promises for values)
+ * @returns a promise for an array of the corresponding values
  */
-defer.prototype.makeNodeResolver = function () {
-    var self = this;
-    return function (error, value) {
-        if (error) {
-            self.reject(error);
-        } else if (arguments.length > 2) {
-            self.resolve(array_slice(arguments, 1));
+// By Mark Miller
+// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled
+Q.all = all;
+function all(promises) {
+    var countDown = 0;
+    var deferred = defer();
+    Array.prototype.forEach.call(promises, function (promise, index) {
+        var handler;
+        if (
+            isPromise(promise) &&
+            (handler = promise.inspect()).state === "fulfilled"
+        ) {
+            promises[index] = handler.value;
         } else {
-            self.resolve(value);
+            ++countDown;
+            Q(promise).then(
+                function (value) {
+                    promises[index] = value;
+                    if (--countDown === 0) {
+                        deferred.resolve(promises);
+                    }
+                },
+                deferred.reject,
+                function (progress) {
+                    deferred.notify({ index: index, value: progress });
+                }
+            );
         }
-    };
-};
+    });
+    if (countDown === 0) {
+        deferred.resolve(promises);
+    }
+    return deferred.promise;
+}
 
 /**
- * @param resolver {Function} a function that returns nothing and accepts
- * the resolve, reject, and notify functions for a deferred.
- * @returns a promise that may be resolved with the given resolve and reject
- * functions, or rejected by a thrown exception in resolver
+ * @see Promise#allSettled
  */
-Q.promise = promise;
-function promise(resolver) {
-    if (typeof resolver !== "function") {
-        throw new TypeError("resolver must be a function.");
-    }
-    var deferred = defer();
-    try {
-        resolver(deferred.resolve, deferred.reject, deferred.notify);
-    } catch (reason) {
-        deferred.reject(reason);
-    }
-    return deferred.promise;
+Q.allSettled = allSettled;
+function allSettled(promises) {
+    return Q(promises).allSettled();
 }
 
-// XXX experimental.  This method is a way to denote that a local value is
-// serializable and should be immediately dispatched to a remote upon request,
-// instead of passing a reference.
-Q.passByCopy = function (object) {
-    //freeze(object);
-    //passByCopies.set(object, true);
-    return object;
+/**
+ * Returns a promise for the given value (or promised value), some
+ * milliseconds after it resolved. Passes rejections immediately.
+ * @param {Any*} promise
+ * @param {Number} milliseconds
+ * @returns a promise for the resolution of the given promise after milliseconds
+ * time has elapsed since the resolution of the given promise.
+ * If the given promise rejects, that is passed immediately.
+ */
+Q.delay = function (object, timeout) {
+    if (timeout === void 0) {
+        timeout = object;
+        object = void 0;
+    }
+    return Q(object).delay(timeout);
 };
 
-Promise.prototype.passByCopy = function () {
-    //freeze(object);
-    //passByCopies.set(object, true);
-    return this;
+/**
+ * Causes a promise to be rejected if it does not get fulfilled before
+ * some milliseconds time out.
+ * @param {Any*} promise
+ * @param {Number} milliseconds timeout
+ * @param {String} custom error message (optional)
+ * @returns a promise for the resolution of the given promise if it is
+ * fulfilled before the timeout, otherwise rejected.
+ */
+Q.timeout = function (object, ms, message) {
+    return Q(object).timeout(ms, message);
 };
 
+/**
+ * Spreads the values of a promised array of arguments into the
+ * fulfillment callback.
+ * @param fulfilled callback that receives variadic arguments from the
+ * promised array
+ * @param rejected callback that receives the exception if the promise
+ * is rejected.
+ * @returns a promise for the return value or thrown exception of
+ * either callback.
+ */
+Q.spread = spread;
+function spread(value, fulfilled, rejected) {
+    return Q(value).spread(fulfilled, rejected);
+}
+
 /**
  * If two promises eventually fulfill to the same value, promises that value,
  * but otherwise rejects.
@@ -394,11 +365,7 @@ Promise.prototype.passByCopy = function () {
  *
  */
 Q.join = function (x, y) {
-    return Q(x).join(y);
-};
-
-Promise.prototype.join = function (that) {
-    return Q([this, that]).spread(function (x, y) {
+    return Q.spread([x, y], function (x, y) {
         if (x === y) {
             // TODO: "===" should be Object.is or equiv
             return x;
@@ -415,83 +382,240 @@ Promise.prototype.join = function (that) {
  */
 Q.race = race;
 function race(answerPs) {
-    return promise(function(resolve, reject) {
-        // Switch to this once we can assume at least ES5
-        // answerPs.forEach(function(answerP) {
-        //     Q(answerP).then(resolve, reject);
-        // });
-        // Use this in the meantime
-        for (var i = 0, len = answerPs.length; i < len; i++) {
-            Q(answerPs[i]).then(resolve, reject);
-        }
+    return new Promise(function(deferred) {
+        answerPs.forEach(function(answerP) {
+            Q(answerP).then(deferred.resolve, deferred.reject);
+        });
     });
 }
 
-Promise.prototype.race = function () {
-    return this.then(Q.race);
+/**
+ * Calls the promised function in a future turn.
+ * @param object    promise or immediate reference for target function
+ * @param ...args   array of application arguments
+ */
+Q["try"] = function (callback) {
+    return Q(callback).dispatch("post", [void 0, []]);
+};
+
+/**
+ * TODO
+ */
+Q.fapply = function (callback, args) {
+    return Q(callback).dispatch("post", [void 0, args]);
 };
 
 /**
- * Constructs a Promise with a promise descriptor object and optional fallback
- * function.  The descriptor contains methods like when(rejected), get(name),
- * set(name, value), post(name, args), and delete(name), which all
- * return either a value, a promise for a value, or a rejection.  The fallback
- * accepts the operation name, a resolver, and any further arguments that would
- * have been forwarded to the appropriate method above had a method been
- * provided with the proper name.  The API makes no guarantees about the nature
- * of the returned object, apart from that it is usable whereever promises are
- * bought and sold.
+ * TODO
  */
-Q.makePromise = Promise;
-function Promise(descriptor, fallback, inspect) {
-    if (fallback === void 0) {
-        fallback = function (op) {
-            return reject(new Error(
-                "Promise does not support operation: " + op
-            ));
-        };
-    }
-    if (inspect === void 0) {
-        inspect = function () {
-            return {state: "unknown"};
-        };
-    }
+Q.fcall = function (callback /*, ...args*/) {
+    return Q(callback).dispatch("post", [void 0, Array.prototype.slice.call(arguments, 1)]);
+};
+
+/**
+ * Binds the promised function, transforming return values into a fulfilled
+ * promise and thrown errors into a rejected one.
+ * @param object    promise or immediate reference for target function
+ * @param ...args   array of application arguments
+ */
+Q.fbind = function (object /*...args*/) {
+    var promise = Q(object);
+    var args = Array.prototype.slice.call(arguments, 1);
+    return function fbound() {
+        return promise.dispatch("post", [
+            void 0,
+            args.concat(Array.prototype.slice.call(arguments)),
+            this
+        ]);
+    };
+};
 
-    var promise = object_create(Promise.prototype);
+// XXX experimental.  This method is a way to denote that a local value is
+// serializable and should be immediately dispatched to a remote upon request,
+// instead of passing a reference.
+Q.passByCopy = function (object) {
+    //freeze(object);
+    //passByCopies.set(object, true);
+    return object;
+};
 
-    var handler = {
-        dispatch: function (resolve, op, operands) {
+/**
+ * The async function is a decorator for generator functions, turning
+ * them into asynchronous generators.  Although generators are only part
+ * of the newest ECMAScript 6 drafts, this code does not cause syntax
+ * errors in older engines.  This code should continue to work and will
+ * in fact improve over time as the language improves.
+ *
+ * ES6 generators are currently part of V8 version 3.19 with the
+ * --harmony-generators runtime flag enabled.  SpiderMonkey has had them
+ * for longer, but under an older Python-inspired form.  This function
+ * works on both kinds of generators.
+ *
+ * Decorates a generator function such that:
+ *  - it may yield promises
+ *  - execution will continue when that promise is fulfilled
+ *  - the value of the yield expression will be the fulfilled value
+ *  - it returns a promise for the return value (when the generator
+ *    stops iterating)
+ *  - the decorated function returns a promise for the return value
+ *    of the generator or the first rejected promise among those
+ *    yielded.
+ *  - if an error is thrown in the generator, it propagates through
+ *    every following yield until it is caught, or until it escapes
+ *    the generator function altogether, and is translated into a
+ *    rejection for the promise returned by the decorated generator.
+ */
+Q.async = async;
+function async(makeGenerator) {
+    return function () {
+        // when verb is "send", arg is a value
+        // when verb is "throw", arg is an exception
+        function continuer(verb, arg) {
             var result;
             try {
-                if (descriptor[op]) {
-                    result = descriptor[op].apply(promise, operands);
-                } else {
-                    result = fallback.call(promise, op, operands);
-                }
+                result = generator[verb](arg);
             } catch (exception) {
-                result = reject(exception);
+                return reject(exception);
             }
-            if (resolve) {
-                resolve(result);
+            if (result.done) {
+                return result.value;
+            } else {
+                return Q(result.value).then(callback, errback);
             }
-        },
-        inspect: inspect
+        }
+        var generator = makeGenerator.apply(this, arguments);
+        var callback = continuer.bind(continuer, "next");
+        var errback = continuer.bind(continuer, "throw");
+        return callback();
     };
-
-    handlers.set(promise, handler);
-
-    return promise;
 }
 
-Promise.prototype.inspect = function () {
-    return getHandler(this).inspect();
-};
-
-Promise.prototype.toString = function () {
-    return "[object Promise]";
+/**
+ * The spawn function is a small wrapper around async that immediately
+ * calls the generator and also ends the promise chain, so that any
+ * unhandled errors are thrown instead of forwarded to the error
+ * handler. This is useful because it's extremely common to run
+ * generators at the top-level to work with libraries.
+ */
+Q.spawn = spawn;
+function spawn(makeGenerator) {
+    Q.async(makeGenerator)().done();
+}
+
+/**
+ * The promised function decorator ensures that any promise arguments
+ * are settled and passed as values (`this` is also settled and passed
+ * as a value).  It will also ensure that the result of a function is
+ * always a promise.
+ *
+ * @example
+ * var add = Q.promised(function (a, b) {
+ *     return a + b;
+ * });
+ * add(Q(a), Q(B));
+ *
+ * @param {function} callback The function to decorate
+ * @returns {function} a function that has been decorated.
+ */
+Q.promised = promised;
+function promised(callback) {
+    return function () {
+        return spread([this, all(arguments)], function (self, args) {
+            return callback.apply(self, args);
+        });
+    };
+}
+
+
+// Thus begins the section dedicated to the Promise
+
+/**
+ * TODO
+ */
+Q.Promise = Promise;
+function Promise(handler) {
+    if (!(this instanceof Promise)) {
+        return new Promise(handler);
+    }
+    if (typeof handler === "function") {
+        var setup = handler;
+        var deferred = defer();
+        handler = inspect(deferred.promise);
+        try {
+            setup(deferred);
+        } catch (reason) {
+            deferred.reject(reason);
+        }
+    }
+    handlers.set(this, handler);
+}
+
+/**
+ * TODO
+ */
+Promise.cast = function (value) {
+    return Q(value);
+};
+
+/**
+ * @returns whether the given object is a promise.
+ * Otherwise it is a fulfilled value.
+ */
+Q.isPromise = isPromise;
+function isPromise(object) {
+    return isObject(object) && !!handlers.get(object);
+}
+
+/**
+ * TODO
+ */
+Q.isThenable = isThenable;
+function isThenable(object) {
+    return isObject(object) && typeof object.then === "function";
+}
+
+/**
+ * TODO
+ */
+Promise.prototype.inspect = function () {
+    // the second layer captures only the relevant "state" properties of the
+    // handler to prevent leaking the capability to access or alter the
+    // handler.
+    return inspect(this).inspect();
+};
+
+/**
+ * TODO
+ */
+Promise.prototype.isPending = function isPending() {
+    return inspect(this).state === "pending";
+};
+
+/**
+ * TODO
+ */
+Promise.prototype.isFulfilled = function isFulfilled() {
+    return inspect(this).state === "fulfilled";
+};
+
+/**
+ * TODO
+ */
+Promise.prototype.isRejected = function isRejected() {
+    return inspect(this).state === "rejected";
+};
+
+/**
+ * TODO
+ */
+Promise.prototype.toString = function () {
+    return "[object Promise]";
 };
 
-Promise.prototype.then = function (fulfilled, rejected, progressed) {
+/**
+ * TODO
+ */
+Promise.prototype.then = function then(fulfilled, rejected, progressed) {
     var self = this;
     var deferred = defer();
     var done = false;   // ensure the untrusted promise makes at most a
@@ -522,14 +646,14 @@ Promise.prototype.then = function (fulfilled, rejected, progressed) {
     }
 
     asap(function () {
-        getHandler(self).dispatch(function (value) {
+        inspect(self).dispatch(function (value) {
             if (done) {
                 return;
             }
             done = true;
 
             deferred.resolve(_fulfilled(value));
-        }, "when", [function (exception) {
+        }, "then", [function (exception) {
             if (done) {
                 return;
             }
@@ -540,7 +664,7 @@ Promise.prototype.then = function (fulfilled, rejected, progressed) {
     });
 
     // Progress propagator need to be attached in the current tick.
-    getHandler(this).dispatch(void 0, "when", [void 0, function (value) {
+    inspect(this).dispatch(void 0, "then", [void 0, function (value) {
         var newValue;
         var threw = false;
         try {
@@ -563,146 +687,488 @@ Promise.prototype.then = function (fulfilled, rejected, progressed) {
 };
 
 /**
- * Registers an observer on a promise.
- *
- * Guarantees:
- *
- * 1. that fulfilled and rejected will be called only once.
- * 2. that either the fulfilled callback or the rejected callback will be
- *    called, but not both.
- * 3. that fulfilled and rejected will not be called in this turn.
- *
- * @param value      promise or immediate reference to observe
- * @param fulfilled  function to be called with the fulfilled value
- * @param rejected   function to be called with the rejection exception
- * @param progressed function to be called on any progress notifications
- * @return promise for the return value from the invoked callback
+ * TODO
  */
-Q.when = when;
-function when(value, fulfilled, rejected, progressed) {
-    return Q(value).then(fulfilled, rejected, progressed);
-}
-
-Promise.prototype.thenResolve = function (value) {
+Promise.prototype.thenResolve = function thenResolve(value) {
     return this.then(function () { return value; });
 };
 
-Q.thenResolve = function (promise, value) {
-    return Q(promise).thenResolve(value);
-};
-
-Promise.prototype.thenReject = function (reason) {
+/**
+ * TODO
+ */
+Promise.prototype.thenReject = function thenReject(reason) {
     return this.then(function () { throw reason; });
 };
 
-Q.thenReject = function (promise, reason) {
-    return Q(promise).thenReject(reason);
+/**
+ * TODO
+ */
+Promise.prototype.all = function () {
+    return this.then(Q.all);
 };
 
 /**
- * If an object is not a promise, it is as "near" as possible.
- * If a promise is rejected, it is as "near" as possible too.
- * If it’s a fulfilled promise, the fulfillment value is nearer.
- * If it’s a deferred promise and the deferred has been resolved, the
- * resolution is "nearer".
- * @param object
- * @returns most resolved (nearest) form of the object
+ * Turns an array of promises into a promise for an array of their states (as
+ * returned by `inspect`) when they have all settled.
+ * @param {Array[Any*]} values an array (or promise for an array) of values (or
+ * promises for values)
+ * @returns {Array[State]} an array of states for the respective values.
  */
+Promise.prototype.allSettled = function () {
+    return this.then(function (promises) {
+        return all(promises.map(function (promise) {
+            promise = Q(promise);
+            function regardless() {
+                return promise.inspect();
+            }
+            return promise.then(regardless, regardless);
+        }));
+    });
+};
 
-// XXX should we re-do this?
-Q.nearer = nearer;
-function nearer(value) {
-    if (isPromise(value)) {
-        var inspected = value.inspect();
-        if (inspected.state === "fulfilled") {
-            return inspected.value;
-        }
-    }
-    return value;
-}
+/**
+ * TODO
+ */
+Promise.prototype["catch"] = function (rejected) {
+    return this.then(void 0, rejected);
+};
 
 /**
- * @returns whether the given object is a promise.
- * Otherwise it is a fulfilled value.
+ * TODO
  */
-Q.isPromise = isPromise;
-function isPromise(object) {
-    return isObject(object) && !!handlers.get(object);
-}
+Promise.prototype.progress = function (progressed) {
+    return this.then(void 0, void 0, progressed);
+};
 
-Q.isPromiseAlike = isPromiseAlike;
-function isPromiseAlike(object) {
-    return isObject(object) && typeof object.then === "function";
-}
+/**
+ * TODO
+ */
+Promise.prototype["finally"] = function (callback) {
+    callback = Q(callback);
+    return this.then(function (value) {
+        return callback.fcall().then(function () {
+            return value;
+        });
+    }, function (reason) {
+        // TODO attempt to recycle the rejection with "this".
+        return callback.fcall().then(function () {
+            throw reason;
+        });
+    });
+};
 
 /**
- * @returns whether the given object is a pending promise, meaning not
- * fulfilled or rejected.
+ * Terminates a chain of promises, forcing rejections to be
+ * thrown as exceptions.
+ * @param onfulfilled
+ * @param onrejected
+ * @param onprogress
  */
-Q.isPending = isPending;
-function isPending(object) {
-    return Q(object).isPending();
-}
+Promise.prototype.done = function done(fulfilled, rejected, progress) {
+    var onUnhandledError = function (error) {
+        // forward to a future turn so that ``when``
+        // does not catch it and turn it into a rejection.
+        asap(function () {
+            makeStackTraceLong(error, promise);
+            if (Q.onerror) {
+                Q.onerror(error);
+            } else {
+                throw error;
+            }
+        });
+    };
+
+    // Avoid unnecessary `asap` calls due to an unnecessary `then`.
+    var promise = fulfilled || rejected || progress ?
+        this.then(fulfilled, rejected, progress) :
+        this;
+
+    // Bind the error handler to the current Node.js domain
+    if (typeof process === "object" && process && process.domain) {
+        onUnhandledError = process.domain.bind(onUnhandledError);
+    }
 
-Promise.prototype.isPending = function () {
-    return getHandler(this).inspect().state === "pending";
+    promise.then(void 0, onUnhandledError);
 };
 
 /**
- * @returns whether the given object is a value or fulfilled
- * promise.
+ * TODO
  */
-Q.isFulfilled = isFulfilled;
-function isFulfilled(object) {
-    return !isPromise(object) || object.inspect().state === "fulfilled";
-}
+Promise.prototype.dispatch = function (op, args) {
+    var self = this;
+    var deferred = defer();
+    asap(function () {
+        inspect(self).dispatch(deferred.resolve, op, args);
+    });
+    return deferred.promise;
+};
 
-Promise.prototype.isFulfilled = function () {
-    return this.inspect().state === "fulfilled";
+/**
+ * TODO
+ */
+Promise.prototype.get = function (key) {
+    return this.dispatch("get", [key]);
 };
 
 /**
- * @returns whether the given object is a rejected promise.
+ * TODO
  */
-Q.isRejected = isRejected;
-function isRejected(object) {
-    return isPromise(object) && object.inspect().state === "rejected";
-}
+Promise.prototype.post = function (name, args, thisp) {
+    return this.dispatch("post", [name, args, thisp]);
+};
 
-Promise.prototype.isRejected = function () {
-    return this.inspect().state === "rejected";
+/**
+ * TODO
+ */
+Promise.prototype.invoke = function (name /*...args*/) {
+    return this.dispatch("post", [name, Array.prototype.slice.call(arguments, 1)]);
 };
 
-//// BEGIN UNHANDLED REJECTION TRACKING
+/**
+ * TODO
+ */
+Promise.prototype.fapply = function (args) {
+    return this.dispatch("post", [void 0, args]);
+};
 
-// This promise library consumes exceptions thrown in handlers so they can be
-// handled by a subsequent promise.  The exceptions get added to this array when
-// they are created, and removed when they are handled.  Note that in ES6 or
-// shimmed environments, this would naturally be a `Set`.
-var unhandledReasons = [];
-var unhandledRejections = [];
-var unhandledReasonsDisplayed = false;
-var trackUnhandledRejections = true;
-function displayUnhandledReasons() {
-    if (
-        !unhandledReasonsDisplayed &&
-        typeof window !== "undefined" &&
-        !window.Touch &&
-        window.console
-    ) {
-        console.warn("[Q] Unhandled rejection reasons (should be empty):",
-                     unhandledReasons);
-    }
+/**
+ * TODO
+ */
+Promise.prototype.fcall = function (/*...args*/) {
+    return this.dispatch("post", [void 0, Array.prototype.slice.call(arguments)]);
+};
 
-    unhandledReasonsDisplayed = true;
-}
+/**
+ * TODO
+ */
+Promise.prototype.keys = function () {
+    return this.dispatch("keys", []);
+};
 
-function logUnhandledReasons() {
-    for (var i = 0; i < unhandledReasons.length; i++) {
-        var reason = unhandledReasons[i];
-        console.warn("Unhandled rejection reason:", reason);
-    }
-}
+/**
+ * TODO
+ */
+Promise.prototype.spread = function (fulfilled, rejected, progressed) {
+    return this.all().then(function (array) {
+        return fulfilled.apply(void 0, array);
+    }, rejected, progressed);
+};
+
+/**
+ * Causes a promise to be rejected if it does not get fulfilled before
+ * some milliseconds time out.
+ * @param {Number} milliseconds timeout
+ * @param {String} custom error message (optional)
+ * @returns a promise for the resolution of the given promise if it is
+ * fulfilled before the timeout, otherwise rejected.
+ */
+Promise.prototype.timeout = function (ms, message) {
+    var deferred = defer();
+    var timeoutId = setTimeout(function () {
+        deferred.reject(new Error(message || "Timed out after " + ms + " ms"));
+    }, ms);
+
+    this.then(function (value) {
+        clearTimeout(timeoutId);
+        deferred.resolve(value);
+    }, function (exception) {
+        clearTimeout(timeoutId);
+        deferred.reject(exception);
+    }, deferred.notify);
+
+    return deferred.promise;
+};
+
+/**
+ * Returns a promise for the given value (or promised value), some
+ * milliseconds after it resolved. Passes rejections immediately.
+ * @param {Any*} promise
+ * @param {Number} milliseconds
+ * @returns a promise for the resolution of the given promise after milliseconds
+ * time has elapsed since the resolution of the given promise.
+ * If the given promise rejects, that is passed immediately.
+ */
+
+Promise.prototype.delay = function (ms) {
+    return this.then(function (value) {
+        var deferred = defer();
+        setTimeout(function () {
+            deferred.resolve(value);
+        }, ms);
+        return deferred.promise;
+    });
+};
+
+/**
+ * TODO
+ */
+Promise.prototype.nodeify = function (nodeback) {
+    if (nodeback) {
+        this.then(function (value) {
+            asap(function () {
+                nodeback(null, value);
+            });
+        }, function (error) {
+            asap(function () {
+                nodeback(error);
+            });
+        });
+    } else {
+        return this;
+    }
+};
+
+
+// Thus begins the portion dedicated to the deferred
+
+function Deferred(promise) {
+    this.promise = promise;
+    // A deferred has an intrinsic promise, denoted by its hidden handler
+    // property.  The promise property of the deferred may be assigned to a
+    // different promise (as it is in a Queue), but the intrinsic promise does
+    // not change.
+    handlers.set(this, inspect(promise));
+    this.resolve = this.resolve.bind(this);
+    this.reject = this.reject.bind(this);
+    this.notify = this.notify.bind(this);
+}
+
+/**
+ * TODO
+ */
+Deferred.prototype.resolve = function (value) {
+    var handler = inspect(this);
+    if (!handler.messages) {
+        return;
+    }
+    handler.become(Q(value));
+};
+
+/**
+ * TODO
+ */
+Deferred.prototype.reject = function (reason) {
+    var handler = inspect(this);
+    if (!handler.messages) {
+        return;
+    }
+    handler.become(reject(reason));
+};
+
+/**
+ * TODO
+ */
+Deferred.prototype.notify = function (progress) {
+    var handler = inspect(this);
+    if (!handler.messages) {
+        return;
+    }
+    handler.notify(progress);
+};
+
+
+// Thus ends the public interface
+
+// Thus begins the portion dedicated to handlers
+
+function FulfilledHandler(value) {
+    this.value = value;
+}
+
+FulfilledHandler.prototype.state = "fulfilled";
+
+FulfilledHandler.prototype.inspect = function () {
+    return {state: "fulfilled", value: this.value};
+};
+
+FulfilledHandler.prototype.dispatch = function (resolve, op, operands) {
+    var result;
+    if (op === "then" || op === "get" || op === "post" || op === "keys") {
+        try {
+            result = this[op].apply(this, operands);
+        } catch (exception) {
+            result = reject(exception);
+        }
+    } else {
+        var error = new Error(
+            "Fulfilled promises do not support the " + op + " operator"
+        );
+        result = reject(error);
+    }
+    if (resolve) {
+        resolve(result);
+    }
+};
+
+FulfilledHandler.prototype.then = function () {
+    return this.value;
+};
+
+FulfilledHandler.prototype.get = function (name) {
+    return this.value[name];
+};
+
+FulfilledHandler.prototype.post = function (name, args, thisp) {
+    if (name === null || name === void 0) {
+        // function application
+        return this.value.apply(thisp, args);
+    } else {
+        // method invocation
+        return this.value[name].apply(this.value, args);
+    }
+};
+
+FulfilledHandler.prototype.keys = function () {
+    return Object.keys(this.value);
+};
+
+
+function RejectedHandler(reason) {
+    this.reason = reason;
+    // Note that the reason has not been handled.
+    trackRejection(this, reason);
+}
+
+RejectedHandler.prototype.state = "rejected";
+
+RejectedHandler.prototype.inspect = function () {
+    return {state: "rejected", reason: this.reason};
+};
+
+RejectedHandler.prototype.dispatch = function (resolve, op, operands) {
+    var result;
+    if (op === "then") {
+        result = this.then(resolve, operands[0]);
+    } else {
+        result = this;
+    }
+    if (resolve) {
+        resolve(result);
+    }
+};
+
+RejectedHandler.prototype.then = function (resolve, rejected) {
+    if (rejected) {
+        untrackRejection(this);
+    }
+    return rejected ? rejected(this.reason) : this;
+};
+
+
+function DeferredHandler() {
+    // if "messages" is an "Array", that indicates that the promise has not yet
+    // been resolved.  If it is "undefined", it has been resolved.  Each
+    // element of the messages array is itself an array of complete arguments to
+    // forward to the resolved promise.  We coerce the resolution value to a
+    // promise using the `resolve` function because it handles both fully
+    // non-thenable values and other thenables gracefully.
+    this.messages = [];
+    this.progressListeners = [];
+}
+
+DeferredHandler.prototype.state = "pending";
+
+DeferredHandler.prototype.inspect = function () {
+    return {state: "pending"};
+};
+
+DeferredHandler.prototype.dispatch = function (resolve, op, operands) {
+    this.messages.push([resolve, op, operands]);
+    if (op === "then" && operands[1]) { // progress operand
+        this.progressListeners.push(operands[1]);
+    }
+};
+
+DeferredHandler.prototype.become = function (promise) {
+    this.became = theViciousCycleHandler;
+    var handler = inspect(promise);
+    this.became = handler;
+
+    handlers.set(promise, handler);
+    this.promise = void 0;
+
+    this.messages.forEach(function (message) {
+        // TODO figure out whether this asap is necessary.  makeQ does not
+        // have it.
+        asap(function () {
+            var handler = inspect(promise);
+            handler.dispatch.apply(handler, message);
+        });
+    });
+
+    this.messages = void 0;
+    this.progressListeners = void 0;
+};
+
+DeferredHandler.prototype.notify = function (progress) {
+    this.progressListeners.forEach(function (progressListener) {
+        asap(function () {
+            progressListener(progress);
+        });
+    });
+};
+
+
+function ThenableHandler(thenable) {
+    this.thenable = thenable;
+    this.became = null;
+}
+
+ThenableHandler.prototype.cast = function () {
+    if (!this.became) {
+        var deferred = defer();
+        var thenable = this.thenable;
+        asap(function () {
+            try {
+                thenable.then(
+                    deferred.resolve,
+                    deferred.reject,
+                    deferred.notify
+                );
+            } catch (exception) {
+                deferred.reject(exception);
+            }
+        });
+        this.became = inspect(deferred.promise);
+    }
+    return this.became;
+};
+
+ThenableHandler.prototype.dispatch = function (resolve, op, args) {
+    this.cast().dispatch(resolve, op, args);
+};
+
+
+//// BEGIN UNHANDLED REJECTION TRACKING
+
+// This promise library consumes exceptions thrown in handlers so they can be
+// handled by a subsequent promise.  The exceptions get added to this array when
+// they are created, and removed when they are handled.  Note that in ES6 or
+// shimmed environments, this would naturally be a `Set`.
+var unhandledReasons = [];
+var unhandledRejections = [];
+var unhandledReasonsDisplayed = false;
+var trackUnhandledRejections = true;
+function displayUnhandledReasons() {
+    if (
+        !unhandledReasonsDisplayed &&
+        typeof window !== "undefined" &&
+        !window.Touch &&
+        window.console
+    ) {
+        console.warn("[Q] Unhandled rejection reasons (should be empty):",
+                     unhandledReasons);
+    }
+
+    unhandledReasonsDisplayed = true;
+}
+
+function logUnhandledReasons() {
+    for (var i = 0; i < unhandledReasons.length; i++) {
+        var reason = unhandledReasons[i];
+        console.warn("Unhandled rejection reason:", reason);
+    }
+}
 
 function resetUnhandledRejections() {
     unhandledReasons.length = 0;
@@ -766,828 +1232,192 @@ resetUnhandledRejections();
 
 //// END UNHANDLED REJECTION TRACKING
 
-/**
- * Constructs a rejected promise.
- * @param reason value describing the failure
- */
-Q.reject = reject;
-function reject(reason) {
-    var rejection = Promise({
-        "when": function (rejected) {
-            // note that the error has been handled
-            if (rejected) {
-                untrackRejection(this);
-            }
-            return rejected ? rejected(reason) : this;
-        }
-    }, function fallback() {
-        return this;
-    }, function inspect() {
-        return { state: "rejected", reason: reason };
-    });
+// All code before this point will be filtered from stack traces.
+var qEndingLine = captureLine();
 
-    // Note that the reason has not been handled.
-    trackRejection(rejection, reason);
 
-    return rejection;
-}
+// DEPRECATED
 
-/**
- * Constructs a fulfilled promise for an immediate reference.
- * @param value immediate reference
- */
-Q.fulfill = fulfill;
-function fulfill(value) {
-    return Promise({
-        "when": function () {
-            return value;
-        },
-        "get": function (name) {
-            return value[name];
-        },
-        "set": function (name, rhs) {
-            value[name] = rhs;
-        },
-        "delete": function (name) {
-            delete value[name];
-        },
-        "post": function (name, args) {
-            // Mark Miller proposes that post with no name should apply a
-            // promised function.
-            if (name === null || name === void 0) {
-                return value.apply(void 0, args);
-            } else {
-                return value[name].apply(value, args);
-            }
-        },
-        "apply": function (thisp, args) {
-            return value.apply(thisp, args);
-        },
-        "keys": function () {
-            return Object.keys(value);
-        }
-    }, void 0, function inspect() {
-        return { state: "fulfilled", value: value };
-    });
-}
+Q.nextTick = deprecate(asap, "nextTick", "asap package");
 
-/**
- * Converts thenables to Q promises.
- * @param promise thenable promise
- * @returns a Q promise
- */
-function coerce(promise) {
-    var deferred = defer();
-    asap(function () {
-        try {
-            promise.then(deferred.resolve, deferred.reject, deferred.notify);
-        } catch (exception) {
-            deferred.reject(exception);
-        }
-    });
-    return deferred.promise;
-}
+Q.resolve = deprecate(Q, "resolve", "Q");
 
-/**
- * Annotates an object such that it will never be
- * transferred away from this process over any promise
- * communication channel.
- * @param object
- * @returns promise a wrapping of that object that
- * additionally responds to the "isDef" message
- * without a rejection.
- */
-Q.master = master;
-function master(object) {
-    return Promise({
-        "isDef": function () {}
-    }, function fallback(op, args) {
-        return dispatch(object, op, args);
-    }, function () {
-        return Q(object).inspect();
-    });
-}
+Q.fulfill = deprecate(Q, "fulfill", "Q");
 
-/**
- * Spreads the values of a promised array of arguments into the
- * fulfillment callback.
- * @param fulfilled callback that receives variadic arguments from the
- * promised array
- * @param rejected callback that receives the exception if the promise
- * is rejected.
- * @returns a promise for the return value or thrown exception of
- * either callback.
- */
-Q.spread = spread;
-function spread(value, fulfilled, rejected) {
-    return Q(value).spread(fulfilled, rejected);
-}
+Q.isPromiseAlike = deprecate(isThenable, "isPromiseAlike", "isThenable");
 
-Promise.prototype.spread = function (fulfilled, rejected) {
-    return this.all().then(function (array) {
-        return fulfilled.apply(void 0, array);
-    }, rejected);
-};
-
-/**
- * The async function is a decorator for generator functions, turning
- * them into asynchronous generators.  Although generators are only part
- * of the newest ECMAScript 6 drafts, this code does not cause syntax
- * errors in older engines.  This code should continue to work and will
- * in fact improve over time as the language improves.
- *
- * ES6 generators are currently part of V8 version 3.19 with the
- * --harmony-generators runtime flag enabled.  SpiderMonkey has had them
- * for longer, but under an older Python-inspired form.  This function
- * works on both kinds of generators.
- *
- * Decorates a generator function such that:
- *  - it may yield promises
- *  - execution will continue when that promise is fulfilled
- *  - the value of the yield expression will be the fulfilled value
- *  - it returns a promise for the return value (when the generator
- *    stops iterating)
- *  - the decorated function returns a promise for the return value
- *    of the generator or the first rejected promise among those
- *    yielded.
- *  - if an error is thrown in the generator, it propagates through
- *    every following yield until it is caught, or until it escapes
- *    the generator function altogether, and is translated into a
- *    rejection for the promise returned by the decorated generator.
- */
-Q.async = async;
-function async(makeGenerator) {
-    return function () {
-        // when verb is "send", arg is a value
-        // when verb is "throw", arg is an exception
-        function continuer(verb, arg) {
-            var result;
-            try {
-                result = generator[verb](arg);
-            } catch (exception) {
-                return reject(exception);
-            }
-            if (result.done) {
-                return result.value;
-            } else {
-                return when(result.value, callback, errback);
-            }
-        }
-        var generator = makeGenerator.apply(this, arguments);
-        var callback = continuer.bind(continuer, "next");
-        var errback = continuer.bind(continuer, "throw");
-        return callback();
-    };
-}
-
-/**
- * The spawn function is a small wrapper around async that immediately
- * calls the generator and also ends the promise chain, so that any
- * unhandled errors are thrown instead of forwarded to the error
- * handler. This is useful because it's extremely common to run
- * generators at the top-level to work with libraries.
- */
-Q.spawn = spawn;
-function spawn(makeGenerator) {
-    Q.done(Q.async(makeGenerator)());
-}
-
-/**
- * The promised function decorator ensures that any promise arguments
- * are settled and passed as values (`this` is also settled and passed
- * as a value).  It will also ensure that the result of a function is
- * always a promise.
- *
- * @example
- * var add = Q.promised(function (a, b) {
- *     return a + b;
- * });
- * add(Q(a), Q(B));
- *
- * @param {function} callback The function to decorate
- * @returns {function} a function that has been decorated.
- */
-Q.promised = promised;
-function promised(callback) {
-    return function () {
-        return spread([this, all(arguments)], function (self, args) {
-            return callback.apply(self, args);
-        });
-    };
-}
-
-/**
- * sends a message to a value in a future turn
- * @param object* the recipient
- * @param op the name of the message operation, e.g., "when",
- * @param args further arguments to be forwarded to the operation
- * @returns result {Promise} a promise for the result of the operation
- */
-Q.dispatch = dispatch;
-function dispatch(object, op, args) {
-    return Q(object).dispatch(op, args);
-}
-
-Promise.prototype.dispatch = function (op, args) {
-    var deferred = defer();
-    var self = this;
-    asap(function () {
-        getHandler(self).dispatch(deferred.resolve, op, args);
-    });
-    return deferred.promise;
-};
+Q.when = deprecate(function (value, fulfilled, rejected, progressed) {
+    return Q(value).then(fulfilled, rejected, progressed);
+}, "when", "Q(value).then");
 
-/**
- * Gets the value of a property in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of property to get
- * @return promise for the property value
- */
-Q.get = function (object, key) {
-    return Q(object).dispatch("get", [key]);
-};
+Q.fail = deprecate(function (value, rejected) {
+    return Q(value)["catch"](rejected);
+}, "Q.fail", "Q(value).catch");
 
-Promise.prototype.get = function (key) {
-    return this.dispatch("get", [key]);
-};
+Q.fin = deprecate(function (value, regardless) {
+    return Q(value)["finally"](regardless);
+}, "Q.fin", "Q(value).finally");
 
-/**
- * Sets the value of a property in a future turn.
- * @param object    promise or immediate reference for object object
- * @param name      name of property to set
- * @param value     new value of property
- * @return promise for the return value
- */
-Q.set = function (object, key, value) {
-    return Q(object).dispatch("set", [key, value]);
-};
-
-Promise.prototype.set = function (key, value) {
-    return this.dispatch("set", [key, value]);
-};
+Q.progress = deprecate(function (value, rejected) {
+    return Q(value).progress(rejected);
+}, "Q.progress", "Q(value).progress");
 
-/**
- * Deletes a property in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of property to delete
- * @return promise for the return value
- */
-Q.del = // XXX legacy
-Q["delete"] = function (object, key) {
-    return Q(object).dispatch("delete", [key]);
-};
+Q.thenResolve = deprecate(function (promise, value) {
+    return Q(promise).thenResolve(value);
+}, "thenResolve", "Q(value).thenResolve");
 
-Promise.prototype.del = // XXX legacy
-Promise.prototype["delete"] = function (key) {
-    return this.dispatch("delete", [key]);
-};
+Q.thenReject = deprecate(function (promise, reason) {
+    return Q(promise).thenResolve(reason);
+}, "thenResolve", "Q(value).thenResolve");
 
-/**
- * Invokes a method in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of method to invoke
- * @param value     a value to post, typically an array of
- *                  invocation arguments for promises that
- *                  are ultimately backed with `resolve` values,
- *                  as opposed to those backed with URLs
- *                  wherein the posted value can be any
- *                  JSON serializable object.
- * @return promise for the return value
- */
-// bound locally because it is used by other methods
-Q.mapply = // XXX As proposed by "Redsandro"
-Q.post = function (object, name, args) {
-    return Q(object).dispatch("post", [name, args]);
-};
+Q.isPending = deprecate(function (value) {
+    return Q(value).isPending();
+}, "isPending", "Q(value).isPending");
 
-Promise.prototype.mapply = // XXX As proposed by "Redsandro"
-Promise.prototype.post = function (name, args) {
-    return this.dispatch("post", [name, args]);
-};
+Q.isFulfilled = deprecate(function (value) {
+    return Q(value).isFulfilled();
+}, "isFulfilled", "Q(value).isFulfilled");
 
-/**
- * Invokes a method in a future turn.
- * @param object    promise or immediate reference for target object
- * @param name      name of method to invoke
- * @param ...args   array of invocation arguments
- * @return promise for the return value
- */
-Q.send = // XXX Mark Miller's proposed parlance
-Q.mcall = // XXX As proposed by "Redsandro"
-Q.invoke = function (object, name /*...args*/) {
-    return Q(object).dispatch("post", [name, array_slice(arguments, 2)]);
-};
+Q.isRejected = deprecate(function (value) {
+    return Q(value).isRejected();
+}, "isRejected", "Q(value).isRejected");
 
-Promise.prototype.send = // XXX Mark Miller's proposed parlance
-Promise.prototype.mcall = // XXX As proposed by "Redsandro"
-Promise.prototype.invoke = function (name /*...args*/) {
-    return this.dispatch("post", [name, array_slice(arguments, 1)]);
-};
+Q.master = deprecate(function (value) {
+    return value;
+}, "master", "no longer necessary");
 
-/**
- * Applies the promised function in a future turn.
- * @param object    promise or immediate reference for target function
- * @param args      array of application arguments
- */
-Q.fapply = function (object, args) {
-    return Q(object).dispatch("apply", [void 0, args]);
+Q.makePromise = function () {
+    throw new Error("makePromise is no longer supported");
 };
 
-Promise.prototype.fapply = function (args) {
-    return this.dispatch("apply", [void 0, args]);
-};
+Q.dispatch = deprecate(function (value, op, operands) {
+    return Q(value).dispatch(op, operands);
+}, "dispatch", "Q(value).dispatch");
 
-/**
- * Calls the promised function in a future turn.
- * @param object    promise or immediate reference for target function
- * @param ...args   array of application arguments
- */
-Q["try"] =
-Q.fcall = function (object /* ...args*/) {
-    return Q(object).dispatch("apply", [void 0, array_slice(arguments, 1)]);
-};
+Q.get = deprecate(function (object, name) {
+    return Q(object).get(name);
+}, "get", "Q(value).get");
 
-Promise.prototype.fcall = function (/*...args*/) {
-    return this.dispatch("apply", [void 0, array_slice(arguments)]);
-};
+Q.keys = deprecate(function (object) {
+    return Q(object).keys();
+}, "keys", "Q(value).keys");
 
-/**
- * Binds the promised function, transforming return values into a fulfilled
- * promise and thrown errors into a rejected one.
- * @param object    promise or immediate reference for target function
- * @param ...args   array of application arguments
- */
-Q.fbind = function (object /*...args*/) {
-    var promise = Q(object);
-    var args = array_slice(arguments, 1);
-    return function fbound() {
-        return promise.dispatch("apply", [
-            this,
-            args.concat(array_slice(arguments))
-        ]);
-    };
-};
-Promise.prototype.fbind = function (/*...args*/) {
-    var promise = this;
-    var args = array_slice(arguments);
-    return function fbound() {
-        return promise.dispatch("apply", [
-            this,
-            args.concat(array_slice(arguments))
-        ]);
-    };
-};
+Q.post = deprecate(function (object, name, args) {
+    return Q(object).post(name, args);
+}, "post", "Q(value).post");
 
-/**
- * Requests the names of the owned properties of a promised
- * object in a future turn.
- * @param object    promise or immediate reference for target object
- * @return promise for the keys of the eventually settled object
- */
-Q.keys = function (object) {
-    return Q(object).dispatch("keys", []);
-};
+Q.mapply = deprecate(function (object, name, args) {
+    return Q(object).post(name, args);
+}, "post", "Q(value).post");
 
-Promise.prototype.keys = function () {
-    return this.dispatch("keys", []);
-};
+Q.send = deprecate(function (object, name) {
+    return Q(object).post(name, Array.prototype.slice.call(arguments, 2));
+}, "send", "Q(value).invoke");
 
-/**
- * Turns an array of promises into a promise for an array.  If any of
- * the promises gets rejected, the whole array is rejected immediately.
- * @param {Array*} an array (or promise for an array) of values (or
- * promises for values)
- * @returns a promise for an array of the corresponding values
- */
-// By Mark Miller
-// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled
-Q.all = all;
-function all(promises) {
-    return when(promises, function (promises) {
-        var countDown = 0;
-        var deferred = defer();
-        Array.prototype.forEach.call(promises, function (promise, index) {
-            var snapshot;
-            if (
-                isPromise(promise) &&
-                (snapshot = promise.inspect()).state === "fulfilled"
-            ) {
-                promises[index] = snapshot.value;
-            } else {
-                ++countDown;
-                when(
-                    promise,
-                    function (value) {
-                        promises[index] = value;
-                        if (--countDown === 0) {
-                            deferred.resolve(promises);
-                        }
-                    },
-                    deferred.reject,
-                    function (progress) {
-                        deferred.notify({ index: index, value: progress });
-                    }
-                );
-            }
-        });
-        if (countDown === 0) {
-            deferred.resolve(promises);
-        }
-        return deferred.promise;
-    });
-}
+Q.mcall = deprecate(function (object, name) {
+    return Q(object).post(name, Array.prototype.slice.call(arguments, 2));
+}, "mcall", "Q(value).invoke");
 
-Promise.prototype.all = function () {
-    return all(this);
+Q.set = function () {
+    throw new Error("Q.set no longer supported");
 };
 
-/**
- * Waits for all promises to be settled, either fulfilled or
- * rejected.  This is distinct from `all` since that would stop
- * waiting at the first rejection.  The promise returned by
- * `allResolved` will never be rejected.
- * @param promises a promise for an array (or an array) of promises
- * (or values)
- * @return a promise for an array of promises
- */
-Q.allResolved = deprecate(allResolved, "allResolved", "allSettled");
-function allResolved(promises) {
-    return when(promises, function (promises) {
-        promises = promises.map(Q);
-        return when(all(promises.map(function (promise) {
-            return when(promise, noop, noop);
-        })), function () {
-            return promises;
-        });
-    });
-}
-
-Promise.prototype.allResolved = function () {
-    return allResolved(this);
+Q["delete"] = function () {
+    throw new Error("Q.delete no longer supported");
 };
 
-/**
- * @see Promise#allSettled
- */
-Q.allSettled = allSettled;
-function allSettled(promises) {
-    return Q(promises).allSettled();
-}
-
-/**
- * Turns an array of promises into a promise for an array of their states (as
- * returned by `inspect`) when they have all settled.
- * @param {Array[Any*]} values an array (or promise for an array) of values (or
- * promises for values)
- * @returns {Array[State]} an array of states for the respective values.
- */
-Promise.prototype.allSettled = function () {
-    return this.then(function (promises) {
-        return all(promises.map(function (promise) {
-            promise = Q(promise);
-            function regardless() {
-                return promise.inspect();
-            }
-            return promise.then(regardless, regardless);
-        }));
-    });
-};
-
-/**
- * Captures the failure of a promise, giving an oportunity to recover
- * with a callback.  If the given promise is fulfilled, the returned
- * promise is fulfilled.
- * @param {Any*} promise for something
- * @param {Function} callback to fulfill the returned promise if the
- * given promise is rejected
- * @returns a promise for the return value of the callback
- */
-Q.fail = // XXX legacy
-Q["catch"] = function (object, rejected) {
-    return Q(object).then(void 0, rejected);
-};
+Q.nearer = deprecate(function (value) {
+    if (Q.isPromise(value) && value.isFulfilled()) {
+        return value.inspect().value;
+    } else {
+        return value;
+    }
+}, "nearer", "inspect().value (+nuances)");
 
-Promise.prototype.fail = // XXX legacy
-Promise.prototype["catch"] = function (rejected) {
-    return this.then(void 0, rejected);
-};
+Promise.prototype.fail = deprecate(function (rejected) {
+    return this["catch"](rejected);
+}, "fail", "catch");
 
-/**
- * Attaches a listener that can respond to progress notifications from a
- * promise's originating deferred. This listener receives the exact arguments
- * passed to ``deferred.notify``.
- * @param {Any*} promise for something
- * @param {Function} callback to receive any progress notifications
- * @returns the given promise, unchanged
- */
-Q.progress = progress;
-function progress(object, progressed) {
-    return Q(object).then(void 0, void 0, progressed);
-}
-
-Promise.prototype.progress = function (progressed) {
-    return this.then(void 0, void 0, progressed);
-};
+Promise.prototype.fin = deprecate(function (regardless) {
+    return this["finally"](regardless);
+}, "fin", "finally");
 
-/**
- * Provides an opportunity to observe the settling of a promise,
- * regardless of whether the promise is fulfilled or rejected.  Forwards
- * the resolution to the returned promise when the callback is done.
- * The callback can return a promise to defer completion.
- * @param {Any*} promise
- * @param {Function} callback to observe the resolution of the given
- * promise, takes no arguments.
- * @returns a promise for the resolution of the given promise when
- * ``fin`` is done.
- */
-Q.fin = // XXX legacy
-Q["finally"] = function (object, callback) {
-    return Q(object)["finally"](callback);
-};
-
-Promise.prototype.fin = // XXX legacy
-Promise.prototype["finally"] = function (callback) {
-    callback = Q(callback);
-    return this.then(function (value) {
-        return callback.fcall().then(function () {
-            return value;
-        });
-    }, function (reason) {
-        // TODO attempt to recycle the rejection with "this".
-        return callback.fcall().then(function () {
-            throw reason;
-        });
-    });
+Promise.prototype.set = function () {
+    throw new Error("Promise set no longer supported");
 };
 
-/**
- * Terminates a chain of promises, forcing rejections to be
- * thrown as exceptions.
- * @param {Any*} promise at the end of a chain of promises
- * @returns nothing
- */
-Q.done = function (object, fulfilled, rejected, progress) {
-    return Q(object).done(fulfilled, rejected, progress);
+Promise.prototype["delete"] = function () {
+    throw new Error("Promise delete no longer supported");
 };
 
-Promise.prototype.done = function (fulfilled, rejected, progress) {
-    var onUnhandledError = function (error) {
-        // forward to a future turn so that ``when``
-        // does not catch it and turn it into a rejection.
-        asap(function () {
-            makeStackTraceLong(error, promise);
-            if (Q.onerror) {
-                Q.onerror(error);
-            } else {
-                throw error;
-            }
-        });
-    };
-
-    // Avoid unnecessary `asap`ing via an unnecessary `when`.
-    var promise = fulfilled || rejected || progress ?
-        this.then(fulfilled, rejected, progress) :
-        this;
+// alternative proposed by Redsandro, dropped in favor of post to streamline
+// the interface
+Promise.prototype.mapply = deprecate(function (name, args, thisp) {
+    return this.dispatch("post", [name, args, thisp]);
+}, "mapply", "post");
 
-    if (typeof process === "object" && process && process.domain) {
-        onUnhandledError = process.domain.bind(onUnhandledError);
-    }
+Promise.prototype.fbind = deprecate(function () {
+    return Q.fbind.apply(Q, [this].concat(Array.prototype.slice.call(arguments)));
+}, "promise.fbind", "Q.fbind");
 
-    promise.then(void 0, onUnhandledError);
-};
+// alternative proposed by Mark Miller, dropped in favor of invoke
+Promise.prototype.send = deprecate(function () {
+    return this.dispatch("post", [name, Array.prototype.slice.call(arguments, 1)]);
+}, "send", "invoke");
 
-/**
- * Causes a promise to be rejected if it does not get fulfilled before
- * some milliseconds time out.
- * @param {Any*} promise
- * @param {Number} milliseconds timeout
- * @param {String} custom error message (optional)
- * @returns a promise for the resolution of the given promise if it is
- * fulfilled before the timeout, otherwise rejected.
- */
-Q.timeout = function (object, ms, message) {
-    return Q(object).timeout(ms, message);
-};
+// alternative proposed by Redsandro, dropped in favor of invoke
+Promise.prototype.mcall = deprecate(function () {
+    return this.dispatch("post", [name, Array.prototype.slice.call(arguments, 1)]);
+}, "mcall", "invoke");
 
-Promise.prototype.timeout = function (ms, message) {
-    var deferred = defer();
-    var timeoutId = setTimeout(function () {
-        deferred.reject(new Error(message || "Timed out after " + ms + " ms"));
-    }, ms);
+Promise.prototype.passByCopy = deprecate(function (value) {
+    return value;
+}, "passByCopy", "Q.passByCopy");
 
-    this.then(function (value) {
-        clearTimeout(timeoutId);
-        deferred.resolve(value);
-    }, function (exception) {
-        clearTimeout(timeoutId);
-        deferred.reject(exception);
-    }, deferred.notify);
+Q.promise = deprecate(Promise, "promise", "Promise");
 
-    return deferred.promise;
-};
+// Deprecated Node.js shorthands
 
-/**
- * Returns a promise for the given value (or promised value), some
- * milliseconds after it resolved. Passes rejections immediately.
- * @param {Any*} promise
- * @param {Number} milliseconds
- * @returns a promise for the resolution of the given promise after milliseconds
- * time has elapsed since the resolution of the given promise.
- * If the given promise rejects, that is passed immediately.
- */
-Q.delay = function (object, timeout) {
-    if (timeout === void 0) {
-        timeout = object;
-        object = void 0;
+var NQ = require("./node");
+(function () {
+    for (var name in NQ) {
+        Q[name] = NQ[name];
     }
-    return Q(object).delay(timeout);
-};
-
-Promise.prototype.delay = function (timeout) {
-    return this.then(function (value) {
-        var deferred = defer();
-        setTimeout(function () {
-            deferred.resolve(value);
-        }, timeout);
-        return deferred.promise;
-    });
-};
-
-/**
- * Passes a continuation to a Node function, which is called with the given
- * arguments provided as an array, and returns a promise.
- *
- *      Q.nfapply(FS.readFile, [__filename])
- *      .then(function (content) {
- *      })
- *
- */
-Q.nfapply = function (callback, args) {
-    return Q(callback).nfapply(args);
-};
-
-Promise.prototype.nfapply = function (args) {
-    var deferred = defer();
-    var nodeArgs = array_slice(args);
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.fapply(nodeArgs).fail(deferred.reject);
-    return deferred.promise;
-};
-
-/**
- * Passes a continuation to a Node function, which is called with the given
- * arguments provided individually, and returns a promise.
- * @example
- * Q.nfcall(FS.readFile, __filename)
- * .then(function (content) {
- * })
- *
- */
-Q.nfcall = function (callback /*...args*/) {
-    var args = array_slice(arguments, 1);
-    return Q(callback).nfapply(args);
-};
-
-Promise.prototype.nfcall = function (/*...args*/) {
-    var nodeArgs = array_slice(arguments);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.fapply(nodeArgs).fail(deferred.reject);
-    return deferred.promise;
-};
+})();
 
-/**
- * Wraps a NodeJS continuation passing function and returns an equivalent
- * version that returns a promise.
- * @example
- * Q.nfbind(FS.readFile, __filename)("utf-8")
- * .then(console.log)
- * .done()
- */
-Q.nfbind =
-Q.denodeify = function (callback /*...args*/) {
-    var baseArgs = array_slice(arguments, 1);
-    return function () {
-        var nodeArgs = baseArgs.concat(array_slice(arguments));
-        var deferred = defer();
-        nodeArgs.push(deferred.makeNodeResolver());
-        Q(callback).fapply(nodeArgs).fail(deferred.reject);
-        return deferred.promise;
-    };
-};
+Deferred.prototype.makeNodeResolver = deprecate(function () {
+    return NQ.makeNodeResolver(this.resolve);
+}, "makeNodeResolver", "q/node makeNodeResolver");
 
-Promise.prototype.nfbind =
-Promise.prototype.denodeify = function (/*...args*/) {
-    var args = array_slice(arguments);
-    args.unshift(this);
-    return Q.denodeify.apply(void 0, args);
-};
+Promise.prototype.nfapply = deprecate(function (args) {
+    return NQ.nfapply(this, args);
+}, "nfapply", "q/node nfapply");
 
-Q.nbind = function (callback, thisp /*...args*/) {
-    var baseArgs = array_slice(arguments, 2);
-    return function () {
-        var nodeArgs = baseArgs.concat(array_slice(arguments));
-        var deferred = defer();
-        nodeArgs.push(deferred.makeNodeResolver());
-        function bound() {
-            return callback.apply(thisp, arguments);
-        }
-        Q(bound).fapply(nodeArgs).fail(deferred.reject);
-        return deferred.promise;
-    };
-};
-
-Promise.prototype.nbind = function (/*thisp, ...args*/) {
-    var args = array_slice(arguments, 0);
-    args.unshift(this);
-    return Q.nbind.apply(void 0, args);
-};
+Promise.prototype.nfcall = deprecate(function () {
+    return NQ.nfapply(this, Array.prototype.slice.call(arguments));
+}, "nfcall", "q/node nfcall");
 
-/**
- * Calls a method of a Node-style object that accepts a Node-style
- * callback with a given array of arguments, plus a provided callback.
- * @param object an object that has the named method
- * @param {String} name name of the method of object
- * @param {Array} args arguments to pass to the method; the callback
- * will be provided by Q and appended to these arguments.
- * @returns a promise for the value or error
- */
-Q.nmapply = // XXX As proposed by "Redsandro"
-Q.npost = function (object, name, args) {
-    return Q(object).npost(name, args);
-};
+Promise.prototype.nfbind = deprecate(function () {
+    return NQ.nfbind(this, Array.prototype.slice.call(arguments));
+}, "nfbind", "q/node nfbind");
 
-Promise.prototype.nmapply = // XXX As proposed by "Redsandro"
-Promise.prototype.npost = function (name, args) {
-    var nodeArgs = array_slice(args || []);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
-    return deferred.promise;
-};
+Q.nmapply = deprecate(NQ.nmapply, "nmapply", "q/node nmapply");
 
-/**
- * Calls a method of a Node-style object that accepts a Node-style
- * callback, forwarding the given variadic arguments, plus a provided
- * callback argument.
- * @param object an object that has the named method
- * @param {String} name name of the method of object
- * @param ...args arguments to pass to the method; the callback will
- * be provided by Q and appended to these arguments.
- * @returns a promise for the value or error
- */
-Q.nsend = // XXX Based on Mark Miller's proposed "send"
-Q.nmcall = // XXX Based on "Redsandro's" proposal
-Q.ninvoke = function (object, name /*...args*/) {
-    var nodeArgs = array_slice(arguments, 2);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    Q(object).dispatch("post", [name, nodeArgs]).fail(deferred.reject);
-    return deferred.promise;
+var npost = function (name, args) {
+    return NQ.npost(this, name, args);
 };
 
-Promise.prototype.nsend = // XXX Based on Mark Miller's proposed "send"
-Promise.prototype.nmcall = // XXX Based on "Redsandro's" proposal
-Promise.prototype.ninvoke = function (name /*...args*/) {
-    var nodeArgs = array_slice(arguments, 1);
-    var deferred = defer();
-    nodeArgs.push(deferred.makeNodeResolver());
-    this.dispatch("post", [name, nodeArgs]).fail(deferred.reject);
-    return deferred.promise;
-};
+Promise.prototype.nmapply = deprecate(npost, "nmapply", "q/node nmapply");
+Promise.prototype.npost = deprecate(npost, "npost", "q/node npost");
 
-/**
- * If a function would like to support both Node continuation-passing-style and
- * promise-returning-style, it can end its internal promise chain with
- * `nodeify(nodeback)`, forwarding the optional nodeback argument.  If the user
- * elects to use a nodeback, the result will be sent there.  If they do not
- * pass a nodeback, they will receive the result promise.
- * @param object a result (or a promise for a result)
- * @param {Function} nodeback a Node.js-style callback
- * @returns either the promise or nothing
- */
-Q.nodeify = nodeify;
-function nodeify(object, nodeback) {
-    return Q(object).nodeify(nodeback);
-}
+Q.nsend = deprecate(NQ.ninvoke, "nsend", "q/node ninvoke");
+Q.nmcall = deprecate(NQ.ninvoke, "nmcall", "q/node ninvoke");
 
-Promise.prototype.nodeify = function (nodeback) {
-    if (nodeback) {
-        this.then(function (value) {
-            asap(function () {
-                nodeback(null, value);
-            });
-        }, function (error) {
-            asap(function () {
-                nodeback(error);
-            });
-        });
-    } else {
-        return this;
-    }
+var ninvoke = function (name) {
+    return NQ.npost(this, name, Array.prototype.slice.call(arguments, 1));
 };
 
-module.exports = Q;
+Promise.prototype.nsend = deprecate(ninvoke, "nsend", "q/node ninvoke");
+Promise.prototype.nmcall = deprecate(ninvoke, "nmcall", "q/node ninvoke");
+Promise.prototype.ninvoke = deprecate(ninvoke, "ninvoke", "q/node ninvoke");
 
-// All code before this point will be filtered from stack traces.
-var qEndingLine = captureLine();
diff --git a/queue.js b/queue.js
index 1505fd0b..19e23373 100644
--- a/queue.js
+++ b/queue.js
@@ -1,35 +1,25 @@
+"use strict";
 
 var Q = require("./q");
 
 module.exports = Queue;
 function Queue() {
+    if (!(this instanceof Queue)) {
+        return new Queue();
+    }
     var ends = Q.defer();
-    var closed = Q.defer();
-    return {
-        put: function (value) {
-            var next = Q.defer();
-            ends.resolve({
-                head: value,
-                tail: next.promise
-            });
-            ends.resolve = next.resolve;
-        },
-        get: function () {
-            var result = ends.promise.get("head");
-            ends.promise = ends.promise.get("tail");
-            return result.fail(function (error) {
-                closed.resolve(error);
-                throw error;
-            });
-        },
-        closed: closed.promise,
-        close: function (error) {
-            error = error || new Error("Can't get value from closed queue");
-            var end = {head: Q.reject(error)};
-            end.tail = end;
-            ends.resolve(end);
-            return closed.promise;
-        }
+    this.put = function (value) {
+        var next = Q.defer();
+        ends.resolve({
+            head: value,
+            tail: next.promise
+        });
+        ends.resolve = next.resolve;
+    };
+    this.get = function () {
+        var result = ends.promise.get("head");
+        ends.promise = ends.promise.get("tail");
+        return result;
     };
 }
 
diff --git a/spec/q-spec.js b/spec/q-spec.js
index c8bb330b..26def56c 100644
--- a/spec/q-spec.js
+++ b/spec/q-spec.js
@@ -5,6 +5,8 @@
          runs: false */
 
 var Q = require("../q");
+var Queue = require("../queue");
+var NQ = require("../node");
 var asap = require("asap");
 
 var REASON = "this is not an error, but it might show up in the console";
@@ -24,10 +26,10 @@ describe("computing sum of integers using promises", function() {
             array.push(i);
         }
 
-        var pZero = Q.fulfill(0);
+        var pZero = Q(0);
         var result = array.reduce(function (promise, nextVal) {
             return promise.then(function (currentVal) {
-                return Q.fulfill(currentVal + nextVal);
+                return Q(currentVal + nextVal);
             });
         }, pZero);
 
@@ -43,9 +45,9 @@ describe("Q function", function () {
     });
 
     it("should be the identity when given promise", function () {
-        var f = Q.fulfill(5);
+        var f = Q(5);
         var r = Q.reject(new Error("aaargh"));
-        var p = Q.promise(function () { });
+        var p = Q.Promise(function () { });
 
         expect(Q(f)).toBe(f);
         expect(Q(r)).toBe(r);
@@ -53,13 +55,13 @@ describe("Q function", function () {
     });
 });
 
-describe("defer and when", function () {
+describe("defer and then", function () {
 
-    it("resolve before when", function () {
+    it("resolve before then", function () {
         var turn = 0;
         var deferred = Q.defer();
         deferred.resolve(10);
-        var promise = Q.when(deferred.promise, function (value) {
+        var promise = deferred.promise.then(function (value) {
             expect(turn).toEqual(1);
             expect(value).toEqual(10);
         });
@@ -67,11 +69,11 @@ describe("defer and when", function () {
         return promise;
     });
 
-    it("reject before when", function () {
+    it("reject before then", function () {
         var turn = 0;
         var deferred = Q.defer();
         deferred.reject(-1);
-        var promise = Q.when(deferred.promise, function () {
+        var promise = deferred.promise.then(function () {
             expect(true).toBe(false);
         }, function (value) {
             expect(turn).toEqual(1);
@@ -98,7 +100,7 @@ describe("defer and when", function () {
         return promise;
     });
 
-    it("when before reject", function () {
+    it("then before reject", function () {
         var turn = 0;
         var deferred = Q.defer();
         var promise = deferred.promise.then(function () {
@@ -135,7 +137,7 @@ describe("defer and when", function () {
         }
 
         while (++i <= count) {
-            Q.when(deferred.promise, resolve);
+            deferred.promise.then(resolve);
         }
 
         deferred.resolve(resolution);
@@ -146,11 +148,11 @@ describe("defer and when", function () {
     it("observers called even after throw", function () {
         var threw = false;
         var deferred = Q.defer();
-        Q.when(deferred.promise, function () {
+        deferred.promise.then(function () {
             threw = true;
             throw new Error(REASON);
         });
-        var promise = Q.when(deferred.promise, function (value) {
+        var promise = deferred.promise.then(function (value) {
             expect(value).toEqual(10);
         }, function () {
             expect("not").toEqual("here");
@@ -170,7 +172,7 @@ describe("always next tick", function () {
 
     it("generated by `resolve`", function () {
         var turn = 0;
-        var promise = Q.when(Q(), function () {
+        var promise = Q().then(function () {
             expect(turn).toEqual(1);
         });
         turn++;
@@ -179,7 +181,7 @@ describe("always next tick", function () {
 
     it("generated by `reject`", function () {
         var turn = 0;
-        var promise = Q.when(Q.reject(), function () {
+        var promise = Q.reject().then(function () {
             expect(true).toBe(false);
         }, function () {
             expect(turn).toEqual(1);
@@ -190,14 +192,13 @@ describe("always next tick", function () {
 
 });
 
-describe("progress", function () {
+xdescribe("progress", function () {
 
     it("calls a single progress listener", function () {
         var progressed = false;
         var deferred = Q.defer();
 
-        var promise = Q.when(
-            deferred.promise,
+        var promise = deferred.promise.then(
             function () {
                 expect(progressed).toBe(true);
             },
@@ -219,8 +220,7 @@ describe("progress", function () {
         var progressed1 = false;
         var progressed2 = false;
         var deferred = Q.defer();
-        var promise = Q.when(
-            deferred.promise,
+        var promise = deferred.promise.then(
             function () {
                 expect(progressed1).toBe(true);
                 expect(progressed2).toBe(true);
@@ -232,7 +232,7 @@ describe("progress", function () {
                 progressed1 = true;
             }
         );
-        Q.when(deferred.promise, null, null, function () {
+        deferred.promise.then(null, null, function () {
             progressed2 = true;
         });
 
@@ -247,8 +247,7 @@ describe("progress", function () {
         var progressed2 = false;
         var progressed3 = false;
         var deferred = Q.defer();
-        var promise = Q.when(
-            deferred.promise,
+        var promise = deferred.promise.then(
             function () {
                 expect(progressed1).toBe(true);
                 expect(progressed2).toBe(true);
@@ -264,11 +263,11 @@ describe("progress", function () {
 
         Q.onerror = function () { };
 
-        Q.when(deferred.promise, null, null, function () {
+        deferred.promise.then(null, null, function () {
             progressed2 = true;
             throw new Error("just a test, ok if it shows up in the console");
         });
-        Q.when(deferred.promise, null, null, function () {
+        deferred.promise.then(null, null, function () {
             progressed3 = true;
         });
 
@@ -281,8 +280,7 @@ describe("progress", function () {
     it("calls the progress listener even if later rejected", function () {
         var progressed = false;
         var deferred = Q.defer();
-        var promise = Q.when(
-            deferred.promise,
+        var promise = deferred.promise.then(
             function () {
                 expect(true).toBe(false);
             },
@@ -304,8 +302,7 @@ describe("progress", function () {
         var progressValues = [];
         var desiredProgressValues = [{}, {}, "foo", 5];
         var deferred = Q.defer();
-        var promise = Q.when(
-            deferred.promise,
+        var promise = deferred.promise.then(
             function () {
                 for (var i = 0; i < desiredProgressValues.length; ++i) {
                     var desired = desiredProgressValues[i];
@@ -333,7 +330,7 @@ describe("progress", function () {
         var deferred = Q.defer();
         var called = false;
 
-        Q.when(deferred.promise, null, null, function () {
+        deferred.promise.then(null, null, function () {
             called = true;
         });
 
@@ -349,7 +346,7 @@ describe("progress", function () {
         var deferred = Q.defer();
         var called = false;
 
-        Q.when(deferred.promise, null, null, function () {
+        deferred.promise.then(null, null, function () {
             called = true;
         });
 
@@ -367,8 +364,7 @@ describe("progress", function () {
 
         deferred.notify(1);
 
-        var promise = Q.when(
-            deferred.promise,
+        var promise = deferred.promise.then(
             function () {
                 expect(progressValues).toEqual([2]);
             },
@@ -418,8 +414,7 @@ describe("progress", function () {
         var progressed = false;
         var progressContext = {};
         var deferred = Q.defer();
-        var promise = Q.when(
-            deferred.promise,
+        var promise = deferred.promise.then(
             function () {
                 expect(progressed).toBe(true);
                 expect(progressContext).toBe(calledAsFunctionThis);
@@ -443,8 +438,7 @@ describe("progress", function () {
         var progressValueArrays = [];
         var deferred = Q.defer();
 
-        var promise = Q.when(
-            deferred.promise,
+        var promise = deferred.promise.then(
             function () {
                 expect(progressValueArrays).toEqual([[1], [2], [4]]);
             },
@@ -536,62 +530,6 @@ describe("promises for objects", function () {
 
     });
 
-    describe("set", function () {
-
-        it("fulfills a promise", function () {
-            var object = {};
-            return Q(object)
-            .set("a", 1)
-            .then(function (result) {
-                expect(result).toBe(undefined);
-                expect(object.a).toBe(1);
-            });
-        });
-
-        it("propagates a rejection", function () {
-            var exception = new Error("Gah!");
-            return Q.reject(exception)
-            .set("a", 1)
-            .then(function () {
-                expect("frozen over").toBe("quite warm");
-            }, function (_exception) {
-                expect(_exception).toBe(exception);
-            });
-        });
-
-    });
-
-    describe("del", function () {
-
-        it("fulfills a promise", function () {
-            var object = {a: 10};
-            return Q.fcall(function () {
-                return object;
-            })
-            .del("a")
-            .then(function (result) {
-                expect("a" in object).toBe(false);
-                expect(result).toBe(void 0);
-            }, function () {
-                expect("up").toBe("down");
-            });
-        });
-
-        it("propagates a rejection", function () {
-            var exception = new Error("hah-hah");
-            return Q.fcall(function () {
-                throw exception;
-            })
-            .del("a")
-            .then(function () {
-                expect(true).toBe(false);
-            }, function (_exception) {
-                expect(_exception).toBe(exception);
-            });
-        });
-
-    });
-
     describe("post", function () {
 
         it("fulfills a promise", function () {
@@ -601,7 +539,7 @@ describe("promises for objects", function () {
                     return 1 + value;
                 }
             };
-            return Q.when(Q.post(subject, "a", [1]), function (two) {
+            return Q(subject).post("a", [1]).then(function (two) {
                 expect(subject._a).toBe(1);
                 expect(two).toBe(2);
             });
@@ -632,7 +570,7 @@ describe("promises for objects", function () {
                     return this.foo(_bar);
                 }
             };
-            return Q.send(subject, "bar", 1, 2)
+            return Q(subject).invoke("bar", 1, 2)
             .then(function (two) {
                 expect(foo).toEqual(1);
                 expect(two).toEqual(2);
@@ -642,7 +580,7 @@ describe("promises for objects", function () {
         it("is rejected for undefined method", function () {
             var subject = {};
             return Q(subject)
-            .send("foo")
+            .invoke("foo")
             .then(function () {
                 expect("here").toEqual("not here");
             }, function () {
@@ -651,7 +589,7 @@ describe("promises for objects", function () {
 
         it("is rejected for undefined object", function () {
             return Q()
-            .send("foo")
+            .invoke("foo")
             .then(function () {
                 expect("here").toEqual("not here");
             }, function () {
@@ -669,7 +607,8 @@ describe("promises for objects", function () {
         Klass.prototype.notOwn = 1;
 
         it("fulfills a promise", function () {
-            return Q.keys(new Klass(10, 20))
+            return Q(new Klass(10, 20))
+            .keys()
             .then(function (keys) {
                 expect(keys.sort()).toEqual(["a", "b"]);
             });
@@ -718,10 +657,10 @@ describe("promises for functions", function () {
         });
 
         it("chains partial application on a promise for a function", function () {
-            return Q(function (a, b) {
+            return Q.fbind(function (a, b) {
                 return a * b;
-            })
-            .fbind(2)(3)
+            }, 2)
+            (3)
             .then(function (product) {
                 expect(product).toEqual(6);
             });
@@ -840,19 +779,10 @@ describe("inspect", function () {
 
 describe("promise states", function () {
 
-    it("of fulfilled value", function () {
-        expect(Q.isFulfilled(void 0)).toBe(true);
-        expect(Q.isRejected(false)).toBe(false);
-        expect(Q.isPending(true)).toBe(false);
-    });
-
     it("of fulfillment", function () {
         var promise = Q(10);
-        expect(Q.isFulfilled(promise)).toBe(true);
         expect(promise.isFulfilled()).toBe(true);
-        expect(Q.isRejected(promise)).toBe(false);
         expect(promise.isRejected()).toBe(false);
-        expect(Q.isPending(promise)).toBe(false);
         expect(promise.isPending()).toBe(false);
     });
 
@@ -985,7 +915,7 @@ describe("propagation", function () {
         var error = new Error("Foolish mortals!");
         var nextError = new Error("Silly humans!");
         return Q.reject(error)
-        .fail(function () {
+        .catch(function () {
             throw nextError;
         })
         .then(null, function (_error) {
@@ -1003,7 +933,7 @@ describe("propagation", function () {
         });
     });
 
-    it("should propagate progress by default", function () {
+    xit("should propagate progress by default", function () {
         var d = Q.defer();
 
         var progressValues = [];
@@ -1027,7 +957,7 @@ describe("propagation", function () {
         return promise;
     });
 
-    it("should allow translation of progress in the progressback", function () {
+    xit("should allow translation of progress in the progressback", function () {
         var d = Q.defer();
 
         var progressValues = [];
@@ -1111,6 +1041,13 @@ describe("all", function () {
         });
     });
 
+    it("calls thenables lazilly", function () {
+        var promise = Q({then: function () {
+            expect(true).toBe(false);
+        }})
+        return Q.delay(10);
+    });
+
     it("fulfills when passed an sparse array", function () {
         var toResolve = Q.defer();
         var promises = [];
@@ -1288,7 +1225,7 @@ describe("fin", function () {
             var called = false;
 
             return Q("foo")
-            .fin(function () {
+            .finally(function () {
                 called = true;
             })
             .then(function () {
@@ -1298,7 +1235,7 @@ describe("fin", function () {
 
         it("should fulfill with the original value", function () {
             return Q("foo")
-            .fin(function () {
+            .finally(function () {
                 return "bar";
             })
             .then(function (result) {
@@ -1313,11 +1250,11 @@ describe("fin", function () {
                     var promise = Q.delay(250);
 
                     return Q("foo")
-                    .fin(function () {
+                    .finally(function () {
                         return promise;
                     })
                     .then(function (result) {
-                        expect(Q.isPending(promise)).toBe(false);
+                        expect(promise.isPending()).toBe(false);
                         expect(result).toBe("foo");
                     });
                 });
@@ -1326,7 +1263,7 @@ describe("fin", function () {
             describe("that is rejected", function () {
                 it("should reject with this new rejection reason", function () {
                     return Q("foo")
-                    .fin(function () {
+                    .finally(function () {
                         return Q.reject(exception1);
                     })
                     .then(function () {
@@ -1343,7 +1280,7 @@ describe("fin", function () {
         describe("when the callback throws an exception", function () {
             it("should reject with this new exception", function () {
                 return Q("foo")
-                .fin(function () {
+                .finally(function () {
                     throw exception1;
                 })
                 .then(function () {
@@ -1363,7 +1300,7 @@ describe("fin", function () {
             var called = false;
 
             return Q.reject(exception1)
-            .fin(function () {
+            .finally(function () {
                 called = true;
             })
             .then(function () {
@@ -1375,7 +1312,7 @@ describe("fin", function () {
 
         it("should reject with the original reason", function () {
             return Q.reject(exception1)
-            .fin(function () {
+            .finally(function () {
                 return "bar";
             })
             .then(function () {
@@ -1393,7 +1330,7 @@ describe("fin", function () {
                     var promise = Q.delay(250);
 
                     return Q.reject(exception1)
-                    .fin(function () {
+                    .finally(function () {
                         return promise;
                     })
                     .then(function () {
@@ -1401,7 +1338,7 @@ describe("fin", function () {
                     },
                     function (exception) {
                         expect(exception).toBe(exception1);
-                        expect(Q.isPending(promise)).toBe(false);
+                        expect(promise.isPending()).toBe(false);
                     });
                 });
             });
@@ -1409,7 +1346,7 @@ describe("fin", function () {
             describe("that is rejected", function () {
                 it("should reject with the new reason", function () {
                     return Q.reject(exception1)
-                    .fin(function () {
+                    .finally(function () {
                         return Q.reject(exception2);
                     })
                     .then(function () {
@@ -1426,7 +1363,7 @@ describe("fin", function () {
         describe("when the callback throws an exception", function () {
             it("should reject with this new exception", function () {
                 return Q.reject(exception1)
-                .fin(function () {
+                .finally(function () {
                     throw exception2;
                 })
                 .then(function () {
@@ -1454,7 +1391,7 @@ describe("done", function () {
                     called = true;
                 });
 
-                return promise.fail(function () { }).fin(function () {
+                return promise.catch(function () { }).finally(function () {
                     expect(called).toBe(true);
                     expect(returnValue).toBe(undefined);
                 });
@@ -1502,7 +1439,7 @@ describe("done", function () {
                     }
                 );
 
-                return promise.fail(function () { }).fin(function () {
+                return promise.catch(function () { }).finally(function () {
                     expect(called).toBe(true);
                     expect(returnValue).toBe(undefined);
                 });
@@ -1835,7 +1772,7 @@ describe("thenables", function () {
 
     it("assimilates a thenable with progress and fulfillment (using when)", function () {
         var progressValueArrays = [];
-        return Q.when({
+        return Q({
             then: function (fulfilled, rejected, progressed) {
                 asap(function () {
                     progressed(1, 2);
@@ -1912,7 +1849,7 @@ describe("node support", function () {
     describe("nfapply", function () {
 
         it("fulfills with callback result", function () {
-            return Q.nfapply(function (a, b, c, callback) {
+            return NQ.nfapply(function (a, b, c, callback) {
                 callback(null, a + b + c);
             }, [1, 2, 3])
             .then(function (sum) {
@@ -1922,7 +1859,7 @@ describe("node support", function () {
 
         it("rejects with callback error", function () {
             var exception = new Error("That is not your favorite color.");
-            return Q.nfapply(function (a, b, c, callback) {
+            return NQ.nfapply(function (a, b, c, callback) {
                 callback(exception);
             }, [1, 2, 3])
             .then(function () {
@@ -1936,7 +1873,7 @@ describe("node support", function () {
 
     describe("nfcall", function () {
         it("fulfills with callback result", function () {
-            return Q.nfcall(function (a, b, c, callback) {
+            return NQ.nfcall(function (a, b, c, callback) {
                 callback(null, a + b + c);
             }, 1, 2, 3)
             .then(function (sum) {
@@ -1946,7 +1883,7 @@ describe("node support", function () {
 
         it("rejects with callback error", function () {
             var exception = new Error("That is not your favorite color.");
-            return Q.nfcall(function (a, b, c, callback) {
+            return NQ.nfcall(function (a, b, c, callback) {
                 callback(exception);
             }, 1, 2, 3)
             .then(function () {
@@ -1961,7 +1898,7 @@ describe("node support", function () {
     describe("nfbind", function () {
 
         it("mixes partial application with complete application", function () {
-            return Q.nfbind(function (a, b, c, d, callback) {
+            return NQ.nfbind(function (a, b, c, d, callback) {
                 callback(null, a + b + c + d);
             }, 1, 2).call({}, 3, 4)
             .then(function (ten) {
@@ -1974,7 +1911,7 @@ describe("node support", function () {
     describe("nbind", function () {
 
         it("binds this, and mixes partial application with complete application", function () {
-            return Q.nbind(function (a, b, c, callback) {
+            return NQ.nbind(function (a, b, c, callback) {
                 callback(null, this + a + b + c);
             }, 1, 2).call(3 /* effectively ignored as fn bound to 1 */, 4, 5)
             .then(function (twelve) {
@@ -1985,7 +1922,7 @@ describe("node support", function () {
         it("second arg binds this", function() {
             var expectedThis = { test: null };
 
-            return Q.nbind(function(callback) {
+            return NQ.nbind(function(callback) {
                 callback(null, this);
             }, expectedThis).call()
             .then(function(actualThis) {
@@ -1997,21 +1934,21 @@ describe("node support", function () {
     describe("npost", function () {
 
         it("fulfills with callback result", function () {
-            return Q.npost(obj, "method", [1, 2, 3])
+            return NQ.npost(obj, "method", [1, 2, 3])
             .then(function (sum) {
                 expect(sum).toEqual(6);
             });
         });
 
         it("gets the correct thisp", function () {
-            return Q.npost(obj, "thispChecker", [])
+            return NQ.npost(obj, "thispChecker", [])
             .then(function (result) {
                 expect(result).toBe(true);
             });
         });
 
         it("rejects with callback error", function () {
-            return Q.npost(obj, "errorCallbacker", [1, 2, 3])
+            return NQ.npost(obj, "errorCallbacker", [1, 2, 3])
             .then(function () {
                 expect("blue").toBe("no, yellow!");
             }, function (_exception) {
@@ -2020,7 +1957,7 @@ describe("node support", function () {
         });
 
         it("rejects with thrown error", function () {
-            return Q.npost(obj, "errorThrower", [1, 2, 3])
+            return NQ.npost(obj, "errorThrower", [1, 2, 3])
             .then(function () {
                 expect(true).toBe(false);
             }, function (_exception) {
@@ -2029,8 +1966,7 @@ describe("node support", function () {
         });
 
         it("works on promises for objects with Node methods", function () {
-            return Q(obj)
-            .npost("method", [1, 2, 3])
+            return NQ.npost(obj, "method", [1, 2, 3])
             .then(function (sum) {
                 expect(sum).toEqual(6);
             });
@@ -2038,24 +1974,24 @@ describe("node support", function () {
 
     });
 
-    describe("nsend", function () {
+    describe("ninvoke", function () {
 
         it("fulfills with callback result", function () {
-            return Q.nsend(obj, "method", 1, 2, 3)
+            return NQ.ninvoke(obj, "method", 1, 2, 3)
             .then(function (sum) {
                 expect(sum).toEqual(6);
             });
         });
 
         it("gets the correct thisp", function () {
-            return Q.nsend(obj, "thispChecker")
+            return NQ.ninvoke(obj, "thispChecker")
             .then(function (result) {
                 expect(result).toBe(true);
             });
         });
 
         it("rejects with callback error", function () {
-            return Q.nsend(obj, "errorCallbacker", 1, 2, 3)
+            return NQ.ninvoke(obj, "errorCallbacker", 1, 2, 3)
             .then(function () {
                 expect("blue").toBe("no, yellow!");
             }, function (_exception) {
@@ -2064,7 +2000,7 @@ describe("node support", function () {
         });
 
         it("rejects with thrown error", function () {
-            return Q.nsend(obj, "errorThrower", 1, 2, 3)
+            return NQ.ninvoke(obj, "errorThrower", 1, 2, 3)
             .then(function () {
                 expect(true).toBe(false);
             }, function (_exception) {
@@ -2073,8 +2009,7 @@ describe("node support", function () {
         });
 
         it("works on promises for objects with Node methods", function () {
-            return Q(obj)
-            .nsend("method", 1, 2, 3)
+            return NQ.ninvoke(obj, "method", 1, 2, 3)
             .then(function (sum) {
                 expect(sum).toEqual(6);
             });
@@ -2086,7 +2021,7 @@ describe("node support", function () {
 
         it("fulfills a promise with a single callback argument", function () {
             var deferred = Q.defer();
-            var callback = deferred.makeNodeResolver();
+            var callback = NQ.makeNodeResolver(deferred.resolve);
             callback(null, 10);
             return deferred.promise.then(function (value) {
                 expect(value).toBe(10);
@@ -2095,7 +2030,7 @@ describe("node support", function () {
 
         it("fulfills a promise with multiple callback arguments", function () {
             var deferred = Q.defer();
-            var callback = deferred.makeNodeResolver();
+            var callback = NQ.makeNodeResolver(deferred.resolve);
             callback(null, 10, 20);
             return deferred.promise.then(function (value) {
                 expect(value).toEqual([10, 20]);
@@ -2104,7 +2039,7 @@ describe("node support", function () {
 
         it("rejects a promise", function () {
             var deferred = Q.defer();
-            var callback = deferred.makeNodeResolver();
+            var callback = NQ.makeNodeResolver(deferred.resolve);
             var exception = new Error("Holy Exception of Anitoch");
             callback(exception);
             return deferred.promise.then(function () {
@@ -2171,24 +2106,24 @@ describe("isPromise", function () {
     });
 });
 
-describe("isPromiseAlike", function () {
+describe("isThenable", function () {
     it("returns true if passed a promise like object", function () {
-        expect(Q.isPromiseAlike(Q(10))).toBe(true);
-        expect(Q.isPromiseAlike({
+        expect(Q.isThenable(Q(10))).toBe(true);
+        expect(Q.isThenable({
             then: function () {}
         })).toBe(true);
     });
 
     it("returns false if not passed a promise like object", function () {
-        expect(Q.isPromiseAlike(undefined)).toBe(false);
-        expect(Q.isPromiseAlike(null)).toBe(false);
-        expect(Q.isPromiseAlike(10)).toBe(false);
-        expect(Q.isPromiseAlike("str")).toBe(false);
-        expect(Q.isPromiseAlike("")).toBe(false);
-        expect(Q.isPromiseAlike(true)).toBe(false);
-        expect(Q.isPromiseAlike(false)).toBe(false);
-        expect(Q.isPromiseAlike({})).toBe(false);
-        expect(Q.isPromiseAlike(function () {})).toBe(false);
+        expect(Q.isThenable(undefined)).toBe(false);
+        expect(Q.isThenable(null)).toBe(false);
+        expect(Q.isThenable(10)).toBe(false);
+        expect(Q.isThenable("str")).toBe(false);
+        expect(Q.isThenable("")).toBe(false);
+        expect(Q.isThenable(true)).toBe(false);
+        expect(Q.isThenable(false)).toBe(false);
+        expect(Q.isThenable({})).toBe(false);
+        expect(Q.isThenable(function () {})).toBe(false);
     });
 });
 
@@ -2336,21 +2271,24 @@ describe("stack trace formatting", function () {
     it("doesn't mangle a stack trace that gets handled twice", function () {
         var d1 = Q.defer();
         var d2 = Q.defer();
-        var captured = [];
+        var captured = new Queue();
         d1.promise.done();
         d2.promise.done();
 
         Q.onerror = function (err) {
-            captured.push(err.stack);
+            captured.put(err.stack);
         };
 
         var error = new Error("boom!");
         d1.reject(error);
         d2.reject(error);
 
-        return Q.all([d1.promise.fail(function () {}), d2.promise.fail(function () { })])
-        .then(function () {
-            expect(captured[0]).toEqual(captured[1]);
+        var a = captured.get();
+        var b = captured.get();
+
+        return Q.spread([a, b], function (a, b) {
+            expect(a).toBeDefined();
+            expect(a).toEqual(b);
         });
     });
 });
@@ -2359,10 +2297,10 @@ describe("possible regressions", function () {
 
     describe("gh-9", function () {
         it("treats falsy values as resolved values without error", function () {
-            expect(Q.isPending(null)).toEqual(false);
-            expect(Q.isPending(void 0)).toEqual(false);
-            expect(Q.isPending(false)).toEqual(false);
-            expect(Q.isPending()).toEqual(false);
+            expect(Q(null).isPending()).toEqual(false);
+            expect(Q(void 0).isPending()).toEqual(false);
+            expect(Q(false).isPending()).toEqual(false);
+            expect(Q().isPending()).toEqual(false);
         });
     });
 
@@ -2412,8 +2350,15 @@ describe("possible regressions", function () {
 
     describe("gh-75", function () {
         it("does not double-resolve misbehaved promises", function () {
-            var badPromise = Q.makePromise({
-                post: function () { return "hello"; }
+            var badPromise = new Q.Promise({
+                dispatch: function (resolve) {
+                    if (resolve) {
+                        resolve();
+                    }
+                },
+                inspect: function () {
+                    return null;
+                }
             });
 
             var resolutions = 0;
@@ -2421,7 +2366,7 @@ describe("possible regressions", function () {
                 ++resolutions;
             }
 
-            return Q.when(badPromise, onResolution, onResolution).then(function () {
+            return badPromise.then(onResolution, onResolution).then(function () {
                 expect(resolutions).toBe(1);
             });
         });
@@ -2443,9 +2388,12 @@ describe("unhandled rejection reporting", function () {
     });
 
     it("doesn't report when you chain off a rejection", function () {
-        return Q.reject("this will be handled").get("property").fail(function () {
+        return Q.reject("this will be handled")
+        .get("property")
+        .catch(function () {
             // now it should be handled.
-        }).fin(function() {
+        })
+        .finally(function() {
             expect(Q.getUnhandledReasons().length).toEqual(0);
         });
     });
diff --git a/spec/queue-spec.js b/spec/queue-spec.js
index 4cec14e2..87723515 100644
--- a/spec/queue-spec.js
+++ b/spec/queue-spec.js
@@ -101,80 +101,5 @@ describe("queue", function () {
         ]);
     });
 
-    it("should close", function () {
-
-        var queue = Queue();
-
-        Q.try(function () {
-            return Q.delay(20).then(function () {
-                queue.put(1);
-            })
-        })
-        .then(function () {
-            return Q.delay(20).then(function () {
-                queue.put(2);
-            })
-        })
-        .then(function () {
-            queue.close();
-        })
-        .done();
-
-        return Q.try(function () {
-            return queue.get()
-            .then(function (value) {
-                expect(value).toBe(1);
-            });
-        })
-        .then(function () {
-            return queue.get()
-            .then(function (value) {
-                expect(value).toBe(2);
-            });
-        })
-        .then(function () {
-            return queue.get()
-            .then(function (value) {
-                expect(false).toBe(true); // should not get here
-            });
-        })
-        .catch(function (error) {
-            expect(error.message).toBe("Can't get value from closed queue");
-            return queue.get();
-        })
-        .catch(function (error) {
-            expect(error.message).toBe("Can't get value from closed queue");
-        })
-        .then(function () {
-            return queue.closed;
-        })
-        .then(function (error) {
-            expect(error.message).toBe("Can't get value from closed queue");
-        })
-    });
-
-    it("should close with alternate error", function () {
-
-        var queue = Queue();
-        queue.close(new Error("Alternate reason"));
-
-        return Q.try(function () {
-            return queue.get();
-        })
-        .catch(function (error) {
-            expect(error.message).toBe("Alternate reason");
-            return queue.get();
-        })
-        .catch(function (error) {
-            expect(error.message).toBe("Alternate reason");
-        })
-        .then(function () {
-            return queue.closed;
-        })
-        .then(function (error) {
-            expect(error.message).toBe("Alternate reason");
-        })
-    });
-
 });