@endo/eventual-send 0.15.1 → 0.15.4

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+### [0.15.4](https://github.com/endojs/endo/compare/@endo/eventual-send@0.15.3...@endo/eventual-send@0.15.4) (2022-06-11)
+
+
+### Bug Fixes
+
+* **eventual-send:** no implicit rejection silencing; just harden ([ca07d81](https://github.com/endojs/endo/commit/ca07d8150fd1e12b9e90505a7c06ada6b25d0743))
+* **eventual-send:** use `!Object.is(a, b)` instead of `a !== b` for NaNs ([2b7e418](https://github.com/endojs/endo/commit/2b7e4189182dcac17832bbdcfb6ac56e32fee456))
+
+
+
+### [0.15.3](https://github.com/endojs/endo/compare/@endo/eventual-send@0.15.2...@endo/eventual-send@0.15.3) (2022-04-15)
+
+**Note:** Version bump only for package @endo/eventual-send
+
+
+
+
+
+### [0.15.2](https://github.com/endojs/endo/compare/@endo/eventual-send@0.15.1...@endo/eventual-send@0.15.2) (2022-04-14)
+
+**Note:** Version bump only for package @endo/eventual-send
+
+
+
+
+
 ### [0.15.1](https://github.com/endojs/endo/compare/@endo/eventual-send@0.15.0...@endo/eventual-send@0.15.1) (2022-04-13)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@endo/eventual-send",
-  "version": "0.15.1",
+  "version": "0.15.4",
   "description": "Extend a Promise class to implement the eventual-send API",
   "type": "module",
   "main": "src/no-shim.js",
@@ -27,8 +27,8 @@
   },
   "homepage": "https://github.com/endojs/endo#readme",
   "devDependencies": {
-    "@endo/lockdown": "^0.1.11",
-    "@endo/ses-ava": "^0.2.23",
+    "@endo/lockdown": "^0.1.14",
+    "@endo/ses-ava": "^0.2.26",
     "ava": "^3.12.1",
     "c8": "^7.7.3",
     "tsd": "^0.19.1"
@@ -62,5 +62,5 @@
     ],
     "timeout": "2m"
   },
-  "gitHead": "ada5203fd64e6828dca74895fd74588e08925d97"
+  "gitHead": "7be9306df5e5eae280134cbbaf0d3886b4e51536"
 }

package/src/handled-promise.js

@@ -26,6 +26,7 @@ const {
   getPrototypeOf,
   setPrototypeOf,
   isFrozen,
+  is: objectIs,
 } = Object;
 
 const { apply, construct } = Reflect;
@@ -93,7 +94,7 @@ export const makeHandledPromise = () => {
     if (presence) {
       // Presences are final, so it is ok to propagate
       // this upstream.
-      while (target !== p) {
+      while (!objectIs(target, p)) {
         const parent = forwardedPromiseToPromise.get(target);
         forwardedPromiseToPromise.delete(target);
         promiseToPendingHandler.delete(target);
@@ -104,7 +105,7 @@ export const makeHandledPromise = () => {
       // We propagate p and remove all other pending handlers
       // upstream.
       // Note that everything except presences is covered here.
-      while (target !== p) {
+      while (!objectIs(target, p)) {
         const parent = forwardedPromiseToPromise.get(target);
         forwardedPromiseToPromise.set(target, p);
         promiseToPendingHandler.delete(target);
@@ -237,7 +238,7 @@ export const makeHandledPromise = () => {
           targetP = presenceToPromise.get(value);
         }
         // Ensure our data structure is a proper tree (avoid cycles).
-        if (targetP && targetP !== handledP) {
+        if (targetP && !objectIs(targetP, handledP)) {
           forwardedPromiseToPromise.set(handledP, targetP);
         } else {
           forwardedPromiseToPromise.delete(handledP);
@@ -246,11 +247,6 @@ export const makeHandledPromise = () => {
         // Remove stale pending handlers, set to canonical form.
         shorten(handledP);
 
-        // Ensure our pendingHandler is cleaned up if not already.
-        if (promiseToPendingHandler.has(handledP)) {
-          handledP.then(_ => promiseToPendingHandler.delete(handledP));
-        }
-
         // Finish the resolution.
         superResolve(value);
         resolved = true;
@@ -259,10 +255,11 @@ export const makeHandledPromise = () => {
         // We're resolved, so forward any postponed operations to us.
         continueForwarding();
       };
-      handledReject = err => {
+      handledReject = reason => {
         if (resolved) {
           return;
         }
+        harden(reason);
         assert(
           !forwardedPromiseToPromise.has(handledP),
           X`internal: already forwarded`,
@@ -270,7 +267,7 @@ export const makeHandledPromise = () => {
         );
         promiseToPendingHandler.delete(handledP);
         resolved = true;
-        superReject(err);
+        superReject(reason);
         continueForwarding();
       };
     };
@@ -401,7 +398,7 @@ export const makeHandledPromise = () => {
     },
     getSendOnly(target, prop) {
       prop = coerceToObjectProperty(prop);
-      handle(target, 'getSendOnly', [prop]);
+      handle(target, 'getSendOnly', [prop]).catch(() => {});
     },
     applyFunction(target, args) {
       // Ensure args is an array.
@@ -411,7 +408,7 @@ export const makeHandledPromise = () => {
     applyFunctionSendOnly(target, args) {
       // Ensure args is an array.
       args = [...args];
-      handle(target, 'applyFunctionSendOnly', [args]);
+      handle(target, 'applyFunctionSendOnly', [args]).catch(() => {});
     },
     applyMethod(target, prop, args) {
       prop = coerceToObjectProperty(prop);
@@ -423,7 +420,7 @@ export const makeHandledPromise = () => {
       prop = coerceToObjectProperty(prop);
       // Ensure args is an array.
       args = [...args];
-      handle(target, 'applyMethodSendOnly', [prop, args]);
+      handle(target, 'applyMethodSendOnly', [prop, args]).catch(() => {});
     },
     resolve(value) {
       // Resolving a Presence returns the pre-registered handled promise.
@@ -443,7 +440,7 @@ export const makeHandledPromise = () => {
       const executeThen = (resolve, reject) =>
         resolvedPromise.then(resolve, reject);
       return harden(
-        Promise.resolve().then(_ => new HandledPromise(executeThen)),
+        Promise.resolve().then(() => new HandledPromise(executeThen)),
       );
     },
   };
@@ -497,6 +494,7 @@ export const makeHandledPromise = () => {
     const returnedP = new HandledPromise((resolve, reject) => {
       // We run in a future turn to prevent synchronous attacks,
       let raceIsOver = false;
+
       const win = (handlerName, handler, o) => {
         if (raceIsOver) {
           return;
@@ -504,16 +502,16 @@ export const makeHandledPromise = () => {
         try {
           resolve(trackedDoDispatch(handlerName, handler, o));
         } catch (reason) {
-          reject(reason);
+          reject(harden(reason));
         }
         raceIsOver = true;
       };
 
-      const lose = e => {
+      const lose = reason => {
         if (raceIsOver) {
           return;
         }
-        reject(e);
+        reject(harden(reason));
         raceIsOver = true;
       };
 
@@ -546,11 +544,6 @@ export const makeHandledPromise = () => {
         .catch(lose);
     });
 
-    // Harden the fulfillment and rejection, as well as a workaround for
-    // Node.js: silence "Unhandled Rejection" by default when using the static
-    // methods.
-    returnedP.then(harden, harden);
-
     // We return a handled promise with the default pending handler.  This
     // prevents a race between the above Promise.resolves and pipelining.
     return harden(returnedP);

package/src/track-turns.js

@@ -86,7 +86,7 @@ export const trackTurns = funcs => {
               console.log('REJECTED at top of event loop', reason);
             }
           });
-          return result;
+          return harden(result);
         } finally {
           hiddenPriorError = undefined;
         }