@agoric/async-flow 0.1.1-dev-12ce494.0 → 0.1.1-dev-5d18974.0

package/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./src/async-flow.js";
+export * from "./src/types.js";
 export { makeStateRecord } from "./src/endowments.js";
 //# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,2 +1,3 @@
 export * from './src/async-flow.js';
+export * from './src/types.js';
 export { makeStateRecord } from './src/endowments.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/async-flow",
-  "version": "0.1.1-dev-12ce494.0+12ce494",
+  "version": "0.1.1-dev-5d18974.0+5d18974",
   "description": "Upgrade async functions at await points by replay",
   "type": "module",
   "repository": "https://github.com/Agoric/agoric-sdk",
@@ -24,10 +24,10 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/base-zone": "0.1.1-dev-12ce494.0+12ce494",
-    "@agoric/internal": "0.3.3-dev-12ce494.0+12ce494",
-    "@agoric/store": "0.9.3-dev-12ce494.0+12ce494",
-    "@agoric/vow": "0.1.1-dev-12ce494.0+12ce494",
+    "@agoric/base-zone": "0.1.1-dev-5d18974.0+5d18974",
+    "@agoric/internal": "0.3.3-dev-5d18974.0+5d18974",
+    "@agoric/store": "0.9.3-dev-5d18974.0+5d18974",
+    "@agoric/vow": "0.1.1-dev-5d18974.0+5d18974",
     "@endo/common": "^1.2.2",
     "@endo/errors": "^1.2.2",
     "@endo/eventual-send": "^1.2.2",
@@ -37,11 +37,12 @@
     "@endo/promise-kit": "^1.1.2"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-12ce494.0+12ce494",
-    "@agoric/zone": "0.2.3-dev-12ce494.0+12ce494",
+    "@agoric/swingset-liveslots": "0.10.3-dev-5d18974.0+5d18974",
+    "@agoric/zone": "0.2.3-dev-5d18974.0+5d18974",
     "@endo/env-options": "^1.1.4",
     "@endo/ses-ava": "^1.2.2",
-    "ava": "^5.3.0"
+    "ava": "^5.3.0",
+    "tsd": "^0.31.1"
   },
   "publishConfig": {
     "access": "public"
@@ -60,7 +61,7 @@
     "workerThreads": false
   },
   "typeCoverage": {
-    "atLeast": 77.83
+    "atLeast": 77.32
   },
-  "gitHead": "12ce49423c9afe6eb2396e7cac79b7f2f003cbb0"
+  "gitHead": "5d18974dc0f204abf085a9ef1f95c8b7e890335f"
 }

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

@@ -1 +1 @@
-{"version":3,"file":"replay-membrane.d.ts","sourceRoot":"","sources":["replay-membrane.js"],"names":[],"mappings":"AAsCO,oFANJ;IAAsB,GAAG,EAAjB,QAAQ;IACO,SAAS,EAAxB,SAAS;IACK,QAAQ,EAAtB,QAAQ;IAC6B,SAAS,EAA9C,CAAC,MAAM,EAAE,eAAU,GAAG,KAAK,IAAI;IACA,KAAK,EAApC,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;CACnC;;;;;;;;;;GAusBA;6BAGa,UAAU,mDA/sBrB;IAAsB,GAAG,EAAjB,QAAQ;IACO,SAAS,EAAxB,SAAS;IACK,QAAQ,EAAtB,QAAQ;IAC6B,SAAS,EAA9C,CAAC,MAAM,EAAE,eAAU,GAAG,KAAK,IAAI;IACA,KAAK,EAApC,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;CACnC;;;;;;;;;;GA0sB2C;8BAxtBjB,qBAAqB;+BACpB,qBAAqB;8BAFT,aAAa;yBAAb,aAAa;8BADD,kBAAkB"}
+{"version":3,"file":"replay-membrane.d.ts","sourceRoot":"","sources":["replay-membrane.js"],"names":[],"mappings":"AA8BO,oFANJ;IAAsB,GAAG,EAAjB,QAAQ;IACO,SAAS,EAAxB,SAAS;IACK,QAAQ,EAAtB,QAAQ;IAC6B,SAAS,EAA9C,CAAC,MAAM,EAAE,eAAU,GAAG,KAAK,IAAI;IACA,KAAK,EAApC,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;CACnC;;;;;;;;;;GAmpBA;6BAGa,UAAU,mDA3pBrB;IAAsB,GAAG,EAAjB,QAAQ;IACO,SAAS,EAAxB,SAAS;IACK,QAAQ,EAAtB,QAAQ;IAC6B,SAAS,EAA9C,CAAC,MAAM,EAAE,eAAU,GAAG,KAAK,IAAI;IACA,KAAK,EAApC,CAAC,OAAO,EAAE,KAAK,KAAK,KAAK;CACnC;;;;;;;;;;GAspB2C;8BApqBjB,qBAAqB;+BACpB,qBAAqB;8BAFT,aAAa;yBAAb,aAAa;8BADD,kBAAkB"}

package/src/replay-membrane.js

@@ -1,21 +1,13 @@
 /* eslint-disable no-use-before-define */
+import { isVow } from '@agoric/vow/src/vow-utils.js';
+import { heapVowE } from '@agoric/vow/vat.js';
+import { throwLabeled } from '@endo/common/throw-labeled.js';
 import { Fail, X, b, makeError, q } from '@endo/errors';
 import { E } from '@endo/eventual-send';
 import { getMethodNames } from '@endo/eventual-send/utils.js';
-import { throwLabeled } from '@endo/common/throw-labeled.js';
-import { objectMap } from '@endo/common/object-map.js';
-import {
-  Far,
-  Remotable,
-  getInterfaceOf,
-  getTag,
-  makeTagged,
-  passStyleOf,
-} from '@endo/pass-style';
-import { heapVowE } from '@agoric/vow/vat.js';
-import { isVow } from '@agoric/vow/src/vow-utils.js';
-import { makeEquate } from './equate.js';
+import { Far, Remotable, getInterfaceOf } from '@endo/pass-style';
 import { makeConvertKit } from './convert.js';
+import { makeEquate } from './equate.js';
 
 /**
  * @import {PromiseKit} from '@endo/promise-kit'
@@ -43,7 +35,7 @@ export const makeReplayMembrane = ({
   watchWake,
   panic,
 }) => {
-  const { when, watch, makeVowKit } = vowTools;
+  const { when, makeVowKit } = vowTools;
 
   const equate = makeEquate(bijection);
 
@@ -137,63 +129,12 @@ export const makeReplayMembrane = ({
 
   // ///////////// Guest to Host or consume log ////////////////////////////////
 
-  /**
-   * The host is not supposed to expose host-side promises to the membrane,
-   * since they cannot be stored durably or survive upgrade. We cannot just
-   * automatically wrap any such host promises with host vows, because that
-   * would mask upgrade hazards if an upgrade happens before the vow settles.
-   * However, during the transition, the current host APIs called by
-   * orchestration still return many promises. We want to generate diagnostics
-   * when we encounter them, but for now, automatically convert them to
-   * host vow anyway, just so integration testing can proceed to reveal
-   * additional problems beyond these.
-   *
-   * @param {Passable} h
-   */
-  const tolerateHostPromiseToVow = h => {
-    const passStyle = passStyleOf(h);
-    switch (passStyle) {
-      case 'promise': {
-        const e = Error('where warning happened');
-        console.log('Warning for now: vow expected, not promise', h, e);
-        // TODO remove this stopgap. Here for now because host-side
-        // promises are everywhere!
-        // Note: A good place to set a breakpoint, or to uncomment the
-        // `debugger;` line, to work around bundling.
-        // debugger;
-        return watch(h);
-      }
-      case 'copyRecord': {
-        const o = /** @type {object} */ (h);
-        return objectMap(o, tolerateHostPromiseToVow);
-      }
-      case 'copyArray': {
-        const a = /** @type {Array} */ (h);
-        return harden(a.map(tolerateHostPromiseToVow));
-      }
-      case 'tagged': {
-        const t = /** @type {CopyTagged} */ (h);
-        if (isVow(t)) {
-          return h;
-        }
-        return makeTagged(getTag(t), tolerateHostPromiseToVow(t.payload));
-      }
-      default: {
-        return h;
-      }
-    }
-  };
-
   const performCall = (hostTarget, optVerb, hostArgs, callIndex) => {
     let hostResult;
     try {
       hostResult = optVerb
         ? hostTarget[optVerb](...hostArgs)
         : hostTarget(...hostArgs);
-      // This is a temporary kludge anyway. But note that it only
-      // catches the case where the promise is at the top of hostResult.
-      harden(hostResult);
-      hostResult = tolerateHostPromiseToVow(hostResult);
       // Try converting here just to route the error correctly
       hostToGuest(hostResult, `converting ${optVerb || 'host'} result`);
     } catch (hostProblem) {
@@ -575,7 +516,6 @@ export const makeReplayMembrane = ({
    * @returns {Promise}
    */
   const makeGuestForHostVow = (hVow, promiseKey = undefined) => {
-    hVow = tolerateHostPromiseToVow(hVow);
     isVow(hVow) || Fail`vow expected ${hVow}`;
     const { promise, resolve, reject } = makeGuestPromiseKit();
     promiseKey ??= promise;

package/src/types.d.ts

@@ -1,4 +1,16 @@
-export type FlowState = "Running" | "Sleeping" | "Replaying" | "Failed" | "Done";
+import type { Passable } from '@endo/pass-style';
+import type { Vow, VowTools } from '@agoric/vow';
+import type { LogStore } from './log-store.js';
+import type { Bijection } from './bijection.js';
+import type { EndowmentTools } from './endowments.js';
+
+export type FlowState =
+  | 'Running'
+  | 'Sleeping'
+  | 'Replaying'
+  | 'Failed'
+  | 'Done';
+
 /**
  * `T` defaults to `any`, not `Passable`, because unwrapped guests include
  * non-passables, like unwrapped functions and unwrapped state records.
@@ -8,52 +20,172 @@ export type FlowState = "Running" | "Sleeping" | "Replaying" | "Failed" | "Done"
  */
 export type Guest<T extends unknown = any> = T;
 export type Host<T extends Passable = Passable> = T;
+
 /**
  * A HostVow must be durably storable. It corresponds to an
  * ephemeral guest promise.
  */
 export type HostVow<T extends Passable = Passable> = Host<Vow<T>>;
-export type GuestAsyncFunc = (...activationArgs: Guest[]) => Guest<Promise<any>>;
+
+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 = any, TResult1 = T, TResult2 = never, C extends any[] = any[]>(specimenP: import("@agoric/vow").EVow<T>, watcher?: import("@agoric/vow").Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
-        makeVowKit: <T>() => import("@agoric/vow").VowKit<T>;
-        allVows: (maybeVows: import("@agoric/vow").EVow<unknown>[]) => Vow<any[]>;
-        asVow: <T extends unknown>(fn: (...args: any[]) => Vow<Awaited<T>> | Awaited<T> | import("@agoric/vow").PromiseVow<T>) => Vow<Awaited<T>>;
-        asPromise: import("@agoric/vow").AsPromiseFunction;
-        retriable: <F extends (...args: any[]) => any>(fnZone: import("@agoric/base-zone").Zone, name: string, fn: F) => PromiseToVow<F>;
-    } | undefined;
-    makeLogStore?: (() => LogStore) | undefined;
-    makeBijection?: (() => Bijection) | undefined;
-    endowmentTools?: {
-        prepareEndowment: (zone: import("@agoric/base-zone").Zone, tag: string, e: unknown) => any;
-        unwrap: (wrapped: any, guestWrapped: any) => any;
-    } | undefined;
+
+/**
+ * The function from the host as it will be available in the guest.
+ *
+ * Specifically, Vow return values are converted to Promises.
+ */
+export type GuestOf<F extends HostAsyncFuncWrapper> = F extends (
+  ...args: infer A
+) => Vow<infer R>
+  ? (...args: A) => Promise<R>
+  : F;
+
+/**
+ * Convert an entire Guest interface into what the host will implement.
+ */
+type HostInterface<T> = {
+  [K in keyof T]: HostOf<T[K]>;
 };
-export type OutcomeKind = "return" | "throw";
-export type Outcome = {
-    kind: "return";
-    result: any;
-} | {
-    kind: "throw";
-    problem: any;
+
+/**
+ * The function the host must provide to match an interface the guest expects.
+ *
+ * Specifically, Promise return values are converted to Vows.
+ */
+export type HostOf<F> = F extends (...args: infer A) => Promise<infer R>
+  ? (...args: A) => Vow<R extends Passable ? R : HostInterface<R>>
+  : F;
+
+export type PreparationOptions = {
+  vowTools?: VowTools;
+  makeLogStore?: (() => LogStore) | undefined;
+  makeBijection?: (() => Bijection) | undefined;
+  endowmentTools?: EndowmentTools;
 };
+export type OutcomeKind = 'return' | 'throw';
+
+export type Outcome =
+  | {
+      kind: 'return';
+      result: any;
+    }
+  | {
+      kind: 'throw';
+      problem: any;
+    };
+
 export type Ephemera<S extends WeakKey = WeakKey, V extends unknown = any> = {
-    for: (self: S) => V;
-    resetFor: (self: S) => void;
+  for: (self: S) => V;
+  resetFor: (self: S) => void;
 };
+
 /**
- * This is the typedef for the membrane log entries we currently implement.
- * See comment below for the commented-out typedef for the full
- * membrane log entry, which we do not yet support.
+ * This is the type alias for the membrane log entries we currently implement.
+ *
+ * @see {FutureLogEntry} below for the full membrane log entry, which we do not
+ * yet support.
  */
-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] | [op: "checkSendOnly", target: Host, optVerb: PropertyKey | undefined, args: Host[], callIndex: number] | [op: "checkSend", target: Host, optVerb: PropertyKey | undefined, args: Host[], callIndex: number];
-import type { Passable } from '@endo/pass-style';
-import type { Vow } from '@agoric/vow';
-import type { LogStore } from './log-store.js';
-import type { Bijection } from './bijection.js';
-//# sourceMappingURL=types.d.ts.map
+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,
+    ]
+  | [
+      op: 'checkSendOnly',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ]
+  | [
+      op: 'checkSend',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ];
+
+/**
+ * This would be the type alias for the full membrane log, if we supported:
+ * - the guest sending guest-promises and guest-remotables to the host
+ * - the guest using `E` to eventual-send to guest wrappers of the host
+ *   vows and remotables.
+ */
+export type FutureLogEntry =
+  | [
+      // ///////////////// From Host to Guest ///////////////////////
+      op: 'doFulfill',
+      vow: HostVow,
+      fulfillment: Host,
+    ]
+  | [op: 'doReject', vow: HostVow, reason: Host]
+  | [
+      op: 'doCall',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ]
+  | [
+      op: 'doSendOnly',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ]
+  | [
+      op: 'doSend',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ]
+  | [op: 'doReturn', callIndex: number, result: Host]
+  | [op: 'doThrow', callIndex: number, problem: Host]
+  | [
+      // ///////////////////// From Guest to Host /////////////////////////
+      op: 'checkFulfill',
+      vow: HostVow,
+      fulfillment: Host,
+    ]
+  | [op: 'checkReject', vow: HostVow, reason: Host]
+  | [
+      op: 'checkCall',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ]
+  | [
+      op: 'checkSendOnly',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ]
+  | [
+      op: 'checkSend',
+      target: Host,
+      optVerb: PropertyKey | undefined,
+      args: Host[],
+      callIndex: number,
+    ]
+  | [op: 'checkReturn', callIndex: number, result: Host]
+  | [op: 'checkThrow', callIndex: number, problem: Host];

package/src/types.js

@@ -1,196 +1 @@
-// Ensure this is a module.
-export {};
-
-/**
- * @import {Passable} from '@endo/pass-style'
- * @import {Vow, VowTools} from '@agoric/vow'
- * @import {LogStore} from './log-store.js'
- * @import {Bijection} from './bijection.js'
- * @import {EndowmentTools} from './endowments.js'
- */
-
-/**
- * @typedef {'Running' |
- *           'Sleeping' |
- *           'Replaying' |
- *           'Failed' |
- *           'Done'
- * } FlowState
- */
-
-/**
- * `T` defaults to `any`, not `Passable`, because unwrapped guests include
- * non-passables, like unwrapped functions and unwrapped state records.
- * (Unwrapped functions could be made into Remotables,
- * but since they still could not be made durable, in this context
- * it'd be pointless.)
- *
- * @template {any} [T=any]
- * @typedef {T} Guest
- */
-
-/**
- * @template {Passable} [T=Passable]
- * @typedef {T} Host
- */
-
-/**
- * A HostVow must be durably storable. It corresponds to an
- * ephemeral guest promise.
- *
- * @template {Passable} [T=Passable]
- * @typedef {Host<Vow<T>>} HostVow
- */
-
-/**
- * @typedef {(...activationArgs: Guest[]) => Guest<Promise>} GuestAsyncFunc
- */
-
-/**
- * @typedef {(...activationArgs: Host[]) => HostVow} HostAsyncFuncWrapper
- */
-
-/**
- * @typedef {object} PreparationOptions
- * @property {VowTools} [vowTools]
- * @property {() => LogStore} [makeLogStore]
- * @property {() => Bijection} [makeBijection]
- * @property {EndowmentTools} [endowmentTools]
- */
-
-/**
- * @typedef {'return'|'throw'} OutcomeKind
- */
-
-/**
- * @typedef {{kind: 'return', result: any}
- *         | {kind: 'throw',  problem: any}
- * } Outcome
- */
-
-/**
- * @template {WeakKey} [S=WeakKey]
- * @template {any} [V=any]
- * @typedef {object} Ephemera
- * @property {(self: S) => V} for
- * @property {(self: S) => void} resetFor
- */
-
-/**
- * This is the typedef for the membrane log entries we currently implement.
- * See comment below for the commented-out typedef for the full
- * membrane log entry, which we do not yet support.
- *
- * @typedef {[ // ///////////////// 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
- *   ] | [
- *     op: 'checkSendOnly',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'checkSend',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ]} LogEntry
- */
-
-/**
- * This would be the typedef for the full membrane log, if we supported
- * - the guest sending guest-promises and guest-remotables to the host
- * - the guest using `E` to eventual-send to guest wrappers of host
- *   vows and remotables.
- *
- * at-typedef {[ // ///////////////// From Host to Guest ///////////////////////
- *     op: 'doFulfill',
- *     vow: HostVow,
- *     fulfillment: Host,
- *   ] | [
- *     op: 'doReject',
- *     vow: HostVow,
- *     reason: Host,
- *   ] | [
- *     op: 'doCall',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'doSendOnly',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'doSend',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'doReturn',
- *     callIndex: number,
- *     result: Host,
- *   ] | [
- *     op: 'doThrow',
- *     callIndex: number,
- *     problem: Host,
- *   ] | [ // ///////////////////// From Guest to Host /////////////////////////
- *     op: 'checkFulfill',
- *     vow: HostVow,
- *     fulfillment: Host,
- *   ] | [
- *     op: 'checkReject',
- *     vow: HostVow,
- *     reason: Host,
- *   ] | [
- *     op: 'checkCall',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'checkSendOnly',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'checkSend',
- *     target: Host,
- *     optVerb: PropertyKey|undefined,
- *     args: Host[],
- *     callIndex: number
- *   ] | [
- *     op: 'checkReturn',
- *     callIndex: number,
- *     result: Host,
- *   ] | [
- *     op: 'checkThrow',
- *     callIndex: number,
- *     problem: Host,
- *   ]} LogEntry
- */
+export const empty = 'Empty JS file to correspond with its .d.ts twin';

package/test/bad-host.test.js

@@ -141,7 +141,7 @@ const testBadHostReplay1 = async (t, zone) => {
         },
         {
           message:
-            'Remotables must be explicitly declared: "[Function nonPassableFunc]"',
+            'converting badMethod result: Remotables must be explicitly declared: "[Function nonPassableFunc]"',
         },
       );
       t.log('  badHost replay1 guest error caused by host error', gErr);
@@ -177,7 +177,7 @@ const testBadHostReplay1 = async (t, zone) => {
       'doThrow',
       2,
       Error(
-        'Remotables must be explicitly declared: "[Function nonPassableFunc]"',
+        'converting badMethod result: Remotables must be explicitly declared: "[Function nonPassableFunc]"',
       ),
     ],
     ['checkCall', badHost, 'badMethod', [], 4],

package/test/types.test-d.ts

@@ -0,0 +1,22 @@
+import { expectType } from 'tsd';
+import type { Zone } from '@agoric/base-zone';
+import type { Vow, VowTools } from '@agoric/vow';
+import type { HostOf, GuestOf } from '../src/types.js';
+
+const vt: VowTools = null as any;
+
+const sumVow = (a: number, b: number) => vt.asVow(() => a + b);
+
+const sumPromise = (a: number, b: number) => Promise.resolve(a + b);
+
+expectType<(p1: number, p2: number) => Promise<number>>(
+  null as unknown as GuestOf<typeof sumVow>,
+);
+
+expectType<(p1: number, p2: number) => Vow<number>>(
+  null as unknown as HostOf<typeof sumPromise>,
+);
+expectType<(p1: number, p2: number) => Vow<void>>(
+  // @ts-expect-error incompatible return type
+  null as unknown as HostOf<typeof sumPromise>,
+);

package/tsconfig.json

@@ -9,5 +9,7 @@
     "scripts",
     "src/**/*.js",
     "test/**/*.js",
+    "src/**/*.ts",
+    "test/**/*.ts",
   ],
 }

package/src/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"wBAYa,SAAS,GACrB,UAAsB,GACtB,WAAuB,GACvB,QAAoB,GACpB,MAAkB;;;;;;;;kBAWC,CAAC,0BACR,CAAC;iBAIW,CAAC,SAAb,QAAU,eACV,CAAC;;;;;oBAOW,CAAC,SAAb,QAAU,eACV,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;6BAIZ,CAAC,GAAG,cAAc,EAAE,KAAK,EAAE,KAAK,KAAK,cAAS;mCAI9C,CAAC,GAAG,cAAc,EAAE,IAAI,EAAE,KAAK,OAAO;;;;;;;wCAyDxC,GAAG;;+BA3BoD,GAAG;;0BAxBjD,QAAQ;2BACR,SAAS;;;;;;0BAKhB,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;qBAKnB,CAAC,SAAX,OAAQ,YACF,CAAC;SAEP,CAAC,IAAI,EAAE,CAAC,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,GAAG,CACR,EAAQ,EAAE,eAAe,EACzB,MAAY,EAAE,IAAI,EAClB,OAAa,EAAE,WAAW,GAAC,SAAS,EACpC,IAAU,EAAE,IAAI,EAAE,EAClB,SAAe,EAAE,MAAM,CAClB,GAAG,CACR,EAAQ,EAAE,WAAW,EACrB,MAAY,EAAE,IAAI,EAClB,OAAa,EAAE,WAAW,GAAC,SAAS,EACpC,IAAU,EAAE,IAAI,EAAE,EAClB,SAAe,EAAE,MAAM,CAClB;8BAjHqB,kBAAkB;yBACb,aAAa;8BAClB,gBAAgB;+BACf,gBAAgB"}