@agoric/vow 0.1.1-dev-d492653.0 → 0.1.1-dev-4fca040.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vow",
-  "version": "0.1.1-dev-d492653.0+d492653",
+  "version": "0.1.1-dev-4fca040.0+4fca040",
   "description": "Remote (shortening and disconnection-tolerant) Promise-likes",
   "type": "module",
   "main": "src/index.js",
@@ -20,8 +20,8 @@
     "lint:types": "tsc"
   },
   "dependencies": {
-    "@agoric/base-zone": "0.1.1-dev-d492653.0+d492653",
-    "@agoric/internal": "0.3.3-dev-d492653.0+d492653",
+    "@agoric/base-zone": "0.1.1-dev-4fca040.0+4fca040",
+    "@agoric/internal": "0.3.3-dev-4fca040.0+4fca040",
     "@endo/env-options": "^1.1.4",
     "@endo/eventual-send": "^1.2.2",
     "@endo/pass-style": "^1.4.0",
@@ -53,5 +53,5 @@
   "typeCoverage": {
     "atLeast": 89.6
   },
-  "gitHead": "d49265372b3cdd681558791b0c780e1c3062bdcc"
+  "gitHead": "4fca040204f3d45fc85c51b67e84d3ecb02728c8"
 }

package/src/tools.d.ts

@@ -1,5 +1,5 @@
 export function prepareVowTools(zone: Zone, powers?: {
-    isRetryableReason?: ((reason: any) => boolean) | undefined;
+    isRetryableReason?: IsRetryableReason | undefined;
 } | undefined): {
     when: <T, TResult1 = import("./types.js").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("./types.js").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
     watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("./types.js").ERef<T_1 | import("./types.js").Vow<T_1>>, watcher?: import("./types.js").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("./types.js").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
@@ -7,4 +7,5 @@ export function prepareVowTools(zone: Zone, powers?: {
     allVows: (vows: unknown[]) => import("./types.js").Vow<any[]>;
 };
 import type { Zone } from '@agoric/base-zone';
+import type { IsRetryableReason } from './types.js';
 //# sourceMappingURL=tools.d.ts.map

package/src/tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["tools.js"],"names":[],"mappings":"AAaO;kCAFa,GAAG,KAAK,OAAO;;sFAEc,CAAC;;;oBAWrC,OAAO,EAAE;EAKrB;0BAvBuB,mBAAmB"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["tools.js"],"names":[],"mappings":"AAcO;;;sFACL,CAAF;;;oBAWa,OAAO,EAAE;EAKrB;0BAzBuB,mBAAmB;uCACN,YAAY"}

package/src/tools.js

@@ -5,14 +5,16 @@ import { prepareWatch } from './watch.js';
 import { prepareWatchUtils } from './watch-utils.js';
 
 /** @import {Zone} from '@agoric/base-zone' */
+/** @import {IsRetryableReason} from './types.js' */
 
 /**
  * @param {Zone} zone
  * @param {object} [powers]
- * @param {(reason: any) => boolean} [powers.isRetryableReason]
+ * @param {IsRetryableReason} [powers.isRetryableReason]
  */
 export const prepareVowTools = (zone, powers = {}) => {
-  const { isRetryableReason = () => false } = powers;
+  const { isRetryableReason = /** @type {IsRetryableReason} */ (() => false) } =
+    powers;
   const makeVowKit = prepareVowKit(zone);
   const when = makeWhen(isRetryableReason);
   const watch = prepareWatch(zone, makeVowKit, isRetryableReason);

package/src/types.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Return truthy if a rejection reason should result in a retry.
+ */
+export type IsRetryableReason = (reason: any, priorRetryValue: any) => any;
 /**
  * Return type of a function that may
  * return a promise or a vow.

package/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;;uBAc6B,CAAC,IAAjB,OAAO,CAAS,CAAC,AAAR,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;iBAMH,CAAC,IAAD,CAAC,AAAhB,GAAG,WAAW,CAAC,CAAC,CAAC;;;;;mBAY9B,CAAK;;;;;;;kBAWsB,CAAC;;;;;;;aAAf,MAAM,OAAO,CAAC,CAAC,CAAC;;uBASe,CAAC;;;gBAKJ,CAAC;;;mBAOhB,CAAC,UAFf;IACZ,GAAO,EAAE,GAAG,CACc,CAAC,AADb,CAAC,CAAC;IAChB,QAAY,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;CAC1B;wBAK0C,CAAC;oDAAI,IAAI;oBAAkB,GAAG,GAAG,IAAI;;oBAS7D,CAAC,QAAyD,QAAQ,MAClB,QAAQ,UAD3C,CAAC;2BAAd,CAAC,YAAY,CAAC;2BACb,GAAG;;;iEAlE0B,CAAA;;;oBAehB,SACjC;;iCAvBmC,kBAAkB;oCAHvB,qBAAqB;qCAEpB,kBAAkB;4BACd,kBAAkB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;yCAeW,GAAG,mBACH,GAAG,KAED,GAAG;;;;;uBAMa,CAAC,IAAjB,OAAO,CAAS,CAAC,AAAR,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;iBAMH,CAAC,IAAD,CAAC,AAAhB,GAAG,WAAW,CAAC,CAAC,CAAC;;;;;mBAY9B,CAAK;;;;;;;kBAWsB,CAAC;;;;;;;aAAf,MAAM,OAAO,CAAC,CAAC,CAAC;;uBASe,CAAC;;;gBAKJ,CAAC;;;mBAOhB,CAAC,UAFf;IACZ,GAAO,EAAE,GAAG,CACc,CAAC,AADb,CAAC,CAAC;IAChB,QAAY,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;CAC1B;wBAK0C,CAAC;oDAAI,IAAI;oBAAkB,GAAG,GAAG,IAAI;;oBAS7D,CAAC,QAAyD,QAAQ,MAClB,QAAQ,UAD3C,CAAC;2BAAd,CAAC,YAAY,CAAC;2BACb,GAAG;;;iEA1EzB,CAAD;;;oBAcsB,SAAS;;iCAvBO,kBAAkB;oCAHvB,qBAAqB;qCAEpB,kBAAkB;4BACd,kBAAkB"}

package/src/types.js

@@ -10,6 +10,16 @@ export {};
  * @import {prepareVowTools} from './tools.js'
  */
 
+/**
+ * @callback IsRetryableReason
+ * Return truthy if a rejection reason should result in a retry.
+ * @param {any} reason
+ * @param {any} priorRetryValue the previous value returned by this function
+ * when deciding whether to retry the same logical operation
+ * @returns {any} If falsy, the reason is not retryable. If truthy, the
+ * priorRetryValue for the next call.
+ */
+
 /**
  * @template T
  * @typedef {Promise<T | Vow<T>>} PromiseVow Return type of a function that may

package/src/vow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vow.d.ts","sourceRoot":"","sources":["vow.js"],"names":[],"mappings":"AAuBO,4CA4Ge,CAAC,iBAStB;;0BApIsB,mBAAmB;4BACJ,YAAY;gCAFrB,mBAAmB"}
+{"version":3,"file":"vow.d.ts","sourceRoot":"","sources":["vow.js"],"names":[],"mappings":"AAuBO,4CA8He,CAAC,iBAStB;;0BAtJsB,mBAAmB;4BACJ,YAAY;gCAFrB,mBAAmB"}

package/src/vow.js

@@ -69,7 +69,9 @@ export const prepareVowKit = zone => {
     () => ({
       value: undefined,
       // The stepStatus is null if the promise step hasn't settled yet.
-      stepStatus: /** @type {null | 'fulfilled' | 'rejected'} */ (null),
+      stepStatus: /** @type {null | 'pending' | 'fulfilled' | 'rejected'} */ (
+        null
+      ),
     }),
     {
       vowV0: {
@@ -84,6 +86,7 @@ export const prepareVowKit = zone => {
             case 'rejected':
               throw value;
             case null:
+            case 'pending':
               return provideCurrentKit(this.facets.resolver).promise;
             default:
               throw new TypeError(`unexpected stepStatus ${stepStatus}`);
@@ -96,10 +99,17 @@ export const prepareVowKit = zone => {
          */
         resolve(value) {
           const { resolver } = this.facets;
-          const { promise, resolve } = getPromiseKitForResolution(resolver);
+          const { stepStatus } = this.state;
+          const { resolve } = getPromiseKitForResolution(resolver);
           if (resolve) {
             resolve(value);
-            zone.watchPromise(promise, this.facets.watchNextStep);
+          }
+          if (stepStatus === null) {
+            this.state.stepStatus = 'pending';
+            zone.watchPromise(
+              HandledPromise.resolve(value),
+              this.facets.watchNextStep,
+            );
           }
         },
         /**
@@ -107,15 +117,23 @@ export const prepareVowKit = zone => {
          */
         reject(reason) {
           const { resolver, watchNextStep } = this.facets;
+          const { stepStatus } = this.state;
           const { reject } = getPromiseKitForResolution(resolver);
           if (reject) {
             reject(reason);
+          }
+          if (stepStatus === null) {
             watchNextStep.onRejected(reason);
           }
         },
       },
       watchNextStep: {
         onFulfilled(value) {
+          const { resolver } = this.facets;
+          const { resolve } = getPromiseKitForResolution(resolver);
+          if (resolve) {
+            resolve(value);
+          }
           this.state.stepStatus = 'fulfilled';
           this.state.value = value;
         },

package/src/watch.d.ts

@@ -1,4 +1,4 @@
-export function prepareWatch(zone: Zone, makeVowKit: () => VowKit<any>, isRetryableReason?: ((reason: any) => boolean) | undefined): <T = any, TResult1 = T, TResult2 = never, C = any>(specimenP: ERef<T | Vow<T>>, watcher?: Watcher<T, TResult1, TResult2> | undefined, watcherContext?: C | undefined) => Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
+export function prepareWatch(zone: Zone, makeVowKit: () => VowKit<any>, isRetryableReason?: ((reason: any, lastValue: any) => any) | undefined): <T = any, TResult1 = T, TResult2 = never, C = any>(specimenP: ERef<T | Vow<T>>, watcher?: Watcher<T, TResult1, TResult2> | undefined, watcherContext?: C | undefined) => Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
 export type Watch = ReturnType<typeof prepareWatch>;
 import type { Zone } from '@agoric/base-zone';
 import type { VowKit } from './types.js';

package/src/watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["watch.js"],"names":[],"mappings":"AAyHO,sGAFa,GAAG,KAAK,OAAO,iBAmBT,CAAC,2SA0B1B;oBAIa,UAAU,CAAC,OAAO,YAAY,CAAC;0BAjKJ,mBAAmB;4BACA,YAAY;yBAAZ,YAAY;0BAAZ,YAAY;6BAAZ,YAAY"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["watch.js"],"names":[],"mappings":"AAkIO,sGAFa,GAAG,aAAa,GAAG,KAAK,GAAG,iBAmBrB,CAAC,2SA0B1B;oBAIa,UAAU,CAAC,OAAO,YAAY,CAAC;0BA1KJ,mBAAmB;4BACmB,YAAY;yBAAZ,YAAY;0BAAZ,YAAY;6BAAZ,YAAY"}

package/src/watch.js

@@ -6,7 +6,7 @@ const { apply } = Reflect;
 
 /**
  * @import { PromiseWatcher, Zone } from '@agoric/base-zone';
- * @import { ERef, Vow, VowKit, VowResolver, Watcher } from './types.js';
+ * @import { ERef, IsRetryableReason, Vow, VowKit, VowResolver, Watcher } from './types.js';
  */
 
 /**
@@ -62,7 +62,7 @@ const settle = (resolver, watcher, wcb, value, watcherContext) => {
 
 /**
  * @param {Zone} zone
- * @param {(reason: any) => boolean} isRetryableReason
+ * @param {IsRetryableReason} isRetryableReason
  * @param {ReturnType<typeof makeWatchNextStep>} watchNextStep
  */
 const preparePromiseWatcher = (zone, isRetryableReason, watchNextStep) =>
@@ -80,6 +80,7 @@ const preparePromiseWatcher = (zone, isRetryableReason, watchNextStep) =>
     (resolver, watcher, watcherContext) => {
       const state = {
         vow: /** @type {unknown} */ (undefined),
+        priorRetryValue: /** @type {any} */ (undefined),
         resolver,
         watcher,
         watcherContext: harden(watcherContext),
@@ -96,17 +97,25 @@ const preparePromiseWatcher = (zone, isRetryableReason, watchNextStep) =>
           watchNextStep(value, this.self);
           return;
         }
+        this.state.priorRetryValue = undefined;
         this.state.watcher = undefined;
         this.state.resolver = undefined;
         settle(resolver, watcher, 'onFulfilled', value, watcherContext);
       },
       /** @type {Required<PromiseWatcher>['onRejected']} */
       onRejected(reason) {
-        const { vow, watcher, watcherContext, resolver } = this.state;
-        if (vow && isRetryableReason(reason)) {
-          watchNextStep(vow, this.self);
-          return;
+        const { vow, watcher, watcherContext, resolver, priorRetryValue } =
+          this.state;
+        if (vow) {
+          const retryValue = isRetryableReason(reason, priorRetryValue);
+          if (retryValue) {
+            // Retry the same specimen.
+            this.state.priorRetryValue = retryValue;
+            watchNextStep(vow, this.self);
+            return;
+          }
         }
+        this.state.priorRetryValue = undefined;
         this.state.resolver = undefined;
         this.state.watcher = undefined;
         settle(resolver, watcher, 'onRejected', reason, watcherContext);
@@ -117,12 +126,12 @@ const preparePromiseWatcher = (zone, isRetryableReason, watchNextStep) =>
 /**
  * @param {Zone} zone
  * @param {() => VowKit<any>} makeVowKit
- * @param {(reason: any) => boolean} [isRetryableReason]
+ * @param {(reason: any, lastValue: any) => any} [isRetryableReason]
  */
 export const prepareWatch = (
   zone,
   makeVowKit,
-  isRetryableReason = _reason => false,
+  isRetryableReason = (_reason, _lastValue) => undefined,
 ) => {
   const watchNextStep = makeWatchNextStep(zone);
   const makePromiseWatcher = preparePromiseWatcher(

package/src/when.d.ts

@@ -1,4 +1,5 @@
-export function makeWhen(isRetryableReason?: ((reason: any) => boolean) | undefined): <T, TResult1 = Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+export function makeWhen(isRetryableReason?: IsRetryableReason | undefined): <T, TResult1 = Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
 export type When = ReturnType<typeof makeWhen>;
+import type { IsRetryableReason } from './types.js';
 import type { Unwrap } from './types.js';
 //# sourceMappingURL=when.d.ts.map

package/src/when.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"when.d.ts","sourceRoot":"","sources":["when.js"],"names":[],"mappings":"AAQO,uDAFa,GAAG,KAAK,OAAO,iBAUP,CAAC,EAEN,QAAQ,cAAG,QAAQ,qBAFd,CAAC,AADf,uCAGS,QAAQ,AAFY,GAAG,WAAW,CAElC,QAAQ,AAFmC,CAAC,sCAC7C,GAAG,KACS,QAAQ,AADJ,GAAG,WAAW,CAClB,QAAQ,AADmB,CAAC,kBAC/C,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC,CAkC1C;mBAIa,UAAU,CAAC,OAAO,QAAQ,CAAC;4BArDb,YAAY"}
+{"version":3,"file":"when.d.ts","sourceRoot":"","sources":["when.js"],"names":[],"mappings":"AAQO,8EAUqB,CAAC,EAEN,QAAQ,cAAG,QAAQ,qBAFd,CAAC,AADf,uCAGS,QAAQ,AAFY,GAAG,WAAW,CAElC,QAAQ,AAFmC,CAAC,sCAC7C,GAAG,KACS,QAAQ,AADJ,GAAG,WAAW,CAClB,QAAQ,AADmB,CAAC,kBAC/C,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC,CA2C1C;mBAIa,UAAU,CAAC,OAAO,QAAQ,CAAC;uCAhEM,YAAY;4BAAZ,YAAY"}

package/src/when.js

@@ -1,12 +1,14 @@
 // @ts-check
 import { getVowPayload, basicE } from './vow-utils.js';
 
-/** @import { Unwrap } from './types.js' */
+/** @import { IsRetryableReason, Unwrap } from './types.js' */
 
 /**
- * @param {(reason: any) => boolean} [isRetryableReason]
+ * @param {IsRetryableReason} [isRetryableReason]
  */
-export const makeWhen = (isRetryableReason = () => false) => {
+export const makeWhen = (
+  isRetryableReason = /** @type {IsRetryableReason} */ (() => false),
+) => {
   /**
    * Shorten `specimenP` until we achieve a final result.
    *
@@ -25,16 +27,25 @@ export const makeWhen = (isRetryableReason = () => false) => {
     // Ensure we have a presence that won't be disconnected later.
     let result = await specimenP;
     let payload = getVowPayload(result);
+    let priorRetryValue;
     while (payload) {
       result = await basicE(payload.vowV0)
         .shorten()
-        .catch(e => {
-          if (isRetryableReason(e)) {
-            // Shorten the same specimen to try again.
-            return result;
-          }
-          throw e;
-        });
+        .then(
+          res => {
+            priorRetryValue = undefined;
+            return res;
+          },
+          e => {
+            const nextValue = isRetryableReason(e, priorRetryValue);
+            if (nextValue) {
+              // Shorten the same specimen to try again.
+              priorRetryValue = nextValue;
+              return result;
+            }
+            throw e;
+          },
+        );
       // Advance to the next vow.
       payload = getVowPayload(result);
     }