fix(unwrap): pass through non-Thenables before throwing

Closes #518

This makes unwrap a lot more useful in the case when the
calling code may or may not be in a different vat than the supplied
argument.

packages/eventual-send/src/index.js

@@ -310,12 +310,25 @@ export function makeHandledPromise(Promise) {
     // handled. Or, at least, the ability to tell given that the
     // promise is already fulfilled.
     unwrap(value) {
+      // This check for Thenable is safe, since in a remote-object
+      // environment, our comms system will defend against remote
+      // objects being represented as a tricky local Proxy, otherwise
+      // it is guaranteed to be local and therefore synchronous enough.
+      if (Object(value) !== value || !('then' in value)) {
+        // Not a Thenable, so return it.
+        // This means that local objects will pass through without error.
+        return value;
+      }
+
+      // Try to look up the HandledPromise.
       ensureMaps();
       const pr = presenceToPromise.get(value) || value;
+
+      // Find the fulfilled presence for that HandledPromise.
       const presence = promiseToPresence.get(pr);
       if (!presence) {
         throw TypeError(
-          `Value is not a presence nor a HandledPromise resolved to a presence`,
+          `Value is a Thenble but not a HandledPromise fulfilled to a presence`,
         );
       }
       return presence;

packages/eventual-send/test/test-hp.js

@@ -48,10 +48,29 @@ test('chained properties', async t => {
 
 test('HandledPromise.unwrap', async t => {
   try {
+    for (const [val, desc] of [
+      [{}, 'object'],
+      [true, 'true'],
+      [false, 'false'],
+      [undefined, 'undefined'],
+      [null, 'null'],
+    ]) {
+      t.equal(HandledPromise.unwrap(val), val, `unwrapped ${desc} is equal`);
+    }
+    const t0 = {
+      then() {},
+    };
+    t.throws(
+      () => HandledPromise.unwrap(t0),
+      TypeError,
+      `unwrapped thenable object throws`,
+    );
+    const t1 = () => {};
+    t1.then = () => {};
     t.throws(
-      () => HandledPromise.unwrap({}),
+      () => HandledPromise.unwrap(t1),
       TypeError,
-      `unwrapped non-presence throws`,
+      `unwrapped thenable function throws`,
     );
     const p0 = new Promise(_ => {});
     t.throws(