@agoric/async-flow 0.1.1-dev-24665a9.0 → 0.1.1-dev-a035bbe.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/async-flow",
-  "version": "0.1.1-dev-24665a9.0+24665a9",
+  "version": "0.1.1-dev-a035bbe.0+a035bbe",
   "description": "Upgrade async functions at await points by replay",
   "type": "module",
   "repository": "https://github.com/Agoric/agoric-sdk",
@@ -24,9 +24,9 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/base-zone": "0.1.1-dev-24665a9.0+24665a9",
-    "@agoric/store": "0.9.3-dev-24665a9.0+24665a9",
-    "@agoric/vow": "0.1.1-dev-24665a9.0+24665a9",
+    "@agoric/base-zone": "0.1.1-dev-a035bbe.0+a035bbe",
+    "@agoric/store": "0.9.3-dev-a035bbe.0+a035bbe",
+    "@agoric/vow": "0.1.1-dev-a035bbe.0+a035bbe",
     "@endo/common": "^1.2.2",
     "@endo/errors": "^1.2.2",
     "@endo/eventual-send": "^1.2.2",
@@ -36,9 +36,9 @@
     "@endo/promise-kit": "^1.1.2"
   },
   "devDependencies": {
-    "@agoric/internal": "0.3.3-dev-24665a9.0+24665a9",
-    "@agoric/swingset-liveslots": "0.10.3-dev-24665a9.0+24665a9",
-    "@agoric/zone": "0.2.3-dev-24665a9.0+24665a9",
+    "@agoric/internal": "0.3.3-dev-a035bbe.0+a035bbe",
+    "@agoric/swingset-liveslots": "0.10.3-dev-a035bbe.0+a035bbe",
+    "@agoric/zone": "0.2.3-dev-a035bbe.0+a035bbe",
     "@endo/env-options": "^1.1.4",
     "@endo/ses-ava": "^1.2.2",
     "ava": "^5.3.0"
@@ -62,5 +62,5 @@
   "typeCoverage": {
     "atLeast": 77.83
   },
-  "gitHead": "24665a97248b854fcb01185d360429301470ed57"
+  "gitHead": "a035bbe9d3a46247ed2199e4ca707103a9e04bfd"
 }

package/src/async-flow.d.ts

@@ -15,8 +15,8 @@ export function prepareAsyncFlowTools(outerZone: Zone, outerOptions?: Preparatio
              */
             restart(eager?: boolean | undefined): void;
             wake(): void;
-            getOutcome(): Vow<any>;
-            dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
+            getOutcome(): import("@agoric/vow").Vow<any>;
+            dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
             getOptFatalProblem(): any;
         };
         admin: {
@@ -33,7 +33,7 @@ export function prepareAsyncFlowTools(outerZone: Zone, outerOptions?: Preparatio
         startEager?: boolean;
     } | undefined) => HostAsyncFuncWrapper;
     adminAsyncFlow: import("@endo/exo").Guarded<{
-        getFailures(): import("@endo/patterns").CopyMap<any, Passable>;
+        getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
         wakeAll(): void;
         getFlowForOutcomeVow(outcomeVow: any): any;
     }>;
@@ -56,8 +56,8 @@ export type AsyncFlowTools = ReturnType<(outerZone: Zone, outerOptions?: Prepara
              */
             restart(eager?: boolean | undefined): void;
             wake(): void;
-            getOutcome(): Vow<any>;
-            dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
+            getOutcome(): import("@agoric/vow").Vow<any>;
+            dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
             getOptFatalProblem(): any;
         };
         admin: {
@@ -74,7 +74,7 @@ export type AsyncFlowTools = ReturnType<(outerZone: Zone, outerOptions?: Prepara
         startEager?: boolean | undefined;
     } | undefined) => HostAsyncFuncWrapper;
     adminAsyncFlow: import("@endo/exo").Guarded<{
-        getFailures(): import("@endo/patterns").CopyMap<any, Passable>;
+        getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
         wakeAll(): void;
         getFlowForOutcomeVow(outcomeVow: any): any;
     }>;
@@ -84,4 +84,9 @@ export type AdminAsyncFlow = AsyncFlowTools["adminAsyncFlow"];
 export type MakeAsyncFlowKit = ReturnType<AsyncFlowTools["prepareAsyncFlowKit"]>;
 export type AsyncFlowKit = ReturnType<MakeAsyncFlowKit>;
 export type AsyncFlow = AsyncFlowKit["flow"];
+import type { Zone } from '@agoric/base-zone';
+import type { PreparationOptions } from '../src/types.js';
+import type { GuestAsyncFunc } from '../src/types.js';
+import type { FlowState } from '../src/types.js';
+import type { HostAsyncFuncWrapper } from '../src/types.js';
 //# sourceMappingURL=async-flow.d.ts.map

package/src/async-flow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"async-flow.d.ts","sourceRoot":"","sources":["async-flow.js"],"names":[],"mappings":"AA4CO;2CAuCM,MAAM,kBACN,cAAc;qBACC,OAAO;;;YA4BzB;;eAEG;4BADU,SAAS;YAkCtB;;;;;eAKG;;;;;;;;;;;;;;;;;iCAkRA,MAAM,aACN,cAAc;qBACC,OAAO;sBACpB,oBAAoB;;;;;;;EAkDlC;6BAIY,UAAU;2CAjZV,MAAM,kBACN,cAAc;;;;YA6BjB;;eAEG;;YAiCH;;;;;eAKG;;;;;;;;;;;;;;;;;iCAkRA,MAAM,aACN,cAAc;;;;;;;;;EAwDmB;6BAIjC,cAAc,CAAC,gBAAgB,CAAC;+BAIhC,UAAU,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC;2BAIjD,UAAU,CAAC,gBAAgB,CAAC;wBAI5B,YAAY,CAAC,MAAM,CAAC"}
+{"version":3,"file":"async-flow.d.ts","sourceRoot":"","sources":["async-flow.js"],"names":[],"mappings":"AAmDO;2CAuCM,MAAM;qBAES,OAAO;;;YA4BzB;;eAEG;;YAiCH;;;;;eAKG;;;;;;;;;;;;;;;;;iCAkRA,MAAM;qBAES,OAAO;;;;;;;;EAmDlC;6BAIY,UAAU;2CAjZV,MAAM;;;;YA8BT;;eAEG;;YAiCH;;;;;eAKG;;;;;;;;;;;;;;;;;iCAkRA,MAAM;;;;;;;;;EAyD2B;6BAIjC,cAAc,CAAC,gBAAgB,CAAC;+BAIhC,UAAU,CAAC,cAAc,CAAC,qBAAqB,CAAC,CAAC;2BAIjD,UAAU,CAAC,gBAAgB,CAAC;wBAI5B,YAAY,CAAC,MAAM,CAAC;0BA7eV,mBAAmB;wCAI4C,iBAAiB;oCAAjB,iBAAiB;+BAAjB,iBAAiB;0CAAjB,iBAAiB"}

package/src/async-flow.js

@@ -10,7 +10,14 @@ import { prepareBijection } from './bijection.js';
 import { LogEntryShape, FlowStateShape } from './type-guards.js';
 
 /**
- * @import { WeakMapStore } from '@agoric/store'
+ * @import {WeakMapStore} from '@agoric/store'
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {MapStore} from '@agoric/store';
+ * @import {LogStore} from '../src/log-store.js';
+ * @import {Bijection} from '../src/bijection.js';
+ * @import {FlowState, GuestAsyncFunc, HostAsyncFuncWrapper, PreparationOptions} from '../src/types.js';
+ * @import {ReplayMembrane} from '../src/replay-membrane.js';
  */
 
 const { defineProperties } = Object;

package/src/bijection.d.ts

@@ -25,4 +25,5 @@ export type Bijection = ReturnType<ReturnType<(zone: Zone) => () => import("@end
     guestToHost(g: any): any;
     hostToGuest(h: any): any;
 }>>>;
+import type { Zone } from '@agoric/base-zone';
 //# sourceMappingURL=bijection.d.ts.map

package/src/bijection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bijection.d.ts","sourceRoot":"","sources":["bijection.js"],"names":[],"mappings":"AA0DO;;;;;;;;GAoEN;0BAzEa,UAAU,QAhCb,MAAM;;;;;;;;GAgCwB;wBA6E5B,UAAU,CAAC,UAAU;;;;;;;;GAAkB,CAAC"}
+{"version":3,"file":"bijection.d.ts","sourceRoot":"","sources":["bijection.js"],"names":[],"mappings":"AAgEO;;;;;;;;GAoEN;0BAzEa,UAAU,QAhCb,MAAM;;;;;;;;GAgCwB;wBA6E5B,UAAU,CAAC,UAAU;;;;;;;;GAAkB,CAAC;0BAhI9B,mBAAmB"}

package/src/bijection.js

@@ -4,6 +4,12 @@ import { Far } from '@endo/pass-style';
 import { toPassableCap } from '@agoric/vow';
 import { makeEphemera } from './ephemera.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Ephemera} from './types.js';
+ */
+
 const BijectionI = M.interface('Bijection', {
   reset: M.call().returns(),
   init: M.call(M.any(), M.any()).returns(),

package/src/convert.d.ts

@@ -2,4 +2,5 @@ export function makeConvertKit(bijection: any, makeGuestForHostRemotable: any, m
     guestToHost: (specimen: Passable, label?: string | undefined) => any;
     hostToGuest: (specimen: Passable, label?: string | undefined) => any;
 };
+import type { Passable } from '@endo/pass-style';
 //# sourceMappingURL=convert.d.ts.map

package/src/convert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["convert.js"],"names":[],"mappings":"AA2EO;;;EAsDN"}
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["convert.js"],"names":[],"mappings":"AA+EO;;;EAsDN;8BAxH0B,kBAAkB"}

package/src/convert.js

@@ -10,6 +10,10 @@ import {
 import { isVow } from '@agoric/vow/src/vow-utils.js';
 import { objectMap } from '@endo/common/object-map.js';
 
+/**
+ * @import {Passable} from '@endo/pass-style'
+ */
+
 const makeConvert = (convertRemotable, convertPromiseOrVow, convertError) => {
   const convertRecur = (specimen, label) => {
     // Open code the synchronous part of applyLabelingError, because

package/src/ephemera.d.ts

@@ -1,2 +1,3 @@
 export function makeEphemera<S extends WeakKey = WeakKey, V extends unknown = any>(reinit: (self: S) => V): Ephemera<S, V>;
+import type { Ephemera } from './types.js';
 //# sourceMappingURL=ephemera.d.ts.map

package/src/ephemera.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ephemera.d.ts","sourceRoot":"","sources":["ephemera.js"],"names":[],"mappings":"AAkBO,6BAFe,CAAC,4BAAC,CAAC,gCADd,CAAC,IAAI,EACM,CAAC,AADJ,KACK,CAAC,AADA,GACZ,QAAQ,CAAC,CAAC,EAAC,CAAC,CAAC,CAiBzB"}
+{"version":3,"file":"ephemera.d.ts","sourceRoot":"","sources":["ephemera.js"],"names":[],"mappings":"AAwBO,6BAFe,CAAC,4BAAC,CAAC,gCADd,CAAC,IAAI,EACM,CAAC,AADJ,KACK,CAAC,AADA,kBAkBxB;8BApC0B,YAAY"}

package/src/ephemera.js

@@ -1,3 +1,9 @@
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Ephemera} from './types.js';
+ */
+
 /**
  * Used by a possibly-durable exo to store per-instance ephemeral state.
  * Each ephemera is created at the exo class prepare level, and then

package/src/log-store.d.ts

@@ -7,7 +7,7 @@ export function prepareLogStore(zone: Zone): () => import("@endo/exo").Guarded<{
     peekEntry(): LogEntry;
     nextEntry(): LogEntry;
     pushEntry(entry: any): number;
-    dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
+    dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
     promiseReplayDone(): Promise<undefined>;
 }>;
 export type LogStore = ReturnType<ReturnType<(zone: Zone) => () => import("@endo/exo").Guarded<{
@@ -19,7 +19,9 @@ export type LogStore = ReturnType<ReturnType<(zone: Zone) => () => import("@endo
     peekEntry(): LogEntry;
     nextEntry(): LogEntry;
     pushEntry(entry: any): number;
-    dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
+    dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
     promiseReplayDone(): Promise<undefined>;
 }>>>;
+import type { Zone } from '@agoric/base-zone';
+import type { LogEntry } from './types.js';
 //# sourceMappingURL=log-store.d.ts.map

package/src/log-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-store.d.ts","sourceRoot":"","sources":["log-store.js"],"names":[],"mappings":"AA4BO;;;;;;;;;;;GAoIN;uBAGY,UAAU,CAAC,UAAU;;;;;;;;;;;GAAiB,CAAC"}
+{"version":3,"file":"log-store.d.ts","sourceRoot":"","sources":["log-store.js"],"names":[],"mappings":"AA+BO;;;;;;;;;;;GAoIN;uBAGY,UAAU,CAAC,UAAU;;;;;;;;;;;GAAiB,CAAC;0BA9J7B,mBAAmB;8BAEL,YAAY"}

package/src/log-store.js

@@ -5,7 +5,10 @@ import { LogEntryShape } from './type-guards.js';
 import { makeEphemera } from './ephemera.js';
 
 /**
- * @import {MapStore} from '@agoric/store'
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {MapStore} from '@agoric/store';
+ * @import {Ephemera, LogEntry} from './types.js';
  */
 
 const LogStoreI = M.interface('LogStore', {

package/src/replay-membrane.d.ts

@@ -7,7 +7,7 @@ export function makeReplayMembrane(log: import("@endo/exo").Guarded<{
     peekEntry(): LogEntry;
     nextEntry(): LogEntry;
     pushEntry(entry: any): number;
-    dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
+    dump(): ([op: "doFulfill", vow: Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
     promiseReplayDone(): Promise<undefined>;
 }>, bijection: import("@endo/exo").Guarded<{
     reset(): void;
@@ -19,33 +19,17 @@ export function makeReplayMembrane(log: import("@endo/exo").Guarded<{
     hostToGuest(h: any): any;
 }>, vowTools: {
     when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    /**
-     * When replaying, this comes from interpreting the log.
-     * Otherwise, it is triggered by a watcher watching hostVow,
-     * that must also log it.
-     *
-     * @param {HostVow} hostVow
-     * @param {Host} hostFulfillment
-     */
     watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
-    /**
-     * When replaying, this comes from interpreting the log.
-     * Otherwise, it is triggered by a watcher watching hostVow,
-     * that must also log it.
-     *
-     * @param {HostVow} hostVow
-     * @param {Host} hostFulfillment
-     */
     makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
     allVows: (vows: unknown[]) => Vow<any[]>;
 }, watchWake: (vowish: Promise<any> | Vow) => void, panic: (problem: Error) => never): {
-    hostToGuest: (specimen: Passable, label?: string | undefined) => any;
-    guestToHost: (specimen: Passable, label?: string | undefined) => any;
+    hostToGuest: (specimen: import("@endo/pass-style").Passable, label?: string | undefined) => any;
+    guestToHost: (specimen: import("@endo/pass-style").Passable, label?: string | undefined) => any;
     wake: () => void;
     stop: () => void;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
-    hostToGuest: (specimen: Passable, label?: string | undefined) => any;
-    guestToHost: (specimen: Passable, label?: string | undefined) => any;
+    hostToGuest: (specimen: import("@endo/pass-style").Passable, label?: string | undefined) => any;
+    guestToHost: (specimen: import("@endo/pass-style").Passable, label?: string | undefined) => any;
     wake: () => void;
     stop: () => void;
 }>;
@@ -58,7 +42,7 @@ export type ReplayMembrane = ReturnType<(log: import("@endo/exo").Guarded<{
     peekEntry(): LogEntry;
     nextEntry(): LogEntry;
     pushEntry(entry: any): number;
-    dump(): ([op: "doFulfill", vow: Vow<Passable>, fulfillment: Passable] | [op: "doReject", vow: Vow<Passable>, reason: Passable] | [op: "doReturn", callIndex: number, result: Passable] | [op: "doThrow", callIndex: number, problem: Passable] | [op: "checkCall", target: Passable, optVerb: PropertyKey | undefined, args: Passable[], callIndex: number])[];
+    dump(): ([op: "doFulfill", vow: Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
     promiseReplayDone(): Promise<undefined>;
 }>, bijection: import("@endo/exo").Guarded<{
     reset(): void;
@@ -70,34 +54,20 @@ export type ReplayMembrane = ReturnType<(log: import("@endo/exo").Guarded<{
     hostToGuest(h: any): any;
 }>, vowTools: {
     when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    /**
-     * When replaying, this comes from interpreting the log.
-     * Otherwise, it is triggered by a watcher watching hostVow,
-     * that must also log it.
-     *
-     * @param {HostVow} hostVow
-     * @param {Host} hostFulfillment
-     */
     watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
-    /**
-     * When replaying, this comes from interpreting the log.
-     * Otherwise, it is triggered by a watcher watching hostVow,
-     * that must also log it.
-     *
-     * @param {HostVow} hostVow
-     * @param {Host} hostFulfillment
-     */
     makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
     allVows: (vows: unknown[]) => Vow<any[]>;
 }, watchWake: (vowish: Promise<any> | Vow) => void, panic: (problem: Error) => never) => {
-    hostToGuest: (specimen: Passable, label?: string | undefined) => any;
-    guestToHost: (specimen: Passable, label?: string | undefined) => any;
+    hostToGuest: (specimen: import("@endo/pass-style").Passable, label?: string | undefined) => any;
+    guestToHost: (specimen: import("@endo/pass-style").Passable, label?: string | undefined) => any;
     wake: () => void;
     stop: () => void;
 } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
-    hostToGuest: (specimen: Passable, label?: string | undefined) => any;
-    guestToHost: (specimen: Passable, label?: string | undefined) => any;
+    hostToGuest: (specimen: import("@endo/pass-style").Passable, label?: string | undefined) => any;
+    guestToHost: (specimen: import("@endo/pass-style").Passable, label?: string | undefined) => any;
     wake: () => void;
     stop: () => void;
 }>>;
+import type { LogEntry } from '../src/types.js';
+import type { Vow } from '@agoric/vow';
 //# sourceMappingURL=replay-membrane.d.ts.map

package/src/replay-membrane.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replay-membrane.d.ts","sourceRoot":"","sources":["replay-membrane.js"],"names":[],"mappings":"AAqBO;;;;;;;;;;;;;;;;;;;;wFATuC,CAAC;IA4B7C;;;;;;;OAOG;;IAPH;;;;;;;OAOG;;oBAbM,SAAS;8CAhBkB,IAAI,SAC/B,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;;;;;;;;;;GAqdnC;6BAGa,UAAU;;;;;;;;;;;;;;;;;;;;wFA/dsB,CAAC;IA4B7C;;;;;;;OAOG;;IAPH;;;;;;;OAOG;;oBAbM,SAAS;2DAfT,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;;;;;;;;;;GAwdQ"}
+{"version":3,"file":"replay-membrane.d.ts","sourceRoot":"","sources":["replay-membrane.js"],"names":[],"mappings":"AA2BO;;;;;;;;;;;;;;;;;;;;wFAhBA,CAAC;;;oBAaG,SAAS;8CAAkB,IAAI,SAC/B,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;;;;;;;;;;GAqdnC;6BAGa,UAAU;;;;;;;;;;;;;;;;;;;;wFAtejB,CAAC;;;oBAaG,SAAS;2DACT,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;;;;;;;;;;GAwdQ;8BAleO,iBAAiB;yBAJpC,aAAa"}

package/src/replay-membrane.js

@@ -8,6 +8,12 @@ import { makeConvertKit } from './convert.js';
 
 /**
  * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Vow, VowTools} from '@agoric/vow'
+ * @import {AsyncFlow} from '../src/async-flow.js'
+ * @import {LogStore} from '../src/log-store.js';
+ * @import {Bijection} from '../src/bijection.js';
+ * @import {Host, HostVow, LogEntry, Outcome} from '../src/types.js';
  */
 
 const { fromEntries, defineProperties, assign } = Object;

package/src/types.d.ts

@@ -1,16 +1,16 @@
-type FlowState = "Running" | "Sleeping" | "Replaying" | "Failed" | "Done";
-type Guest<T extends Passable = Passable> = T;
-type Host<T extends Passable = Passable> = T;
+export type FlowState = "Running" | "Sleeping" | "Replaying" | "Failed" | "Done";
+export type Guest<T extends Passable = Passable> = T;
+export type Host<T extends Passable = Passable> = T;
 /**
  * A HostVow must be durably storable. It corresponds to an
  * ephemeral guest promise.
  */
-type HostVow<T extends Passable = Passable> = import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
+export type HostVow<T extends Passable = Passable> = import("@endo/pass-style").PassStyled<"tagged", "Vow"> & {
     payload: import("@agoric/vow").VowPayload<T>;
 };
-type GuestAsyncFunc = (...activationArgs: Guest[]) => Guest<Promise<any>>;
-type HostAsyncFuncWrapper = (...activationArgs: Host[]) => HostVow;
-type PreparationOptions = {
+export type GuestAsyncFunc = (...activationArgs: Guest[]) => Guest<Promise<any>>;
+export type HostAsyncFuncWrapper = (...activationArgs: Host[]) => HostVow;
+export type PreparationOptions = {
     vowTools?: {
         when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<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("@agoric/vow").ERef<T_1 | Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
@@ -39,15 +39,15 @@ type PreparationOptions = {
         hostToGuest(h: any): any;
     }>) | undefined;
 };
-type OutcomeKind = "return" | "throw";
-type Outcome = {
+export type OutcomeKind = "return" | "throw";
+export type Outcome = {
     kind: "return";
     result: any;
 } | {
     kind: "throw";
     problem: any;
 };
-type Ephemera<S extends WeakKey = WeakKey, V extends unknown = any> = {
+export type Ephemera<S extends WeakKey = WeakKey, V extends unknown = any> = {
     for: (self: S) => V;
     resetFor: (self: S) => void;
 };
@@ -56,15 +56,9 @@ type Ephemera<S extends WeakKey = WeakKey, V extends unknown = any> = {
  * See comment below for the commented-out typedef for the full
  * membrane log entry, which we do not yet support.
  */
-type LogEntry = [// ///////////////// From Host to Guest /////////////////////////
+export type LogEntry = [// ///////////////// From Host to Guest /////////////////////////
 op: "doFulfill", vow: HostVow, fulfillment: Host] | [op: "doReject", vow: HostVow, reason: Host] | [op: "doReturn", callIndex: number, result: Host] | [op: "doThrow", callIndex: number, problem: Host] | [// ///////////////////// From Guest to Host /////////////////////////
 op: "checkCall", target: Host, optVerb: PropertyKey | undefined, args: Host[], callIndex: number];
-import type { PromiseKit } from '@endo/promise-kit';
 import type { Passable } from '@endo/pass-style';
-import type { Zone } from '@agoric/base-zone';
 import type { Vow } from '@agoric/vow';
-import type { VowTools } from '@agoric/vow';
-import type { LogStore } from './log-store.js';
-import type { Bijection } from './bijection.js';
-import type { ReplayMembrane } from './replay-membrane.js';
 //# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"iBAWa,SAAS,GACrB,UAAsB,GACtB,WAAuB,GACvB,QAAoB,GACpB,MAAkB;WAMN,CAAC,gCAAD,CAAC;UAKD,CAAC,gCAAD,CAAC;;;;;aAQQ,CAAC;;;sBAIV,CAAC,GAAG,cAAc,EAAE,KAAK,EAAE,KAAK,KAAK,cAAS;4BAI9C,CAAC,GAAG,cAAc,EAAE,IAAI,EAAE,KAAK,OAAO;;;4FA1BlD,CAAA;;;wBA0BW,SAAQ;;;;;;;;;;;;;;;;;;;;;;;;mBAWP,QAAQ,GAAC,OAAO;eAIhB;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAC,GAC7B;IAAC,IAAI,EAAE,OAAO,CAAC;IAAE,OAAO,EAAE,GAAG,CAAA;CAAC;cAStB,CAAC,4BADK,CAAC;SAAd,CAAC,IAAI,EACE,CAAC,AADA,KAAK,CAAC;cACd,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI;;;;;;;gBAQlB,CAAE,iEAAiE;AAC/E,EAAQ,EAAE,WAAW,EACrB,GAAS,EAAE,OAAO,EAClB,WAAiB,EAAE,IAAI,CAClB,GAAG,CACR,EAAQ,EAAE,UAAU,EACpB,GAAS,EAAE,OAAO,EAClB,MAAY,EAAE,IAAI,CACb,GAAG,CACR,EAAQ,EAAE,UAAU,EACpB,SAAe,EAAE,MAAM,EACvB,MAAY,EAAE,IAAI,CACb,GAAG,CACR,EAAQ,EAAE,SAAS,EACnB,SAAe,EAAE,MAAM,EACvB,OAAa,EAAE,IAAI,CACd,GAAG,CAAE,qEAAqE;AAC/E,EAAQ,EAAE,WAAW,EACrB,MAAY,EAAE,IAAI,EAClB,OAAa,EAAE,WAAW,GAAC,SAAS,EACpC,IAAU,EAAE,IAAI,EAAE,EAClB,SAAe,EAAE,MAAM,CAClB;gCAhGuB,mBAAmB;8BACrB,kBAAkB;0BACtB,mBAAmB;yBACV,aAAa;8BAAb,aAAa;8BAClB,gBAAgB;+BACf,gBAAgB;oCACX,sBAAsB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"wBAaa,SAAS,GACrB,UAAsB,GACtB,WAAuB,GACvB,QAAoB,GACpB,MAAkB;kBAMN,CAAC,gCAAD,CAAC;iBAKD,CAAC,gCAAD,CAAC;;;;;oBAQQ,CAAC;;;6BAIV,CAAC,GAAG,cAAc,EAAE,KAAK,EAAE,KAAK,KAAK,cAAS;mCAI9C,CAAC,GAAG,cAAc,EAAE,IAAI,EAAE,KAAK,OAAO;;;4FA1B1C,CAAC;;;wBA0BU,SAAS;;;;;;;;;;;;;;;;;;;;;;;;0BAWhB,QAAQ,GAAC,OAAO;sBAIhB;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAC,GAC7B;IAAC,IAAI,EAAE,OAAO,CAAC;IAAE,OAAO,EAAE,GAAG,CAAA;CAAC;qBAStB,CAAC,4BADK,CAAC;SAAd,CAAC,IAAI,EACE,CAAC,AADA,KAAK,CAAC;cACd,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI;;;;;;;uBAQlB,CAAE,iEAAiE;AAC/E,EAAQ,EAAE,WAAW,EACrB,GAAS,EAAE,OAAO,EAClB,WAAiB,EAAE,IAAI,CAClB,GAAG,CACR,EAAQ,EAAE,UAAU,EACpB,GAAS,EAAE,OAAO,EAClB,MAAY,EAAE,IAAI,CACb,GAAG,CACR,EAAQ,EAAE,UAAU,EACpB,SAAe,EAAE,MAAM,EACvB,MAAY,EAAE,IAAI,CACb,GAAG,CACR,EAAQ,EAAE,SAAS,EACnB,SAAe,EAAE,MAAM,EACvB,OAAa,EAAE,IAAI,CACd,GAAG,CAAE,qEAAqE;AAC/E,EAAQ,EAAE,WAAW,EACrB,MAAY,EAAE,IAAI,EAClB,OAAa,EAAE,WAAW,GAAC,SAAS,EACpC,IAAU,EAAE,IAAI,EAAE,EAClB,SAAe,EAAE,MAAM,CAClB;8BA/FqB,kBAAkB;yBAEb,aAAa"}

package/src/types.js

@@ -1,5 +1,7 @@
+// Ensure this is a module.
+export {};
+
 /**
- * @import {PromiseKit} from '@endo/promise-kit'
  * @import {Passable} from '@endo/pass-style'
  * @import {Zone} from '@agoric/base-zone'
  * @import {Vow, VowTools} from '@agoric/vow'

package/test/async-flow-crank.test.js

@@ -16,6 +16,12 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Ephemera} from './types.js';
+ */
+
 const neverSettlesP = new Promise(() => {});
 
 /**

package/test/async-flow-early-completion.test.js

@@ -18,6 +18,8 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
 /**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Vow, VowTools} from '@agoric/vow'
  * @import {AsyncFlow} from '../src/async-flow.js'
  */
 

package/test/async-flow-no-this.js

@@ -9,6 +9,12 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
+/**
+ * @import {Zone} from '@agoric/base-zone';
+ * @import {Vow, VowTools} from '@agoric/vow'
+ * @import {AsyncFlow} from '../src/async-flow.js'
+ */
+
 const { apply } = Reflect;
 
 /**

package/test/async-flow.test.js

@@ -21,6 +21,9 @@ import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
 /**
  * @import {AsyncFlow} from '../src/async-flow.js'
+ * @import {Vow, VowTools} from '@agoric/vow'
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
  */
 
 /**

package/test/bad-host.test.js

@@ -17,6 +17,11 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareAsyncFlowTools } from '../src/async-flow.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ */
+
 const nonPassableFunc = () => 'non-passable-function';
 harden(nonPassableFunc);
 const guestCreatedPromise = harden(Promise.resolve('guest-created'));

package/test/bijection.test.js

@@ -15,6 +15,12 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareBijection } from '../src/bijection.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Ephemera} from './types.js';
+ */
+
 /**
  * @param {any} t
  * @param {Zone} zone

package/test/convert.test.js

@@ -18,6 +18,11 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 import { makeConvertKit } from '../src/convert.js';
 import { prepareBijection } from '../src/bijection.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ */
+
 /**
  * @param {any} t
  * @param {Zone} zone

package/test/equate.test.js

@@ -18,6 +18,10 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 import { prepareBijection } from '../src/bijection.js';
 import { makeEquate } from '../src/equate.js';
 
+/**
+ * @import {Zone} from '@agoric/base-zone'
+ */
+
 /**
  * @param {any} t
  * @param {Zone} zone

package/test/log-store.test.js

@@ -14,6 +14,14 @@ import { makeDurableZone } from '@agoric/zone/durable.js';
 
 import { prepareLogStore } from '../src/log-store.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {Vow, VowTools} from '@agoric/vow'
+ * @import {LogStore} from '../src/log-store.js';
+ * @import {Bijection} from '../src/bijection.js';
+ */
+
 /**
  * @param {any} t
  * @param {Zone} zone

package/test/replay-membrane-eventual.test.js

@@ -18,6 +18,13 @@ import { prepareLogStore } from '../src/log-store.js';
 import { prepareBijection } from '../src/bijection.js';
 import { makeReplayMembrane } from '../src/replay-membrane.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {LogStore} from '../src/log-store.js';
+ * @import {Bijection} from '../src/bijection.js';
+ */
+
 const watchWake = _vowish => {};
 const panic = problem => Fail`panic over ${problem}`;
 

package/test/replay-membrane-settlement.test.js

@@ -17,6 +17,13 @@ import { prepareLogStore } from '../src/log-store.js';
 import { prepareBijection } from '../src/bijection.js';
 import { makeReplayMembrane } from '../src/replay-membrane.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {LogStore} from '../src/log-store.js';
+ * @import {Bijection} from '../src/bijection.js';
+ */
+
 const watchWake = _vowish => {};
 const panic = problem => Fail`panic over ${problem}`;
 

package/test/replay-membrane-zombie.test.js

@@ -17,6 +17,11 @@ import { prepareLogStore } from '../src/log-store.js';
 import { prepareBijection } from '../src/bijection.js';
 import { makeReplayMembrane } from '../src/replay-membrane.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ */
+
 const watchWake = _vowish => {};
 const panic = problem => Fail`panic over ${problem}`;
 

package/test/replay-membrane.test.js

@@ -18,6 +18,14 @@ import { prepareLogStore } from '../src/log-store.js';
 import { prepareBijection } from '../src/bijection.js';
 import { makeReplayMembrane } from '../src/replay-membrane.js';
 
+/**
+ * @import {PromiseKit} from '@endo/promise-kit'
+ * @import {Zone} from '@agoric/base-zone'
+ * @import {MapStore} from '@agoric/store';
+ * @import {LogStore} from '../src/log-store.js';
+ * @import {Bijection} from '../src/bijection.js';
+ */
+
 const watchWake = _vowish => {};
 const panic = problem => Fail`panic over ${problem}`;