@agoric/vow 0.1.1-dev-4f70e66.0 → 0.1.1-dev-8edf902.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vow",
-  "version": "0.1.1-dev-4f70e66.0+4f70e66",
+  "version": "0.1.1-dev-8edf902.0+8edf902",
   "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-4f70e66.0+4f70e66",
-    "@agoric/internal": "0.3.3-dev-4f70e66.0+4f70e66",
+    "@agoric/base-zone": "0.1.1-dev-8edf902.0+8edf902",
+    "@agoric/internal": "0.3.3-dev-8edf902.0+8edf902",
     "@endo/env-options": "^1.1.4",
     "@endo/eventual-send": "^1.2.2",
     "@endo/pass-style": "^1.4.0",
@@ -54,5 +54,5 @@
   "typeCoverage": {
     "atLeast": 89.6
   },
-  "gitHead": "4f70e66a2fa4f663e13fa9172e9b8efb1ad7a9d8"
+  "gitHead": "8edf90288c8a7b248ec4961d342063e2b8c52303"
 }

package/src/tools.d.ts

@@ -2,12 +2,15 @@ export function prepareVowTools(zone: Zone, powers?: {
     isRetryableReason?: IsRetryableReason | undefined;
 } | undefined): {
     when: <T, TResult1 = import("./types.js").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("./types.js").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T = any, TResult1 = T, TResult2 = never, C extends any[] = any[]>(specimenP: import("./types.js").ERef<T | import("./types.js").Vow<T>>, watcher?: import("./types.js").Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => import("./types.js").Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
+    watch: <T = any, TResult1 = T, TResult2 = never, C extends any[] = any[]>(specimenP: EVow<T>, watcher?: import("./types.js").Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => import("./types.js").Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
     makeVowKit: <T>() => import("./types.js").VowKit<T>;
-    allVows: (vows: unknown[]) => import("./types.js").Vow<any[]>;
+    allVows: (maybeVows: EVow<unknown>[]) => import("./types.js").Vow<any[]>;
     asVow: <T extends unknown>(fn: (...args: any[]) => import("./types.js").Vow<Awaited<T>> | Awaited<T> | import("./types.js").PromiseVow<T>) => import("./types.js").Vow<Awaited<T>>;
+    asPromise: AsPromiseFunction;
 };
 export type VowTools = ReturnType<typeof prepareVowTools>;
 import type { Zone } from '@agoric/base-zone';
 import type { IsRetryableReason } from './types.js';
+import type { EVow } from './types.js';
+import type { AsPromiseFunction } 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":"AAeO,sCAJI,IAAI;;;;;;oBAiBF,OAAO,EAAE;oCASs0C,GAAG;EAJ91C;uBAGa,UAAU,CAAC,OAAO,eAAe,CAAC;0BA7BxB,mBAAmB;uCACN,YAAY"}
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["tools.js"],"names":[],"mappings":"AAiBO,sCAJI,IAAI;;;;;;yBAsBF,KAAK,OAAO,CAAC,EAAE;oCAaykC,GAAG;;EAJvmC;uBAGa,UAAU,CAAC,OAAO,eAAe,CAAC;0BAvCzB,mBAAmB;uCACmB,YAAY;0BAAZ,YAAY;uCAAZ,YAAY"}

package/src/tools.js

@@ -5,8 +5,10 @@ import { prepareWatch } from './watch.js';
 import { prepareWatchUtils } from './watch-utils.js';
 import { makeAsVow } from './vow-utils.js';
 
-/** @import {Zone} from '@agoric/base-zone' */
-/** @import {IsRetryableReason} from './types.js' */
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {IsRetryableReason, AsPromiseFunction, EVow} from './types.js';
+ */
 
 /**
  * @param {Zone} zone
@@ -19,18 +21,27 @@ export const prepareVowTools = (zone, powers = {}) => {
   const makeVowKit = prepareVowKit(zone);
   const when = makeWhen(isRetryableReason);
   const watch = prepareWatch(zone, makeVowKit, isRetryableReason);
-  const makeWatchUtils = prepareWatchUtils(zone, watch, makeVowKit);
+  const makeWatchUtils = prepareWatchUtils(zone, {
+    watch,
+    when,
+    makeVowKit,
+    isRetryableReason,
+  });
   const watchUtils = makeWatchUtils();
   const asVow = makeAsVow(makeVowKit);
 
   /**
    * Vow-tolerant implementation of Promise.all.
    *
-   * @param {unknown[]} vows
+   * @param {EVow<unknown>[]} maybeVows
    */
-  const allVows = vows => watchUtils.all(vows);
+  const allVows = maybeVows => watchUtils.all(maybeVows);
+
+  /** @type {AsPromiseFunction} */
+  const asPromise = (specimenP, ...watcherArgs) =>
+    watchUtils.asPromise(specimenP, ...watcherArgs);
 
-  return harden({ when, watch, makeVowKit, allVows, asVow });
+  return harden({ when, watch, makeVowKit, allVows, asVow, asPromise });
 };
 harden(prepareVowTools);
 

package/src/types.d.ts

@@ -8,6 +8,10 @@ export type IsRetryableReason = (reason: any, priorRetryValue: any) => any;
  */
 export type PromiseVow<T> = Promise<T | Vow<T>>;
 export type ERef<T> = T | PromiseLike<T>;
+/**
+ * Eventually a value T or Vow for it.
+ */
+export type EVow<T> = ERef<T | Vow<T>>;
 /**
  * Follow the chain of vow shortening to the end, returning the final value.
  * This is used within E, so we must narrow the type to its remote form.
@@ -44,6 +48,10 @@ export type Watcher<T = any, TResult1 = T, TResult2 = never, C extends any[] = a
     onFulfilled?: ((value: T, ...args: C) => Vow<TResult1> | PromiseVow<TResult1> | TResult1) | undefined;
     onRejected?: ((reason: any, ...args: C) => Vow<TResult2> | PromiseVow<TResult2> | TResult2) | undefined;
 };
+/**
+ * Converts a vow or promise to a promise, ensuring proper handling of ephemeral promises.
+ */
+export type AsPromiseFunction<T = any, TResult1 = T, TResult2 = never, C extends any[] = any[]> = (specimenP: ERef<T | Vow<T>>, watcher?: Watcher<T, TResult1, TResult2, C> | undefined, watcherArgs?: C | undefined) => Promise<TResult1 | TResult2>;
 import type { RemotableObject } from '@endo/pass-style';
 import type { Remote } from '@agoric/internal';
 import type { CopyTagged } from '@endo/pass-style';

package/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;yCAaW,GAAG,mBACH,GAAG,KAED,GAAG;;;;;uBAKH,CAAC,IACD,OAAO,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;iBAKnB,CAAC,IACD,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;;;;;oBAMlB,CAAC,IACD,CACZ,CAAK,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACvC,CAAK,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC/C,CAAK,CACF;;;;;;;kBAIU,CAAC;;;;;;;aAMD,MAAM,OAAO,CAAC,CAAC,CAAC;;uBAOhB,CAAC;WAED,eAAe,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;;gBAIlC,CAAC,UACF,WAAW,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;mBAI/B,CAAC,UACF;IACZ,GAAO,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAChB,QAAY,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;CAC1B;wBAIU,CAAC,UACF;IAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,IAAI,CAAA;CAAE;oBAIvE,CAAC,QACD,QAAQ,MACR,QAAQ,UACA,CAAC,SAAT,GAAG,EAAG;2BAEE,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,GAAG,QAAQ;2BAChE,GAAG,WAAW,CAAC,KAAK,GAAG,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,GAAG,QAAQ;;qCAjFxD,kBAAkB;4BAC3B,kBAAkB;gCAFd,kBAAkB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;yCAaW,GAAG,mBACH,GAAG,KAED,GAAG;;;;;uBAKH,CAAC,IACD,OAAO,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;iBAKnB,CAAC,IACD,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;;;;iBAKlB,CAAC,IACD,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;;;;;oBAMhB,CAAC,IACD,CACZ,CAAK,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACvC,CAAK,SAAS,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAC/C,CAAK,CACF;;;;;;;kBAIU,CAAC;;;;;;;aAMD,MAAM,OAAO,CAAC,CAAC,CAAC;;uBAOhB,CAAC;WAED,eAAe,GAAG,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;;gBAIlC,CAAC,UACF,WAAW,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;mBAI/B,CAAC,UACF;IACZ,GAAO,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAChB,QAAY,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;CAC1B;wBAIU,CAAC,UACF;IAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,IAAI,CAAA;CAAE;oBAIvE,CAAC,QACD,QAAQ,MACR,QAAQ,UACA,CAAC,SAAT,GAAG,EAAG;2BAEE,CAAC,WAAW,CAAC,KAAK,GAAG,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,GAAG,QAAQ;2BAChE,GAAG,WAAW,CAAC,KAAK,GAAG,CAAC,QAAQ,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,GAAG,QAAQ;;;;;8BAM5E,CAAC,QACD,QAAQ,MACR,QAAQ,UACA,CAAC,SAAT,GAAG,EAAG,wBAET,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,2FAGd,OAAO,CAAC,QAAQ,GAAG,QAAQ,CAAC;qCArGP,kBAAkB;4BAC3B,kBAAkB;gCAFd,kBAAkB"}

package/src/types.js

@@ -29,6 +29,12 @@ export {};
  * @typedef {T | PromiseLike<T>} ERef
  */
 
+/**
+ * Eventually a value T or Vow for it.
+ * @template T
+ * @typedef {ERef<T | Vow<T>>} EVow
+ */
+
 /**
  * Follow the chain of vow shortening to the end, returning the final value.
  * This is used within E, so we must narrow the type to its remote form.
@@ -86,3 +92,17 @@ export {};
  * @property {(value: T, ...args: C) => Vow<TResult1> | PromiseVow<TResult1> | TResult1} [onFulfilled]
  * @property {(reason: any, ...args: C) => Vow<TResult2> | PromiseVow<TResult2> | TResult2} [onRejected]
  */
+
+/**
+ * Converts a vow or promise to a promise, ensuring proper handling of ephemeral promises.
+ *
+ * @template [T=any]
+ * @template [TResult1=T]
+ * @template [TResult2=never]
+ * @template {any[]} [C=any[]]
+ * @callback AsPromiseFunction
+ * @param {ERef<T | Vow<T>>} specimenP
+ * @param {Watcher<T, TResult1, TResult2, C>} [watcher]
+ * @param {C} [watcherArgs]
+ * @returns {Promise<TResult1 | TResult2>}
+ */

package/src/vow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vow.d.ts","sourceRoot":"","sources":["vow.js"],"names":[],"mappings":"AAuBO,oCAFI,IAAI,IA+HA,CAAC,OACD,OAAO,CAAC,CAAC,CASvB;0BA9IY,OAAO,CAAC,WAAW,GAAG,CAAC,CAAC,GACpC,IAAQ,CAAC,WAAW,GAAG,CAAC,EAAE,SAAS,CAAC;yBA8IvB,UAAU,CAAC,OAAO,aAAa,CAAC;0BAvJvB,mBAAmB;4BACJ,YAAY;gCAFrB,mBAAmB"}
+{"version":3,"file":"vow.d.ts","sourceRoot":"","sources":["vow.js"],"names":[],"mappings":"AA0BO,oCAFI,IAAI,IAkLA,CAAC,OACD,OAAO,CAAC,CAAC,CASvB;0BAjMY,OAAO,CAAC,WAAW,GAAG,CAAC,CAAC,GACpC,IAAQ,CAAC,WAAW,GAAG,CAAC,EAAE,SAAS,CAAC;yBAiMvB,UAAU,CAAC,OAAO,aAAa,CAAC;0BA3MvB,mBAAmB;4BAEJ,YAAY;gCAHrB,mBAAmB"}

package/src/vow.js

@@ -4,10 +4,13 @@ import { M } from '@endo/patterns';
 import { makeTagged } from '@endo/pass-style';
 import { PromiseWatcherI } from '@agoric/base-zone';
 
+const { details: X } = assert;
+
 /**
- * @import {PromiseKit} from '@endo/promise-kit'
- * @import {Zone} from '@agoric/base-zone'
- * @import {VowResolver, VowKit} from './types.js'
+ * @import {PromiseKit} from '@endo/promise-kit';
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {MapStore} from '@agoric/store';
+ * @import {VowResolver, VowKit} from './types.js';
  */
 
 const sink = () => {};
@@ -25,6 +28,9 @@ export const prepareVowKit = zone => {
   /** @type {WeakMap<VowResolver, VowEphemera>} */
   const resolverToEphemera = new WeakMap();
 
+  /** @type {WeakMap<VowResolver, any>} */
+  const resolverToNonStoredValue = new WeakMap();
+
   /**
    * Get the current incarnation's promise kit associated with a vowV0.
    *
@@ -61,17 +67,24 @@ export const prepareVowKit = zone => {
         shorten: M.call().returns(M.promise()),
       }),
       resolver: M.interface('VowResolver', {
-        resolve: M.call().optional(M.any()).returns(),
-        reject: M.call().optional(M.any()).returns(),
+        resolve: M.call().optional(M.raw()).returns(),
+        reject: M.call().optional(M.raw()).returns(),
       }),
       watchNextStep: PromiseWatcherI,
     },
     () => ({
-      value: undefined,
+      value: /** @type {any} */ (undefined),
       // The stepStatus is null if the promise step hasn't settled yet.
       stepStatus: /** @type {null | 'pending' | 'fulfilled' | 'rejected'} */ (
         null
       ),
+      isStoredValue: /** @type {boolean} */ (false),
+      /**
+       * Map for future properties that aren't in the schema.
+       * UNTIL https://github.com/Agoric/agoric-sdk/issues/7407
+       * @type {MapStore<any, any> | undefined}
+       */
+      extra: undefined,
     }),
     {
       vowV0: {
@@ -79,12 +92,30 @@ export const prepareVowKit = zone => {
          * @returns {Promise<any>}
          */
         async shorten() {
-          const { stepStatus, value } = this.state;
+          const { stepStatus, isStoredValue, value } = this.state;
+          const { resolver } = this.facets;
+
           switch (stepStatus) {
-            case 'fulfilled':
-              return value;
-            case 'rejected':
+            case 'fulfilled': {
+              if (isStoredValue) {
+                // Always return a stored fulfilled value.
+                return value;
+              } else if (resolverToNonStoredValue.has(resolver)) {
+                // Non-stored value is available.
+                return resolverToNonStoredValue.get(resolver);
+              }
+              // We can't recover the non-stored value, so throw the
+              // explanation.
               throw value;
+            }
+            case 'rejected': {
+              if (!isStoredValue && resolverToNonStoredValue.has(resolver)) {
+                // Non-stored reason is available.
+                throw resolverToNonStoredValue.get(resolver);
+              }
+              // Always throw a stored rejection reason.
+              throw value;
+            }
             case null:
             case 'pending':
               return provideCurrentKit(this.facets.resolver).promise;
@@ -131,15 +162,38 @@ export const prepareVowKit = zone => {
         onFulfilled(value) {
           const { resolver } = this.facets;
           const { resolve } = getPromiseKitForResolution(resolver);
+          harden(value);
           if (resolve) {
             resolve(value);
           }
           this.state.stepStatus = 'fulfilled';
-          this.state.value = value;
+          this.state.isStoredValue = zone.isStorable(value);
+          if (this.state.isStoredValue) {
+            this.state.value = value;
+          } else {
+            resolverToNonStoredValue.set(resolver, value);
+            this.state.value = assert.error(
+              X`Vow fulfillment value was not stored: ${value}`,
+            );
+          }
         },
         onRejected(reason) {
+          const { resolver } = this.facets;
+          const { reject } = getPromiseKitForResolution(resolver);
+          harden(reason);
+          if (reject) {
+            reject(reason);
+          }
           this.state.stepStatus = 'rejected';
-          this.state.value = reason;
+          this.state.isStoredValue = zone.isStorable(reason);
+          if (this.state.isStoredValue) {
+            this.state.value = reason;
+          } else {
+            resolverToNonStoredValue.set(resolver, reason);
+            this.state.value = assert.error(
+              X`Vow rejection reason was not stored: ${reason}`,
+            );
+          }
         },
       },
     },

package/src/watch-utils.d.ts

@@ -1,10 +1,20 @@
-export function prepareWatchUtils(zone: Zone, watch: Watch, makeVowKit: () => VowKit<any>): () => import("@endo/exo").Guarded<{
+export function prepareWatchUtils(zone: Zone, { watch, when, makeVowKit, isRetryableReason }: {
+    watch: Watch;
+    when: When;
+    makeVowKit: () => VowKit<any>;
+    isRetryableReason: IsRetryableReason;
+}): () => import("@endo/exo").Guarded<{
     /**
-     * @param {unknown[]} vows
+     * @param {EVow<unknown>[]} vows
      */
-    all(vows: unknown[]): import("./types.js").Vow<any[]>;
+    all(vows: EVow<unknown>[]): import("./types.js").Vow<any[]>;
+    /** @type {AsPromiseFunction} */
+    asPromise(specimenP: any, watcher: import("./types.js").Watcher<any, any, never, any[]> | undefined, watcherArgs: any[] | undefined): Promise<any | never>;
 }>;
 import type { Zone } from '@agoric/base-zone';
 import type { Watch } from './watch.js';
+import type { When } from './when.js';
 import type { VowKit } from './types.js';
+import type { IsRetryableReason } from './types.js';
+import type { EVow } from './types.js';
 //# sourceMappingURL=watch-utils.d.ts.map

package/src/watch-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch-utils.d.ts","sourceRoot":"","sources":["watch-utils.js"],"names":[],"mappings":"AAuBO,wCAJI,IAAI,SACJ,KAAK,cACL,MAAM,OAAO,GAAG,CAAC;IAgCpB;;OAEG;cADQ,OAAO,EAAE;GA+E3B;0BA/HwB,mBAAmB;2BAClB,YAAY;4BACb,YAAY"}
+{"version":3,"file":"watch-utils.d.ts","sourceRoot":"","sources":["watch-utils.js"],"names":[],"mappings":"AA4CO,wCAPI,IAAI,kDAEZ;IAAsB,KAAK,EAAnB,KAAK;IACQ,IAAI,EAAjB,IAAI;IACsB,UAAU,EAApC,MAAM,OAAO,GAAG,CAAC;IACS,iBAAiB,EAA3C,iBAAiB;CAC3B;IAsCO;;OAEG;cADQ,KAAK,OAAO,CAAC,EAAE;IAuC1B,gCAAgC;;GAgGvC;0BAhNsB,mBAAmB;2BAClB,YAAY;0BACb,WAAW;4BACmC,YAAY;uCAAZ,YAAY;0BAAZ,YAAY"}

package/src/watch-utils.js

@@ -1,12 +1,16 @@
 // @ts-check
 
 import { M } from '@endo/patterns';
+import { PromiseWatcherI } from '@agoric/base-zone';
+
+const { Fail, bare, details: X } = assert;
 
 /**
- * @import {MapStore} from '@agoric/store/src/types.js'
- * @import { Zone } from '@agoric/base-zone'
- * @import { Watch } from './watch.js'
- * @import {VowKit} from './types.js'
+ * @import {MapStore} from '@agoric/store/src/types.js';
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Watch} from './watch.js';
+ * @import {When} from './when.js';
+ * @import {VowKit, AsPromiseFunction, IsRetryableReason, EVow} from './types.js';
  */
 
 const VowShape = M.tagged(
@@ -16,23 +20,47 @@ const VowShape = M.tagged(
   }),
 );
 
+/**
+ * Like `provideLazy`, but accepts non-Passable values.
+ *
+ * @param {WeakMap} map
+ * @param {any} key
+ * @param {(key: any) => any} makeValue
+ */
+const provideLazyMap = (map, key, makeValue) => {
+  if (!map.has(key)) {
+    map.set(key, makeValue(key));
+  }
+  return map.get(key);
+};
+
 /**
  * @param {Zone} zone
- * @param {Watch} watch
- * @param {() => VowKit<any>} makeVowKit
+ * @param {object} powers
+ * @param {Watch} powers.watch
+ * @param {When} powers.when
+ * @param {() => VowKit<any>} powers.makeVowKit
+ * @param {IsRetryableReason} powers.isRetryableReason
  */
-export const prepareWatchUtils = (zone, watch, makeVowKit) => {
+export const prepareWatchUtils = (
+  zone,
+  { watch, when, makeVowKit, isRetryableReason },
+) => {
   const detached = zone.detached();
+  const utilsToNonStorableResults = new WeakMap();
+
   const makeWatchUtilsKit = zone.exoClassKit(
     'WatchUtils',
     {
       utils: M.interface('Utils', {
         all: M.call(M.arrayOf(M.any())).returns(VowShape),
+        asPromise: M.call(M.raw()).rest(M.raw()).returns(M.promise()),
       }),
       watcher: M.interface('Watcher', {
         onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
         onRejected: M.call(M.any()).rest(M.any()).returns(M.any()),
       }),
+      retryRejectionPromiseWatcher: PromiseWatcherI,
     },
     () => {
       /**
@@ -52,7 +80,7 @@ export const prepareWatchUtils = (zone, watch, makeVowKit) => {
     {
       utils: {
         /**
-         * @param {unknown[]} vows
+         * @param {EVow<unknown>[]} vows
          */
         all(vows) {
           const { nextId: id, idToVowState } = this.state;
@@ -60,40 +88,75 @@ export const prepareWatchUtils = (zone, watch, makeVowKit) => {
           const kit = makeVowKit();
 
           // Preserve the order of the vow results.
-          let index = 0;
-          for (const vow of vows) {
-            watch(vow, this.facets.watcher, { id, index });
-            index += 1;
+          for (let index = 0; index < vows.length; index += 1) {
+            watch(vows[index], this.facets.watcher, {
+              id,
+              index,
+              numResults: vows.length,
+            });
           }
 
-          if (index > 0) {
+          if (vows.length > 0) {
             // Save the state until rejection or all fulfilled.
             this.state.nextId += 1n;
             idToVowState.init(
               id,
               harden({
                 resolver: kit.resolver,
-                remaining: index,
+                remaining: vows.length,
                 resultsMap: detached.mapStore('resultsMap'),
               }),
             );
+            const idToNonStorableResults = provideLazyMap(
+              utilsToNonStorableResults,
+              this.facets.utils,
+              () => new Map(),
+            );
+            idToNonStorableResults.set(id, new Map());
           } else {
             // Base case: nothing to wait for.
             kit.resolver.resolve(harden([]));
           }
           return kit.vow;
         },
+        /** @type {AsPromiseFunction} */
+        asPromise(specimenP, ...watcherArgs) {
+          // Watch the specimen in case it is an ephemeral promise.
+          const vow = watch(specimenP, ...watcherArgs);
+          const promise = when(vow);
+          // Watch the ephemeral result promise to ensure that if its settlement is
+          // lost due to upgrade of this incarnation, we will at least cause an
+          // unhandled rejection in the new incarnation.
+          zone.watchPromise(promise, this.facets.retryRejectionPromiseWatcher);
+
+          return promise;
+        },
       },
       watcher: {
-        onFulfilled(value, { id, index }) {
+        onFulfilled(value, { id, index, numResults }) {
           const { idToVowState } = this.state;
           if (!idToVowState.has(id)) {
             // Resolution of the returned vow happened already.
             return;
           }
           const { remaining, resultsMap, resolver } = idToVowState.get(id);
+          const idToNonStorableResults = provideLazyMap(
+            utilsToNonStorableResults,
+            this.facets.utils,
+            () => new Map(),
+          );
+          const nonStorableResults = provideLazyMap(
+            idToNonStorableResults,
+            id,
+            () => new Map(),
+          );
+
           // Capture the fulfilled value.
-          resultsMap.init(index, value);
+          if (zone.isStorable(value)) {
+            resultsMap.init(index, value);
+          } else {
+            nonStorableResults.set(index, value);
+          }
           const vowState = harden({
             remaining: remaining - 1,
             resultsMap,
@@ -105,13 +168,26 @@ export const prepareWatchUtils = (zone, watch, makeVowKit) => {
           }
           // We're done!  Extract the array.
           idToVowState.delete(id);
-          const results = new Array(resultsMap.getSize());
-          for (const [i, val] of resultsMap.entries()) {
-            results[i] = val;
+          const results = new Array(numResults);
+          let numLost = 0;
+          for (let i = 0; i < numResults; i += 1) {
+            if (nonStorableResults.has(i)) {
+              results[i] = nonStorableResults.get(i);
+            } else if (resultsMap.has(i)) {
+              results[i] = resultsMap.get(i);
+            } else {
+              numLost += 1;
+            }
+          }
+          if (numLost > 0) {
+            resolver.reject(
+              assert.error(X`${numLost} unstorable results were lost`),
+            );
+          } else {
+            resolver.resolve(harden(results));
           }
-          resolver.resolve(harden(results));
         },
-        onRejected(value, { id, index: _index }) {
+        onRejected(value, { id, index: _index, numResults: _numResults }) {
           const { idToVowState } = this.state;
           if (!idToVowState.has(id)) {
             // First rejection wins.
@@ -122,6 +198,14 @@ export const prepareWatchUtils = (zone, watch, makeVowKit) => {
           resolver.reject(value);
         },
       },
+      retryRejectionPromiseWatcher: {
+        onFulfilled(_result) {},
+        onRejected(reason, failedOp) {
+          if (isRetryableReason(reason, undefined)) {
+            Fail`Pending ${bare(failedOp)} could not retry; ${reason}`;
+          }
+        },
+      },
     },
   );
 

package/src/watch.d.ts

@@ -1,8 +1,8 @@
-export function prepareWatch(zone: Zone, makeVowKit: () => VowKit<any>, isRetryableReason?: ((reason: any, lastValue: any) => any) | undefined): <T = any, TResult1 = T, TResult2 = never, C extends any[] = any[]>(specimenP: ERef<T | Vow<T>>, watcher?: Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => 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 extends any[] = any[]>(specimenP: EVow<T>, watcher?: Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => 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';
-import type { Vow } from './types.js';
-import type { ERef } from './types.js';
+import type { EVow } from './types.js';
 import type { Watcher } from './types.js';
+import type { Vow } from './types.js';
 //# sourceMappingURL=watch.d.ts.map

package/src/watch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["watch.js"],"names":[],"mappings":"AA2JO,mCAJI,IAAI,cACJ,MAAM,OAAO,GAAG,CAAC,gCACR,GAAG,aAAa,GAAG,KAAK,GAAG,iBAe/B,CAAC,QACD,QAAQ,MACR,QAAQ,UACA,CAAC,SAAT,GAAG,EAAG,qBACT,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,2EAEhB,CAAC,yIAoBb;oBAIa,UAAU,CAAC,OAAO,YAAY,CAAC;0BA/LJ,mBAAmB;4BACmB,YAAY;yBAAZ,YAAY;0BAAZ,YAAY;6BAAZ,YAAY"}
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["watch.js"],"names":[],"mappings":"AA2JO,mCAJI,IAAI,cACJ,MAAM,OAAO,GAAG,CAAC,gCACR,GAAG,aAAa,GAAG,KAAK,GAAG,iBAe/B,CAAC,QACD,QAAQ,MACR,QAAQ,UACA,CAAC,SAAT,GAAG,EAAG,qBACT,KAAK,CAAC,CAAC,2EAEP,CAAC,yIAoBb;oBAIa,UAAU,CAAC,OAAO,YAAY,CAAC;0BA/LJ,mBAAmB;4BACyB,YAAY;0BAAZ,YAAY;6BAAZ,YAAY;yBAAZ,YAAY"}

package/src/watch.js

@@ -6,7 +6,7 @@ const { apply } = Reflect;
 
 /**
  * @import { PromiseWatcher, Zone } from '@agoric/base-zone';
- * @import { ERef, IsRetryableReason, Vow, VowKit, VowResolver, Watcher } from './types.js';
+ * @import { ERef, EVow, IsRetryableReason, Vow, VowKit, VowResolver, Watcher } from './types.js';
  */
 
 /**
@@ -170,7 +170,7 @@ export const prepareWatch = (
    * @template [TResult1=T]
    * @template [TResult2=never]
    * @template {any[]} [C=any[]] watcher args
-   * @param {ERef<T | Vow<T>>} specimenP
+   * @param {EVow<T>} specimenP
    * @param {Watcher<T, TResult1, TResult2, C>} [watcher]
    * @param {C} watcherArgs
    */