@agoric/vow 0.1.1-dev-3d662f8.0 → 0.1.1-dev-1cd6408.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vow",
-  "version": "0.1.1-dev-3d662f8.0+3d662f8",
+  "version": "0.1.1-dev-1cd6408.0+1cd6408",
   "description": "Remote (shortening and disconnection-tolerant) Promise-likes",
   "type": "module",
   "main": "src/index.js",
@@ -20,7 +20,7 @@
     "lint:types": "tsc"
   },
   "dependencies": {
-    "@agoric/base-zone": "0.1.1-dev-3d662f8.0+3d662f8",
+    "@agoric/base-zone": "0.1.1-dev-1cd6408.0+1cd6408",
     "@endo/env-options": "^1.1.1",
     "@endo/eventual-send": "^1.1.2",
     "@endo/pass-style": "^1.2.0",
@@ -28,7 +28,7 @@
     "@endo/promise-kit": "^1.0.4"
   },
   "devDependencies": {
-    "@agoric/internal": "0.3.3-dev-3d662f8.0+3d662f8",
+    "@agoric/internal": "0.3.3-dev-1cd6408.0+1cd6408",
     "@endo/far": "^1.0.4",
     "@endo/init": "^1.0.4",
     "ava": "^5.3.0"
@@ -49,5 +49,5 @@
   "typeCoverage": {
     "atLeast": 88.27
   },
-  "gitHead": "3d662f8942693391430a675dad4e68b9867a5e89"
+  "gitHead": "1cd6408e27271160227f8aaa12d9771ea73a1da1"
 }

package/src/E.d.ts

@@ -44,15 +44,15 @@ export type EProxy = ReturnType<(<A = {}, U extends (x: any) => Promise<any> = (
      * unwrapped(x).then(onfulfilled, onrejected)
      *
      * @template T
-     * @template [TResult1=Unwrap<T>]
+     * @template [TResult1=import('./types.js').Unwrap<T>]
      * @template [TResult2=never]
      * @param {ERef<T>} x value to convert to a handled promise
-     * @param {(value: Unwrap<T>) => ERef<TResult1>} [onfulfilled]
+     * @param {(value: import('./types.js').Unwrap<T>) => ERef<TResult1>} [onfulfilled]
      * @param {(reason: any) => ERef<TResult2>} [onrejected]
      * @returns {Promise<TResult1 | TResult2>}
      * @readonly
      */
-    readonly when: <T_4, TResult1 = Unwrap<T_4>, TResult2 = never>(x: ERef<T_4>, onfulfilled?: ((value: Unwrap<T_4>) => ERef<TResult1>) | undefined, onrejected?: ((reason: any) => ERef<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    readonly when: <T_4, TResult1 = import("./types.js").Unwrap<T_4>, TResult2 = never>(x: ERef<T_4>, onfulfilled?: ((value: import("./types.js").Unwrap<T_4>) => ERef<TResult1>) | undefined, onrejected?: ((reason: any) => ERef<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
 } & A)>;
 /**
  * `DataOnly<T>` means to return a record type `T2` consisting only of
@@ -60,7 +60,7 @@ export type EProxy = ReturnType<(<A = {}, U extends (x: any) => Promise<any> = (
  */
 export type DataOnly<T> = Omit<T, FilteredKeys<T, Callable>>;
 export type ERef<T> = PromiseLike<T> | T;
-export type ECallable<T extends Callable> = ReturnType<T> extends PromiseLike<infer U> ? T : (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+export type ECallable<T extends Callable> = (...args: Parameters<T>) => Promise<import('./types.js').Unwrap<ReturnType<T>>>;
 export type EMethods<T> = { readonly [P in keyof T]: T[P] extends Callable ? ECallable<T[P]> : never; };
 export type EGetters<T> = { readonly [P in keyof T]: T[P] extends PromiseLike<infer U> ? T[P] : Promise<Awaited<T[P]>>; };
 export type ESendOnlyCallable<T extends Callable> = (...args: Parameters<T>) => Promise<void>;
@@ -86,9 +86,8 @@ export type PickCallable<T> = T extends Callable ? (...args: Parameters<T>) => R
 /**
  * `RemoteFunctions<T>` means to return the functions and properties that are remotely callable.
  */
-export type RemoteFunctions<T> = T extends import("@endo/eventual-send").RemotableBrand<infer L, infer R> ? PickCallable<R> : Awaited<T> extends import("@endo/eventual-send").RemotableBrand<infer L_1, infer R_1> ? PickCallable<R_1> : Awaited<T> extends import("./types").Vow<infer U> ? RemoteFunctions<U> : T extends PromiseLike<infer U_1> ? Awaited<T> : T;
-export type Unwrap<T> = T extends PromiseLike<infer U> ? Unwrap<U> : T extends import("./types").Vow<infer U_1> ? Unwrap<U_1> : T;
-export type LocalRecord<T> = T extends import("@endo/eventual-send").RemotableBrand<infer L, infer R> ? L : Awaited<T> extends import("@endo/eventual-send").RemotableBrand<infer L_1, infer R_1> ? L_1 : Awaited<T> extends import("./types").Vow<infer U> ? LocalRecord<U> : T extends PromiseLike<infer U_1> ? Awaited<T> : T;
+export type RemoteFunctions<T> = T extends import("@endo/eventual-send").RemotableBrand<infer L, infer R> ? PickCallable<R> : Awaited<T> extends import("@endo/eventual-send").RemotableBrand<infer L_1, infer R_1> ? PickCallable<R_1> : Awaited<T> extends import("./types.js").Vow<infer U> ? RemoteFunctions<U> : T extends PromiseLike<infer U_1> ? Awaited<T> : T;
+export type LocalRecord<T> = T extends import("@endo/eventual-send").RemotableBrand<infer L, infer R> ? L : Awaited<T> extends import("@endo/eventual-send").RemotableBrand<infer L_1, infer R_1> ? L_1 : Awaited<T> extends import("./types.js").Vow<infer U> ? LocalRecord<U> : T extends PromiseLike<infer U_1> ? Awaited<T> : T;
 /**
  * Type for an object that must only be invoked with E.  It supports a given
  * interface but declares all the functions as asyncable.
@@ -143,14 +142,14 @@ declare function makeE<A = {}, U extends (x: any) => Promise<any> = (x: any) =>
      * unwrapped(x).then(onfulfilled, onrejected)
      *
      * @template T
-     * @template [TResult1=Unwrap<T>]
+     * @template [TResult1=import('./types.js').Unwrap<T>]
      * @template [TResult2=never]
      * @param {ERef<T>} x value to convert to a handled promise
-     * @param {(value: Unwrap<T>) => ERef<TResult1>} [onfulfilled]
+     * @param {(value: import('./types.js').Unwrap<T>) => ERef<TResult1>} [onfulfilled]
      * @param {(reason: any) => ERef<TResult2>} [onrejected]
      * @returns {Promise<TResult1 | TResult2>}
      * @readonly
      */
-    readonly when: <T_4, TResult1 = Unwrap<T_4>, TResult2 = never>(x: ERef<T_4>, onfulfilled?: ((value: Unwrap<T_4>) => ERef<TResult1>) | undefined, onrejected?: ((reason: any) => ERef<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    readonly when: <T_4, TResult1 = import("./types.js").Unwrap<T_4>, TResult2 = never>(x: ERef<T_4>, onfulfilled?: ((value: import("./types.js").Unwrap<T_4>) => ERef<TResult1>) | undefined, onrejected?: ((reason: any) => ERef<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
 } & A;
 //# sourceMappingURL=E.d.ts.map

package/src/E.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"E.d.ts","sourceRoot":"","sources":["E.js"],"names":[],"mappings":";iCASwB,GAAG,EAAE,KAAK,GAAG;qBAyRvB;;;;;;;IA7EN;;;;;;;;;;OAUG;;IASH;;;;;;;;OAQG;;IAGH;;;;;;;;OAQG;;IASH;;;;;;;;;;;;OAYG;;OAkBoB;;;;;0BAOlB,KAAK,CAAC,EAAE,aAAa,CAAC,EAAE,QAAQ,CAAC,CAAC;sBAMlC,YAAY,CAAC,CAAC,GAAG,CAAC;uGAQZ,WAAW,CAAC,CAAC,KAAK,QAAQ,QAAQ,WAAW,CAAC,CAAC,CAAC,CAAC;;;8DAwB7C,WAAW,CAAC,CAAC,KAAK,QAAQ,IAAI,CAAC;;4CAczC,CACZ,CAAK,SAAS,QAAQ,GACd,kBAAkB,CAAC,CAAC,GAAG,iBAAiB,SAAS,CAAC,CAAC,CAAC,GACpD,iBAAiB,SAAS,CAAC,CAAC,CAAC,CAClC;oCAKS,CACZ,CAAK,SAAS,QAAQ,GACd,UAAU,CAAC,CAAC,GAAG,SAAS,SAAS,CAAC,CAAC,CAAC,GACpC,SAAS,SAAS,CAAC,CAAC,CAAC,CAC1B;;;;;;;;;;;;;;;;6DAyBe,WAAW,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC;;;;;;;;;;;sDAmD/B,WAAW,CAAC,CAAC,KAAK,KAAK,QAAQ,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAhQxE;;;;;;;GAOG;AACH,6CANkB,GAAG,KAAK,QAAQ,GAAG,CAAC,OAAS,GAAG,KAAK,QAAQ,GAAG,CAAC,kBACxD,OAAO,qBAAqB,EAAE,yBAAyB;;;;IA4B1D;;;;;;;;;;OAUG;;IASH;;;;;;;;OAQG;;IAGH;;;;;;;;OAQG;;IASH;;;;;;;;;;;;OAYG;4KAHiB,GAAG;MAiB9B"}
+{"version":3,"file":"E.d.ts","sourceRoot":"","sources":["E.js"],"names":[],"mappings":";iCASwB,GAAG,EAAE,KAAK,GAAG;qBAyRvB;;;;;;;IA7EN;;;;;;;;;;OAUG;;IASH;;;;;;;;OAQG;;IAGH;;;;;;;;OAQG;;IASH;;;;;;;;;;;;OAYG;;OAkBoB;;;;;0BAOlB,KAAK,CAAC,EAAE,aAAa,CAAC,EAAE,QAAQ,CAAC,CAAC;sBAMlC,YAAY,CAAC,CAAC,GAAG,CAAC;sDAMhB,WAAW,CAAC,CAAC,KAAK,QAAQ,OAAO,YAAY,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;;;8DAwB7D,WAAW,CAAC,CAAC,KAAK,QAAQ,IAAI,CAAC;;4CAczC,CACZ,CAAK,SAAS,QAAQ,GACd,kBAAkB,CAAC,CAAC,GAAG,iBAAiB,SAAS,CAAC,CAAC,CAAC,GACpD,iBAAiB,SAAS,CAAC,CAAC,CAAC,CAClC;oCAKS,CACZ,CAAK,SAAS,QAAQ,GACd,UAAU,CAAC,CAAC,GAAG,SAAS,SAAS,CAAC,CAAC,CAAC,GACpC,SAAS,SAAS,CAAC,CAAC,CAAC,CAC1B;;;;;;;;;;;;;;;;6DAyBe,WAAW,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC;;;;;;;;;;sDA4C/B,WAAW,CAAC,CAAC,KAAK,KAAK,QAAQ,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AAvPxE;;;;;;;GAOG;AACH,6CANkB,GAAG,KAAK,QAAQ,GAAG,CAAC,OAAS,GAAG,KAAK,QAAQ,GAAG,CAAC,kBACxD,OAAO,qBAAqB,EAAE,yBAAyB;;;;IA4B1D;;;;;;;;;;OAUG;;IASH;;;;;;;;OAQG;;IAGH;;;;;;;;OAQG;;IASH;;;;;;;;;;;;OAYG;sNAHiB,GAAG;MAiB9B"}

package/src/E.js

@@ -263,10 +263,10 @@ const makeE = (
          * unwrapped(x).then(onfulfilled, onrejected)
          *
          * @template T
-         * @template [TResult1=Unwrap<T>]
+         * @template [TResult1=import('./types.js').Unwrap<T>]
          * @template [TResult2=never]
          * @param {ERef<T>} x value to convert to a handled promise
-         * @param {(value: Unwrap<T>) => ERef<TResult1>} [onfulfilled]
+         * @param {(value: import('./types.js').Unwrap<T>) => ERef<TResult1>} [onfulfilled]
          * @param {(reason: any) => ERef<TResult2>} [onrejected]
          * @returns {Promise<TResult1 | TResult2>}
          * @readonly
@@ -307,9 +307,7 @@ export default makeE;
 /**
  * @template {Callable} T
  * @typedef {(
- *   ReturnType<T> extends PromiseLike<infer U>                       // if function returns a promise
- *     ? T                                                            // return the function
- *     : (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>  // make it return a promise
+ *   (...args: Parameters<T>) => Promise<import('./types.js').Unwrap<ReturnType<T>>>
  * )} ECallable
  */
 
@@ -399,7 +397,7 @@ export default makeE;
  *     ? PickCallable<R>                                              // then return the callable properties of R
  *     : Awaited<T> extends import('@endo/eventual-send').RemotableBrand<infer L, infer R> // otherwise, if the final resolution of T is some remote interface R
  *     ? PickCallable<R>                                              // then return the callable properties of R
- *     : Awaited<T> extends import('./types').Vow<infer U>
+ *     : Awaited<T> extends import('./types.js').Vow<infer U>
  *     ? RemoteFunctions<U>                                           // then extract the remotable functions of U
  *     : T extends PromiseLike<infer U>                               // otherwise, if T is a promise
  *     ? Awaited<T>                                                   // then return resolved value T
@@ -407,13 +405,6 @@ export default makeE;
  * )} RemoteFunctions
  */
 
-/**
- * @template T
- * @typedef {T extends PromiseLike<infer U> ? Unwrap<U> :
- *   T extends import('./types').Vow<infer U> ? Unwrap<U> :
- *   T} Unwrap
- */
-
 /**
  * @template T
  * @typedef {(
@@ -421,7 +412,7 @@ export default makeE;
  *     ? L
  *     : Awaited<T> extends import('@endo/eventual-send').RemotableBrand<infer L, infer R>
  *     ? L
- *     : Awaited<T> extends import('./types').Vow<infer U>
+ *     : Awaited<T> extends import('./types.js').Vow<infer U>
  *     ? LocalRecord<U>
  *     : T extends PromiseLike<infer U>
  *     ? Awaited<T>

package/src/tools.d.ts

@@ -2,7 +2,7 @@ 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>;
+    when: <T, TResult1 = import("./types.js").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("./types.js").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
     watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = 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>;
     allVows: (vows: any) => import("./types.js").Vow<any>;

package/src/types.d.ts

@@ -1,10 +1,28 @@
-export type PromiseVow<T> = PromiseLike<T | Vow<T>>;
-export type ERef<T> = import('./E').ERef<T>;
+export type Callable = (...args: any[]) => any;
 /**
- * Creates a type that accepts both near and marshalled references that were
- * returned from `Remotable` or `Far`, and also promises for such references.
+ * Return type of a function that may
+ * return a promise or a vow.
  */
-export type FarRef<Primary, Local = import("./E").DataOnly<Primary>> = ERef<Local & import('@endo/eventual-send').RemotableBrand<Local, Primary>>;
+export type PromiseVow<T> = Promise<T | Vow<T>>;
+export type ERef<T> = T | PromiseLike<T>;
+/**
+ * Whether T is a primitive type.
+ */
+export type IsPrimitive<T> = (T extends bigint ? true : T extends boolean ? true : T extends null ? true : T extends number ? true : T extends string ? true : T extends symbol ? true : T extends undefined ? true : false);
+/**
+ * Recursively extract the non-callable properties of T.
+ */
+export type DataOnly<T> = IsPrimitive<T> extends true ? T : T extends Callable ? never : { [P in keyof T as T[P] extends Callable ? never : P]: DataOnly<T[P]>; };
+/**
+ * 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.
+ */
+export type Unwrap<T> = T extends PromiseLike<infer U> ? Unwrap<U> : T extends Vow<infer U_1> ? Unwrap<U_1> : IsPrimitive<T> extends true ? T : T extends import("@endo/eventual-send").RemotableBrand<infer Local, infer Primary> ? Local & T : T;
+/**
+ * A type that doesn't assume its parameter is local, but is
+ * satisfied with both local and remote references.
+ */
+export type Remote<Primary, Local = DataOnly<Primary>> = Primary | 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
@@ -21,7 +39,7 @@ export type VowV0<T = any> = {
     shorten: () => Promise<T>;
 };
 export type VowPayload<T = any> = {
-    vowV0: import('@endo/eventual-send').FarRef<VowV0<T>>;
+    vowV0: Remote<VowV0<T>>;
 };
 export type Vow<T = any> = import('@endo/pass-style').CopyTagged<'Vow', VowPayload<T>>;
 export type VowKit<T = any> = {

package/src/types.d.ts.map

@@ -1 +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;;gCAKjE,OAAO,YAAY,EAAE,IAAI,CAAC,CAAC,GAAG,OAAO,YAAY,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"iCAGwB,GAAG,EAAE,KAAK,GAAG;;;;;4BAIxB,QAAQ,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;sBAMnB,CAAC,GAAG,YAAY,CAAC,CAAC;;;;6BAKlB,CACZ,CAAK,SAAS,MAAM,GAAG,IAAI,GAC3B,CAAK,SAAS,OAAO,GAAG,IAAI,GAC5B,CAAK,SAAS,IAAI,GAAG,IAAI,GACzB,CAAK,SAAS,MAAM,GAAG,IAAI,GAC3B,CAAK,SAAS,MAAM,GAAG,IAAI,GAC3B,CAAK,SAAS,MAAM,GAAG,IAAI,GAC3B,CAAK,SAAS,SAAS,GAAG,IAAI,GAC9B,KAAS,CACN;;;;;;;;;;;;;;yDA8BS,OAAO,GACnB,OAAW,qBAAqB,EAAE,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC;;;;;;;;;;;;;;aAYnD,MAAM,QAAQ,CAAC,CAAC;;;WAShB,OAAO,MAAM,CAAC,CAAC,CAAC;;2BAKjB,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;;gCAKjE,OAAO,YAAY,EAAE,IAAI,CAAC,CAAC,GAAG,OAAO,YAAY,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC"}

package/src/types.js

@@ -1,23 +1,64 @@
 // @ts-check
 export {};
 
+/** @typedef {(...args: any[]) => any} Callable */
+
 /**
  * @template T
- * @typedef {PromiseLike<T | Vow<T>>} PromiseVow
+ * @typedef {Promise<T | Vow<T>>} PromiseVow Return type of a function that may
+ * return a promise or a vow.
  */
 
 /**
  * @template T
- * @typedef {import('./E').ERef<T>} ERef
+ * @typedef {T | PromiseLike<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 T
+ * @typedef {(
+ *   T extends bigint ? true :
+ *   T extends boolean ? true :
+ *   T extends null ? true :
+ *   T extends number ? true :
+ *   T extends string ? true :
+ *   T extends symbol ? true :
+ *   T extends undefined ? true :
+ *   false
+ * )} IsPrimitive Whether T is a primitive type.
+ */
+
+/**
+ * @template T
+ * @typedef {(
+ *   IsPrimitive<T> extends true ? T :
+ *   T extends Callable ? never :
+ *   { [P in keyof T as T[P] extends Callable ? never : P]: DataOnly<T[P]> }
+ * )} DataOnly Recursively extract the non-callable properties of 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.
+ * @template T
+ * @typedef {(
+ *   T extends PromiseLike<infer U> ? Unwrap<U> :
+ *   T extends import('./types').Vow<infer U> ? Unwrap<U> :
+ *   IsPrimitive<T> extends true ? T :
+ *   T extends import('@endo/eventual-send').RemotableBrand<infer Local, infer Primary> ? Local & T :
+ *   T
+ * )} Unwrap
+ */
+
+/**
+ * A type that accepts both near and marshalled references that were
+ * returned from `Remotable` or `Far`.
  * @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 [Local=DataOnly<Primary>] The local properties of the object.
+ * @typedef {Primary |
+ *   import('@endo/eventual-send').RemotableBrand<Local, Primary>
+ * } Remote A type that doesn't assume its parameter is local, but is
+ * satisfied with both local and remote references.
  */
 
 /**
@@ -36,7 +77,7 @@ export {};
 /**
  * @template [T=any]
  * @typedef {object} VowPayload
- * @property {import('@endo/eventual-send').FarRef<VowV0<T>>} vowV0
+ * @property {Remote<VowV0<T>>} vowV0
  */
 
 /**

package/src/when.d.ts

@@ -1,3 +1,3 @@
-export function makeWhen(isRetryableReason?: ((reason: any) => boolean) | undefined): <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>;
+export function makeWhen(isRetryableReason?: ((reason: any) => boolean) | undefined): <T, TResult1 = import("./types.js").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("./types.js").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
 export type When = ReturnType<typeof makeWhen>;
 //# sourceMappingURL=when.d.ts.map

package/src/when.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"when.d.ts","sourceRoot":"","sources":["when.js"],"names":[],"mappings":"AAMO,uDAFa,GAAG,KAAK,OAAO,6NAWb,GAAG,oFAoCxB;mBAIa,WAAW,eAAe,CAAC"}
+{"version":3,"file":"when.d.ts","sourceRoot":"","sources":["when.js"],"names":[],"mappings":"AAMO,uDAFa,GAAG,KAAK,OAAO,+NAWb,GAAG,oFAmCxB;mBAIa,WAAW,eAAe,CAAC"}

package/src/when.js

@@ -8,18 +8,17 @@ export const makeWhen = (isRetryableReason = () => false) => {
   /**
    * Shorten `specimenP` until we achieve a final result.
    *
-   * @template [T=any]
-   * @template [TResult1=import('./E.js').Unwrap<T>]
+   * @template T
+   * @template [TResult1=import('./types.js').Unwrap<T>]
    * @template [TResult2=never]
    * @param {T} specimenP value to unwrap
-   * @param {(value: import('./E.js').Unwrap<T>) => TResult1 | PromiseLike<TResult1>} [onFulfilled]
+   * @param {(value: import('./types.js').Unwrap<T>) => TResult1 | PromiseLike<TResult1>} [onFulfilled]
    * @param {(reason: any) => TResult2 | PromiseLike<TResult2>} [onRejected]
    * @returns {Promise<TResult1 | TResult2>}
    */
   const when = async (specimenP, onFulfilled, onRejected) => {
     // Ensure we don't run until a subsequent turn.
     await null;
-    Promise.prototype.then;
 
     // Ensure we have a presence that won't be disconnected later.
     let result = await specimenP;
@@ -38,7 +37,7 @@ export const makeWhen = (isRetryableReason = () => false) => {
       payload = getVowPayload(result);
     }
 
-    const unwrapped = /** @type {import('./E.js').Unwrap<T>} */ (result);
+    const unwrapped = /** @type {import('./types.js').Unwrap<T>} */ (result);
 
     // We've extracted the final result.
     if (onFulfilled == null && onRejected == null) {