@agoric/vow 0.1.1-dev-c5284e4.0

package/src/tools.d.ts

@@ -0,0 +1,9 @@
+export function prepareVowTools(zone: import('@agoric/base-zone').Zone, powers?: {
+    isRetryableReason?: ((reason: any) => boolean) | undefined;
+    watchPromise?: ((p: PromiseLike<any>, watcher: import('./watch-promise.js').PromiseWatcher, ...args: unknown[]) => void) | undefined;
+} | undefined): {
+    when: <T = any, TResult1 = import("./E.js").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("./E.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 = T_1>(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?: unknown) => import("./types.js").Vow<TResult1_1 | TResult2_1>;
+    makeVowKit: <T_2>() => import("./types.js").VowKit<T_2>;
+};
+//# sourceMappingURL=tools.d.ts.map

package/src/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["tools.js"],"names":[],"mappings":"AAWO,sCALI,OAAO,mBAAmB,EAAE,IAAI;kCAEvB,GAAG,KAAK,OAAO;wBACpB,YAAY,GAAG,CAAC,WAAW,OAAO,oBAAoB,EAAE,cAAc,WAAW,OAAO,EAAE,KAAK,IAAI;;;;;EAQjH"}

package/src/tools.js

@@ -0,0 +1,19 @@
+// @ts-check
+import { makeWhen } from './when.js';
+import { prepareVowKit } from './vow.js';
+import { prepareWatch } from './watch.js';
+
+/**
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {object} [powers]
+ * @param {(reason: any) => boolean} [powers.isRetryableReason]
+ * @param {(p: PromiseLike<any>, watcher: import('./watch-promise.js').PromiseWatcher, ...args: unknown[]) => void} [powers.watchPromise]
+ */
+export const prepareVowTools = (zone, powers = {}) => {
+  const { isRetryableReason = () => false, watchPromise } = powers;
+  const makeVowKit = prepareVowKit(zone, watchPromise);
+  const when = makeWhen(isRetryableReason);
+  const watch = prepareWatch(zone, makeVowKit, watchPromise, isRetryableReason);
+  return harden({ when, watch, makeVowKit });
+};
+harden(prepareVowTools);

package/src/track-turns.d.ts

@@ -0,0 +1,7 @@
+export function trackTurns<T extends TurnStarterFn[]>(funcs: T): T;
+/**
+ * An optional function that is not this-sensitive, expected to be called at
+ * bottom of stack to start a new turn.
+ */
+export type TurnStarterFn = ((...args: any[]) => any) | undefined;
+//# sourceMappingURL=track-turns.d.ts.map

package/src/track-turns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track-turns.d.ts","sourceRoot":"","sources":["track-turns.js"],"names":[],"mappings":"AAyFO,mEAiBN;;;;;uCAMuB,GAAG,EAAE,KAAK,GAAG"}

package/src/track-turns.js

@@ -0,0 +1,114 @@
+// @ts-check
+/* global globalThis */
+import {
+  getEnvironmentOption,
+  environmentOptionsListHas,
+} from '@endo/env-options';
+
+// NOTE: We can't import these because they're not in scope before lockdown.
+// import { assert, details as X, Fail } from '@agoric/assert';
+
+// WARNING: Global Mutable State!
+// This state is communicated to `assert` that makes it available to the
+// causal console, which affects the console log output. Normally we
+// regard the ability to see console log output as a meta-level privilege
+// analogous to the ability to debug. Aside from that, this module should
+// not have any observably mutable state.
+
+let hiddenPriorError;
+let hiddenCurrentTurn = 0;
+let hiddenCurrentEvent = 0;
+
+// Turn on if you seem to be losing error logging at the top of the event loop
+const VERBOSE = environmentOptionsListHas('DEBUG', 'track-turns');
+
+// Track-turns is disabled by default and can be enabled by an environment
+// option.
+const ENABLED =
+  getEnvironmentOption('TRACK_TURNS', 'disabled', ['enabled']) === 'enabled';
+
+// We hoist the following functions out of trackTurns() to discourage the
+// closures from holding onto 'args' or 'func' longer than necessary,
+// which we've seen cause HandledPromise arguments to be retained for
+// a surprisingly long time.
+
+const addRejectionNote = detailsNote => reason => {
+  if (reason instanceof Error) {
+    assert.note(reason, detailsNote);
+  }
+  if (VERBOSE) {
+    console.log('REJECTED at top of event loop', reason);
+  }
+};
+
+const wrapFunction =
+  (func, sendingError, X) =>
+  (...args) => {
+    hiddenPriorError = sendingError;
+    hiddenCurrentTurn += 1;
+    hiddenCurrentEvent = 0;
+    try {
+      let result;
+      try {
+        result = func(...args);
+      } catch (err) {
+        if (err instanceof Error) {
+          assert.note(
+            err,
+            X`Thrown from: ${hiddenPriorError}:${hiddenCurrentTurn}.${hiddenCurrentEvent}`,
+          );
+        }
+        if (VERBOSE) {
+          console.log('THROWN to top of event loop', err);
+        }
+        throw err;
+      }
+      // Must capture this now, not when the catch triggers.
+      const detailsNote = X`Rejection from: ${hiddenPriorError}:${hiddenCurrentTurn}.${hiddenCurrentEvent}`;
+      Promise.resolve(result).catch(addRejectionNote(detailsNote));
+      return result;
+    } finally {
+      hiddenPriorError = undefined;
+    }
+  };
+
+/**
+ * Given a list of `TurnStarterFn`s, returns a list of `TurnStarterFn`s whose
+ * `this`-free call behaviors are not observably different to those that
+ * cannot see console output. The only purpose is to cause additional
+ * information to appear on the console.
+ *
+ * The call to `trackTurns` is itself a sending event, that occurs in some call
+ * stack in some turn number at some event number within that turn. Each call
+ * to any of the returned `TurnStartFn`s is a receiving event that begins a new
+ * turn. This sending event caused each of those receiving events.
+ *
+ * @template {TurnStarterFn[]} T
+ * @param {T} funcs
+ * @returns {T}
+ */
+export const trackTurns = funcs => {
+  if (!ENABLED || typeof globalThis === 'undefined' || !globalThis.assert) {
+    return funcs;
+  }
+  const { details: X } = assert;
+
+  hiddenCurrentEvent += 1;
+  const sendingError = Error(
+    `Event: ${hiddenCurrentTurn}.${hiddenCurrentEvent}`,
+  );
+  if (hiddenPriorError !== undefined) {
+    assert.note(sendingError, X`Caused by: ${hiddenPriorError}`);
+  }
+
+  return /** @type {T} */ (
+    funcs.map(func => func && wrapFunction(func, sendingError, X))
+  );
+};
+
+/**
+ * An optional function that is not this-sensitive, expected to be called at
+ * bottom of stack to start a new turn.
+ *
+ * @typedef {((...args: any[]) => any) | undefined} TurnStarterFn
+ */

package/src/types.d.ts

@@ -0,0 +1,44 @@
+export type PromiseVow<T> = PromiseLike<T | Vow<T>>;
+export type ERef<T> = import('./E').ERef<T>;
+/**
+ * Creates a type that accepts both near and marshalled references that were
+ * returned from `Remotable` or `Far`, and also promises for such references.
+ */
+export type FarRef<Primary, Local = import("./E").DataOnly<Primary>> = ERef<Local & import('@endo/eventual-send').RemotableBrand<Local, Primary>>;
+/**
+ * The first version of the vow implementation
+ * object.  CAVEAT: These methods must never be changed or added to, to provide
+ * forward/backward compatibility.  Create a new object and bump its version
+ * number instead.
+ */
+export type VowV0<T = any> = {
+    /**
+     * Attempt to unwrap all vows in this
+     * promise chain, returning a promise for the final value.  A rejection may
+     * indicate a temporary routing failure requiring a retry, otherwise that the
+     * decider of the terminal promise rejected it.
+     */
+    shorten: () => Promise<T>;
+};
+export type VowPayload<T = any> = {
+    vowV0: import('@endo/eventual-send').FarRef<VowV0<T>>;
+};
+export type Vow<T = any> = import('@endo/pass-style').CopyTagged<'Vow', VowPayload<T>>;
+export type VowKit<T = any> = {
+    vow: Vow<T>;
+    resolver: VowResolver<T>;
+};
+export type VowPromiseKit<T = any> = {
+    vow: Vow<T>;
+    resolver: VowResolver<T>;
+    promise: Promise<T>;
+};
+export type VowResolver<T = any> = {
+    resolve(value?: T | PromiseVow<T>): void;
+    reject(reason?: any): void;
+};
+export type Watcher<T = any, TResult1 = T, TResult2 = T> = {
+    onFulfilled?: ((value: T) => Vow<TResult1> | PromiseVow<TResult1> | TResult1) | undefined;
+    onRejected?: ((reason: any) => Vow<TResult2> | PromiseVow<TResult2> | TResult2) | undefined;
+};
+//# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"4BAKa,YAAY,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;sBAKvB,OAAO,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;;;;;uEASrB,KAAK,KAAK,GAAG,OAAO,qBAAqB,EAAE,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;;;;;;;;;;;;;;aAUzE,MAAM,QAAQ,CAAC,CAAC;;;WAShB,OAAO,qBAAqB,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;;2BAK/C,OAAO,kBAAkB,EAAE,UAAU,CACjD,KAAS,EAAE,WAAW,CAAC,CAAC,CACrB;8BAKS;IACZ,GAAO,EAAE,IAAI,CAAC,CAAC,CAAC;IAChB,QAAY,EAAE,YAAY,CAAC,CAAC,CAAC;CAC1B;qCAKS;IACZ,GAAO,EAAE,IAAI,CAAC,CAAC,CAAC;IAChB,QAAY,EAAE,YAAY,CAAC,CAAC,CAAC;IAC7B,OAAW,EAAE,QAAQ,CAAC,CAAC,CAAA;CACpB;;oBAK2B,CAAC,GAAG,WAAW,CAAC,CAAC,GAAG,IAAI;oBAAkB,GAAG,GAAG,IAAI;;;2BAQ7D,CAAC,KAAK,IAAI,QAAQ,CAAC,GAAG,WAAW,QAAQ,CAAC,GAAG,QAAQ;2BACpD,GAAG,KAAK,IAAI,QAAQ,CAAC,GAAG,WAAW,QAAQ,CAAC,GAAG,QAAQ"}

package/src/types.js

@@ -0,0 +1,78 @@
+// @ts-check
+export {};
+
+/**
+ * @template T
+ * @typedef {PromiseLike<T | Vow<T>>} PromiseVow
+ */
+
+/**
+ * @template T
+ * @typedef {import('./E').ERef<T>} ERef
+ */
+
+/**
+ * Creates a type that accepts both near and marshalled references that were
+ * returned from `Remotable` or `Far`, and also promises for such references.
+ *
+ * @template Primary The type of the primary reference.
+ * @template [Local=import('./E').DataOnly<Primary>] The local properties of the object.
+ * @typedef {ERef<Local & import('@endo/eventual-send').RemotableBrand<Local, Primary>>} FarRef
+ */
+
+/**
+ * @template [T=any]
+ * @typedef {object} VowV0 The first version of the vow implementation
+ * object.  CAVEAT: These methods must never be changed or added to, to provide
+ * forward/backward compatibility.  Create a new object and bump its version
+ * number instead.
+ *
+ * @property {() => Promise<T>} shorten Attempt to unwrap all vows in this
+ * promise chain, returning a promise for the final value.  A rejection may
+ * indicate a temporary routing failure requiring a retry, otherwise that the
+ * decider of the terminal promise rejected it.
+ */
+
+/**
+ * @template [T=any]
+ * @typedef {object} VowPayload
+ * @property {import('@endo/eventual-send').FarRef<VowV0<T>>} vowV0
+ */
+
+/**
+ * @template [T=any]
+ * @typedef {import('@endo/pass-style').CopyTagged<
+ *   'Vow', VowPayload<T>
+ * >} Vow
+ */
+
+/**
+ * @template [T=any]
+ * @typedef {{
+ *   vow: Vow<T>,
+ *   resolver: VowResolver<T>,
+ * }} VowKit
+ */
+
+/**
+ * @template [T=any]
+ * @typedef {{
+ *   vow: Vow<T>,
+ *   resolver: VowResolver<T>,
+ *   promise: Promise<T>
+ * }} VowPromiseKit
+ */
+
+/**
+ * @template [T=any]
+ * @typedef {{ resolve(value?: T | PromiseVow<T>): void, reject(reason?: any): void }} VowResolver
+ */
+
+/**
+ * @template [T=any]
+ * @template [TResult1=T]
+ * @template [TResult2=T]
+ * @typedef {object} Watcher
+ * @property {(value: T) => Vow<TResult1> | PromiseVow<TResult1> | TResult1} [onFulfilled]
+ * @property {(reason: any) => Vow<TResult2> | PromiseVow<TResult2> | TResult2} [onRejected]
+ */

package/src/vow-utils.d.ts

@@ -0,0 +1,4 @@
+export { basicE };
+export function getVowPayload<T>(specimen: any): import("./types").VowPayload<T> | undefined;
+import { E as basicE } from '@endo/eventual-send';
+//# sourceMappingURL=vow-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vow-utils.d.ts","sourceRoot":"","sources":["vow-utils.js"],"names":[],"mappings":";AAoBO,2CAHI,GAAG,+CAgBb;4BAhC2B,qBAAqB"}

package/src/vow-utils.js

@@ -0,0 +1,34 @@
+// @ts-check
+import { E as basicE } from '@endo/eventual-send';
+import { getTag, passStyleOf } from '@endo/pass-style';
+
+// TODO: `isPassable` should come from @endo/pass-style
+import { isPassable } from '@agoric/base-zone';
+
+export { basicE };
+
+/**
+ * A vow is a passable tagged as 'Vow'.  Its payload is a record with
+ * API-versioned remotables.  payload.vowV0 is the API for the `watch` and
+ * `when` operators to use for retriable shortening of the vow chain.
+ *
+ * If the specimen is a Vow, return its payload, otherwise undefined.
+ *
+ * @template T
+ * @param {any} specimen any value to verify as a vow
+ * @returns {import('./types').VowPayload<T> | undefined} undefined if specimen is not a vow, otherwise the vow's payload.
+ */
+export const getVowPayload = specimen => {
+  const isVow =
+    isPassable(specimen) &&
+    passStyleOf(specimen) === 'tagged' &&
+    getTag(specimen) === 'Vow';
+  if (!isVow) {
+    return undefined;
+  }
+
+  const vow = /** @type {import('./types').Vow<T>} */ (
+    /** @type {unknown} */ (specimen)
+  );
+  return vow.payload;
+};

package/src/vow.d.ts

@@ -0,0 +1,3 @@
+export function prepareVowKit(zone: import('@agoric/base-zone').Zone, watchPromise?: ((p: Promise<any>, watcher: import("./watch-promise.js").PromiseWatcher, ...watcherArgs: unknown[]) => void) | undefined): <T>() => import("./types.js").VowKit<T>;
+export type VowEphemera = Partial<import('@endo/promise-kit').PromiseKit<any>> & Pick<import('@endo/promise-kit').PromiseKit<any>, 'promise'>;
+//# sourceMappingURL=vow.d.ts.map

package/src/vow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vow.d.ts","sourceRoot":"","sources":["vow.js"],"names":[],"mappings":"AAkBO,oCAHI,OAAO,mBAAmB,EAAE,IAAI,oLAwH1C;0BA7HY,QAAQ,OAAO,mBAAmB,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC,GAChE,KAAS,OAAO,mBAAmB,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC"}

package/src/vow.js

@@ -0,0 +1,138 @@
+// @ts-check
+import { makePromiseKit } from '@endo/promise-kit';
+import { M } from '@endo/patterns';
+import { makeTagged } from '@endo/pass-style';
+import { PromiseWatcherI, watchPromiseShim } from './watch-promise.js';
+
+const sink = () => {};
+harden(sink);
+
+/**
+ * @typedef {Partial<import('@endo/promise-kit').PromiseKit<any>> &
+ *   Pick<import('@endo/promise-kit').PromiseKit<any>, 'promise'>} VowEphemera
+ */
+
+/**
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {typeof watchPromiseShim} [watchPromise]
+ */
+export const prepareVowKit = (zone, watchPromise = watchPromiseShim) => {
+  /** @type {WeakMap<import('./types.js').VowResolver, VowEphemera>} */
+  const resolverToEphemera = new WeakMap();
+
+  /**
+   * Get the current incarnation's promise kit associated with a vowV0.
+   *
+   * @param {import('./types.js').VowResolver} resolver
+   */
+  const provideCurrentKit = resolver => {
+    let pk = resolverToEphemera.get(resolver);
+    if (pk) {
+      return pk;
+    }
+
+    pk = makePromiseKit();
+    pk.promise.catch(sink); // silence unhandled rejection
+    resolverToEphemera.set(resolver, pk);
+    return pk;
+  };
+
+  /**
+   * @param {import('./types.js').VowResolver} resolver
+   */
+  const getPromiseKitForResolution = resolver => {
+    const kit = provideCurrentKit(resolver);
+    if (kit.resolve) {
+      // Resolution is a one-time event, so forget the resolve/reject functions.
+      resolverToEphemera.set(resolver, harden({ promise: kit.promise }));
+    }
+    return kit;
+  };
+
+  const makeVowInternalsKit = zone.exoClassKit(
+    'VowInternalsKit',
+    {
+      vowV0: M.interface('VowV0', {
+        shorten: M.call().returns(M.promise()),
+      }),
+      resolver: M.interface('VowResolver', {
+        resolve: M.call().optional(M.any()).returns(),
+        reject: M.call().optional(M.any()).returns(),
+      }),
+      watchNextStep: PromiseWatcherI,
+    },
+    () => ({
+      value: undefined,
+      // The stepStatus is null if the promise step hasn't settled yet.
+      stepStatus: /** @type {null | 'fulfilled' | 'rejected'} */ (null),
+    }),
+    {
+      vowV0: {
+        /**
+         * @returns {Promise<any>}
+         */
+        async shorten() {
+          const { stepStatus, value } = this.state;
+          switch (stepStatus) {
+            case 'fulfilled':
+              return value;
+            case 'rejected':
+              throw value;
+            case null:
+              return provideCurrentKit(this.facets.resolver).promise;
+            default:
+              throw new TypeError(`unexpected stepStatus ${stepStatus}`);
+          }
+        },
+      },
+      resolver: {
+        /**
+         * @param {any} [value]
+         */
+        resolve(value) {
+          const { resolver } = this.facets;
+          const { promise, resolve } = getPromiseKitForResolution(resolver);
+          if (resolve) {
+            resolve(value);
+            watchPromise(promise, this.facets.watchNextStep);
+          }
+        },
+        /**
+         * @param {any} [reason]
+         */
+        reject(reason) {
+          const { resolver, watchNextStep } = this.facets;
+          const { reject } = getPromiseKitForResolution(resolver);
+          if (reject) {
+            reject(reason);
+            watchNextStep.onRejected(reason);
+          }
+        },
+      },
+      watchNextStep: {
+        onFulfilled(value) {
+          this.state.stepStatus = 'fulfilled';
+          this.state.value = value;
+        },
+        onRejected(reason) {
+          this.state.stepStatus = 'rejected';
+          this.state.value = reason;
+        },
+      },
+    },
+  );
+
+  /**
+   * @template T
+   * @returns {import('./types.js').VowKit<T>}
+   */
+  const makeVowKit = () => {
+    const { resolver, vowV0 } = makeVowInternalsKit();
+    const vow = makeTagged('Vow', harden({ vowV0 }));
+    return harden({ resolver, vow });
+  };
+
+  return makeVowKit;
+};
+
+harden(prepareVowKit);

package/src/watch-promise.d.ts

@@ -0,0 +1,10 @@
+export const PromiseWatcherI: import("@endo/patterns").InterfaceGuard<{
+    onFulfilled: import("@endo/patterns").MethodGuard;
+    onRejected: import("@endo/patterns").MethodGuard;
+}>;
+export function watchPromiseShim(p: Promise<any>, watcher: PromiseWatcher, ...watcherArgs: unknown[]): void;
+export type PromiseWatcher = {
+    onFulfilled?: ((fulfilment: unknown, ...args: unknown[]) => void) | undefined;
+    onRejected?: ((reason: unknown, ...args: unknown[]) => void) | undefined;
+};
+//# sourceMappingURL=watch-promise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"watch-promise.d.ts","sourceRoot":"","sources":["watch-promise.js"],"names":[],"mappings":"AASA;;;GAGG;AAuCI,oCALI,QAAQ,GAAG,CAAC,WACZ,cAAc,kBACX,OAAO,KACR,IAAI,CAUhB;;gCA3C0B,OAAO,WAAW,OAAO,EAAE,KAAK,IAAI;2BACxC,OAAO,WAAW,OAAO,EAAE,KAAK,IAAI"}

package/src/watch-promise.js

@@ -0,0 +1,61 @@
+// @ts-check
+import { M } from '@endo/patterns';
+
+import { basicE } from './vow-utils.js';
+
+const { Fail } = assert;
+
+const { apply } = Reflect;
+
+export const PromiseWatcherI = M.interface('PromiseWatcher', {
+  onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+  onRejected: M.call(M.any()).rest(M.any()).returns(),
+});
+
+/**
+ * @typedef {object} PromiseWatcher
+ * @property {(fulfilment: unknown, ...args: unknown[]) => void} [onFulfilled]
+ * @property {(reason: unknown, ...args: unknown[]) => void} [onRejected]
+ */
+
+/**
+ * Adapt a promise watcher method to E.when.
+ * @param {Record<PropertyKey, (...args: unknown[]) => unknown>} that
+ * @param {PropertyKey} prop
+ * @param {unknown[]} postArgs
+ */
+const callMeMaybe = (that, prop, postArgs) => {
+  const fn = that[prop];
+  if (!fn) {
+    return undefined;
+  }
+  assert.typeof(fn, 'function');
+  /**
+   * @param {unknown} arg value or reason
+   */
+  const wrapped = arg => {
+    // Don't return a value, to prevent E.when from subscribing to a resulting
+    // promise.
+    apply(fn, that, [arg, ...postArgs]);
+  };
+  return wrapped;
+};
+
+/**
+ * Shim the promise watcher behaviour when VatData.watchPromise is not available.
+ *
+ * @param {Promise<any>} p
+ * @param {PromiseWatcher} watcher
+ * @param {...unknown} watcherArgs
+ * @returns {void}
+ */
+export const watchPromiseShim = (p, watcher, ...watcherArgs) => {
+  Promise.resolve(p) === p || Fail`watchPromise only watches promises`;
+  const onFulfilled = callMeMaybe(watcher, 'onFulfilled', watcherArgs);
+  const onRejected = callMeMaybe(watcher, 'onRejected', watcherArgs);
+  onFulfilled ||
+    onRejected ||
+    Fail`promise watcher must implement at least one handler method`;
+  void basicE.when(p, onFulfilled, onRejected);
+};
+harden(watchPromiseShim);

package/src/watch.d.ts

@@ -0,0 +1,3 @@
+export function prepareWatch(zone: import('@agoric/base-zone').Zone, makeVowKit: () => import('./types.js').VowKit<any>, watchPromise?: ((p: Promise<any>, watcher: import("./watch-promise.js").PromiseWatcher, ...watcherArgs: unknown[]) => void) | undefined, isRetryableReason?: ((reason: any) => boolean) | undefined): <T = any, TResult1 = T, TResult2 = T>(specimenP: import("./types.js").ERef<T | import("./types.js").Vow<T>>, watcher?: import("./types.js").Watcher<T, TResult1, TResult2> | undefined, watcherContext?: unknown) => import("./types.js").Vow<TResult1 | TResult2>;
+export type Watch = ReturnType<typeof prepareWatch>;
+//# sourceMappingURL=watch.d.ts.map

package/src/watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["watch.js"],"names":[],"mappings":"AAqHO,mCALI,OAAO,mBAAmB,EAAE,IAAI,cAChC,MAAM,OAAO,YAAY,EAAE,MAAM,CAAC,GAAG,CAAC,yKAE7B,GAAG,KAAK,OAAO,yNAqBtB,OAAO,mDAsBnB;oBAIa,WAAW,mBAAmB,CAAC"}