@endo/eventual-send 0.17.2 → 0.17.5

package/package.json

@@ -1,18 +1,17 @@
 {
   "name": "@endo/eventual-send",
-  "version": "0.17.2",
+  "version": "0.17.5",
   "description": "Extend a Promise class to implement the eventual-send API",
   "type": "module",
   "main": "src/no-shim.js",
-  "types": "src/index.d.ts",
   "scripts": {
     "test": "ava",
     "test:c8": "c8 $C8_OPTIONS ava --config=ava-nesm.config.js",
     "test:xs": "exit 0",
     "build": "exit 0",
-    "clean": "tsc --build tsconfig.build.json --clean",
+    "clean": "git clean -f '*.d.ts*'",
     "prepack": "tsc --build tsconfig.build.json",
-    "postpack": "git clean -f '*.d.ts*'",
+    "postpack": "yarn clean",
     "lint-fix": "yarn lint:eslint --fix && yarn lint:types",
     "lint-check": "yarn lint",
     "lint": "yarn lint:types && yarn lint:eslint",
@@ -29,12 +28,15 @@
     "url": "https://github.com/endojs/endo/issues"
   },
   "homepage": "https://github.com/endojs/endo#readme",
+  "dependencies": {
+    "@endo/env-options": "^0.1.3"
+  },
   "devDependencies": {
-    "@endo/lockdown": "^0.1.28",
-    "@endo/ses-ava": "^0.2.40",
-    "ava": "^5.2.0",
-    "c8": "^7.7.3",
-    "tsd": "^0.24.1"
+    "@endo/lockdown": "^0.1.31",
+    "@endo/ses-ava": "^0.2.43",
+    "ava": "^5.3.0",
+    "c8": "^7.14.0",
+    "tsd": "^0.28.1"
   },
   "keywords": [
     "eventual send",
@@ -61,5 +63,5 @@
     ],
     "timeout": "2m"
   },
-  "gitHead": "38c2c59d6ae8c53f84cd333e6c7828e2d37604e2"
+  "gitHead": "b38361616f968415291b089dcca75cc4a2672a35"
 }

package/shim.js

@@ -1,7 +1,6 @@
-// @ts-nocheck
 /* global globalThis */
 import { makeHandledPromise } from './src/handled-promise.js';
 
-if (typeof HandledPromise === 'undefined') {
+if (typeof globalThis.HandledPromise === 'undefined') {
   globalThis.HandledPromise = makeHandledPromise();
 }

package/src/E.d.ts

@@ -1,6 +1,158 @@
+export default makeE;
+export type EProxy = ReturnType<(HandledPromise: {
+    new <R>(executor: import("./handled-promise.js").HandledExecutor<R>, unfulfilledHandler?: import("./handled-promise.js").Handler<Promise<unknown>> | undefined): Promise<R>;
+    prototype: Promise<unknown>;
+} & PromiseConstructor & import("./handled-promise.js").HandledPromiseStaticMethods) => (<T>(x: T) => ECallableOrMethods<RemoteFunctions<T>>) & {
+    /**
+     * E.get(x) returns a proxy on which you can get arbitrary properties.
+     * Each of these properties returns a promise for the property.  The promise
+     * value will be the property fetched from whatever 'x' designates (or
+     * resolves to) in a future turn, not this one.
+     *
+     * @template T
+     * @param {T} x target for property get
+     * @returns {EGetters<LocalRecord<T>>} property get proxy
+     * @readonly
+     */
+    readonly get: <T_1>(x: T_1) => EGetters<LocalRecord<T_1>>;
+    /**
+     * E.resolve(x) converts x to a handled promise. It is
+     * shorthand for HandledPromise.resolve(x)
+     *
+     * @template T
+     * @param {T} x value to convert to a handled promise
+     * @returns {Promise<Awaited<T>>} handled promise for x
+     * @readonly
+     */
+    readonly resolve: {
+        (): Promise<void>;
+        <T_2>(value: T_2): Promise<Awaited<T_2>>;
+        <T_3>(value: T_3 | PromiseLike<T_3>): Promise<Awaited<T_3>>;
+    };
+    /**
+     * E.sendOnly returns a proxy similar to E, but for which the results
+     * are ignored (undefined is returned).
+     *
+     * @template T
+     * @param {T} x target for method/function call
+     * @returns {ESendOnlyCallableOrMethods<RemoteFunctions<T>>} method/function call proxy
+     * @readonly
+     */
+    readonly sendOnly: <T_4>(x: T_4) => ESendOnlyCallableOrMethods<RemoteFunctions<T_4>>;
+    /**
+     * E.when(x, res, rej) is equivalent to
+     * HandledPromise.resolve(x).then(res, rej)
+     *
+     * @template T
+     * @template [U = T]
+     * @param {T|PromiseLike<T>} x value to convert to a handled promise
+     * @param {(value: T) => ERef<U>} [onfulfilled]
+     * @param {(reason: any) => ERef<U>} [onrejected]
+     * @returns {Promise<U>}
+     * @readonly
+     */
+    readonly when: <T_5, U = T_5>(x: T_5 | PromiseLike<T_5>, onfulfilled?: ((value: T_5) => ERef<U>) | undefined, onrejected?: ((reason: any) => ERef<U>) | undefined) => Promise<U>;
+}>;
 /**
- * @param {import('./index').HandledPromiseConstructor} HandledPromise
- * @returns {import('./index').EProxy}
+ * Creates a type that accepts both near and marshalled references that were
+ * returned from `Remotable` or `Far`, and also promises for such references.
  */
-export default function makeE(HandledPromise: import('./index').HandledPromiseConstructor): import('./index').EProxy;
+export type FarRef<Primary, Local = DataOnly<Primary>> = ERef<Local & import('./types').RemotableBrand<Local, Primary>>;
+/**
+ * `DataOnly<T>` means to return a record type `T2` consisting only of
+ * properties that are *not* functions.
+ */
+export type DataOnly<T> = Omit<T, FilteredKeys<T, import('./types').Callable>>;
+export type ERef<T> = PromiseLike<T> | T;
+export type ECallable<T extends import("./types").Callable> = ReturnType<T> extends PromiseLike<infer U> ? T : (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>>;
+export type EMethods<T> = { readonly [P in keyof T]: T[P] extends import("./types").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 import("./types").Callable> = (...args: Parameters<T>) => Promise<void>;
+export type ESendOnlyMethods<T> = { readonly [P in keyof T]: T[P] extends import("./types").Callable ? ESendOnlyCallable<T[P]> : never; };
+export type ESendOnlyCallableOrMethods<T> = (T extends import('./types').Callable ? ESendOnlyCallable<T> & ESendOnlyMethods<Required<T>> : ESendOnlyMethods<Required<T>>);
+export type ECallableOrMethods<T> = (T extends import('./types').Callable ? ECallable<T> & EMethods<Required<T>> : EMethods<Required<T>>);
+/**
+ * Return a union of property names/symbols/numbers P for which the record element T[P]'s type extends U.
+ *
+ * Given const x = { a: 123, b: 'hello', c: 42, 49: () => {}, 53: 67 },
+ *
+ * FilteredKeys<typeof x, number> is the type 'a' | 'c' | 53.
+ * FilteredKeys<typeof x, string> is the type 'b'.
+ * FilteredKeys<typeof x, 42 | 67> is the type 'c' | 53.
+ * FilteredKeys<typeof x, boolean> is the type never.
+ */
+export type FilteredKeys<T, U> = { [P in keyof T]: T[P] extends U ? P : never; }[keyof T];
+/**
+ * `PickCallable<T>` means to return a single root callable or a record type
+ * consisting only of properties that are functions.
+ */
+export type PickCallable<T> = T extends import("./types").Callable ? (...args: Parameters<T>) => ReturnType<T> : Pick<T, FilteredKeys<T, import("./types").Callable>>;
+/**
+ * `RemoteFunctions<T>` means to return the functions and properties that are remotely callable.
+ */
+export type RemoteFunctions<T> = T extends import("./types").RemotableBrand<infer L, infer R> ? PickCallable<R> : Awaited<T> extends import("./types").RemotableBrand<infer L_1, infer R_1> ? PickCallable<R_1> : T extends PromiseLike<infer U> ? Awaited<T> : T;
+export type LocalRecord<T> = T extends import("./types").RemotableBrand<infer L, infer R> ? L : Awaited<T> extends import("./types").RemotableBrand<infer L_1, infer R_1> ? L_1 : T extends PromiseLike<infer U> ? Awaited<T> : T;
+export type EPromiseKit<R = unknown> = {
+    promise: Promise<R>;
+    settler: import('./types').Settler<R>;
+};
+/**
+ * Type for an object that must only be invoked with E.  It supports a given
+ * interface but declares all the functions as asyncable.
+ */
+export type EOnly<T> = T extends import("./types").Callable ? (...args: Parameters<T>) => ERef<Awaited<EOnly<ReturnType<T>>>> : T extends Record<PropertyKey, import("./types").Callable> ? { [K in keyof T]: T[K] extends import("./types").Callable ? (...args: Parameters<T[K]>) => ERef<Awaited<EOnly<ReturnType<T[K]>>>> : T[K]; } : T;
+/**
+ * @param {import('./types').HandledPromiseConstructor} HandledPromise
+ */
+declare function makeE(HandledPromise: import('./types').HandledPromiseConstructor): (<T>(x: T) => ECallableOrMethods<RemoteFunctions<T>>) & {
+    /**
+     * E.get(x) returns a proxy on which you can get arbitrary properties.
+     * Each of these properties returns a promise for the property.  The promise
+     * value will be the property fetched from whatever 'x' designates (or
+     * resolves to) in a future turn, not this one.
+     *
+     * @template T
+     * @param {T} x target for property get
+     * @returns {EGetters<LocalRecord<T>>} property get proxy
+     * @readonly
+     */
+    readonly get: <T_1>(x: T_1) => EGetters<LocalRecord<T_1>>;
+    /**
+     * E.resolve(x) converts x to a handled promise. It is
+     * shorthand for HandledPromise.resolve(x)
+     *
+     * @template T
+     * @param {T} x value to convert to a handled promise
+     * @returns {Promise<Awaited<T>>} handled promise for x
+     * @readonly
+     */
+    readonly resolve: {
+        (): Promise<void>;
+        <T_2>(value: T_2): Promise<Awaited<T_2>>;
+        <T_3>(value: T_3 | PromiseLike<T_3>): Promise<Awaited<T_3>>;
+    };
+    /**
+     * E.sendOnly returns a proxy similar to E, but for which the results
+     * are ignored (undefined is returned).
+     *
+     * @template T
+     * @param {T} x target for method/function call
+     * @returns {ESendOnlyCallableOrMethods<RemoteFunctions<T>>} method/function call proxy
+     * @readonly
+     */
+    readonly sendOnly: <T_4>(x: T_4) => ESendOnlyCallableOrMethods<RemoteFunctions<T_4>>;
+    /**
+     * E.when(x, res, rej) is equivalent to
+     * HandledPromise.resolve(x).then(res, rej)
+     *
+     * @template T
+     * @template [U = T]
+     * @param {T|PromiseLike<T>} x value to convert to a handled promise
+     * @param {(value: T) => ERef<U>} [onfulfilled]
+     * @param {(reason: any) => ERef<U>} [onrejected]
+     * @returns {Promise<U>}
+     * @readonly
+     */
+    readonly when: <T_5, U = T_5>(x: T_5 | PromiseLike<T_5>, onfulfilled?: ((value: T_5) => ERef<U>) | undefined, onrejected?: ((reason: any) => ERef<U>) | undefined) => Promise<U>;
+};
 //# 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":"AAkHA;;;GAGG;AACH,8CAHW,OAAO,SAAS,EAAE,yBAAyB,GACzC,OAAO,SAAS,EAAE,MAAM,CAgCpC"}
+{"version":3,"file":"E.d.ts","sourceRoot":"","sources":["E.js"],"names":[],"mappings":";qBAiNc;;;;IAhEN;;;;;;;;;;OAUG;;IAMH;;;;;;;;OAQG;;;;;;IAGH;;;;;;;;OAQG;;IAMH;;;;;;;;;;;OAWG;;EAYoB;;;;;yDAQlB,KAAK,KAAK,GAAG,OAAO,SAAS,EAAE,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;;;;;0BAQ9D,KAAK,CAAC,EAAE,aAAa,CAAC,EAAE,OAAO,SAAS,EAAE,QAAQ,CAAC,CAAC;sBAMpD,YAAY,CAAC,CAAC,GAAG,CAAC;yHAQZ,WAAW,CAAC,CAAC,KAAK,QAAQ,QAAQ,WAAW,CAAC,CAAC,CAAC,CAAC;;;gFAwB7C,WAAW,CAAC,CAAC,KAAK,QAAQ,IAAI,CAAC;;4CAczC,CACZ,CAAK,SAAS,OAAO,SAAS,EAAE,QAAQ,GAChC,kBAAkB,CAAC,CAAC,GAAG,iBAAiB,SAAS,CAAC,CAAC,CAAC,GACpD,iBAAiB,SAAS,CAAC,CAAC,CAAC,CAClC;oCAKS,CACZ,CAAK,SAAS,OAAO,SAAS,EAAE,QAAQ,GAChC,UAAU,CAAC,CAAC,GAAG,SAAS,SAAS,CAAC,CAAC,CAAC,GACpC,SAAS,SAAS,CAAC,CAAC,CAAC,CAC1B;;;;;;;;;;;;;;;;+EAyBe,WAAW,CAAC,CAAC,KAAK,WAAW,CAAC,CAAC;;;;;;uCAmCrC;IACZ,OAAW,EAAE,QAAQ,CAAC,CAAC,CAAC;IACxB,OAAW,EAAE,OAAO,SAAS,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CACvC;;;;;wEAUe,WAAW,CAAC,CAAC,KAAK,KAAK,QAAQ,MAAM,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;AA3OxE;;GAEG;AACH,uCAFW,OAAO,SAAS,EAAE,yBAAyB;IAgB9C;;;;;;;;;;OAUG;;IAMH;;;;;;;;OAQG;;;;;;IAGH;;;;;;;;OAQG;;IAMH;;;;;;;;;;;OAWG;yIAHiB,GAAG;EAW9B"}

package/src/E.js

@@ -1,6 +1,7 @@
 import { trackTurns } from './track-turns.js';
 
 const { details: X, quote: q, Fail } = assert;
+const { assign, create } = Object;
 
 /** @type {ProxyHandler<any>} */
 const baseFreezableProxyHandler = {
@@ -31,13 +32,13 @@ const baseFreezableProxyHandler = {
  * A Proxy handler for E(x).
  *
  * @param {*} x Any value passed to E(x)
- * @param {import('./index').HandledPromiseConstructor} HandledPromise
+ * @param {import('./types').HandledPromiseConstructor} HandledPromise
  * @returns {ProxyHandler} the Proxy handler
  */
-function EProxyHandler(x, HandledPromise) {
-  return harden({
+const makeEProxyHandler = (x, HandledPromise) =>
+  harden({
     ...baseFreezableProxyHandler,
-    get(_target, p, receiver) {
+    get: (_target, p, receiver) => {
       return harden(
         {
           // This function purposely checks the `this` value (see above)
@@ -60,28 +61,27 @@ function EProxyHandler(x, HandledPromise) {
         }[p],
       );
     },
-    apply(_target, _thisArg, argArray = []) {
+    apply: (_target, _thisArg, argArray = []) => {
       return HandledPromise.applyFunction(x, argArray);
     },
-    has(_target, _p) {
+    has: (_target, _p) => {
       // We just pretend everything exists.
       return true;
     },
   });
-}
 
 /**
  * A Proxy handler for E.sendOnly(x)
  * It is a variant on the E(x) Proxy handler.
  *
  * @param {*} x Any value passed to E.sendOnly(x)
- * @param {import('./index').HandledPromiseConstructor} HandledPromise
+ * @param {import('./types').HandledPromiseConstructor} HandledPromise
  * @returns {ProxyHandler} the Proxy handler
  */
-function EsendOnlyProxyHandler(x, HandledPromise) {
-  return harden({
+const makeESendOnlyProxyHandler = (x, HandledPromise) =>
+  harden({
     ...baseFreezableProxyHandler,
-    get(_target, p, receiver) {
+    get: (_target, p, receiver) => {
       return harden(
         {
           // This function purposely checks the `this` value (see above)
@@ -101,49 +101,273 @@ function EsendOnlyProxyHandler(x, HandledPromise) {
         }[p],
       );
     },
-    apply(_target, _thisArg, argsArray = []) {
+    apply: (_target, _thisArg, argsArray = []) => {
       HandledPromise.applyFunctionSendOnly(x, argsArray);
       return undefined;
     },
-    has(_target, _p) {
+    has: (_target, _p) => {
       // We just pretend that everything exists.
       return true;
     },
   });
-}
 
 /**
- * @param {import('./index').HandledPromiseConstructor} HandledPromise
- * @returns {import('./index').EProxy}
+ * A Proxy handler for E.get(x)
+ * It is a variant on the E(x) Proxy handler.
+ *
+ * @param {*} x Any value passed to E.get(x)
+ * @param {import('./types').HandledPromiseConstructor} HandledPromise
+ * @returns {ProxyHandler} the Proxy handler
  */
-export default function makeE(HandledPromise) {
-  function E(x) {
-    const handler = EProxyHandler(x, HandledPromise);
-    return harden(new Proxy(() => {}, handler));
-  }
+const makeEGetProxyHandler = (x, HandledPromise) =>
+  harden({
+    ...baseFreezableProxyHandler,
+    has: (_target, _prop) => true,
+    get: (_target, prop) => HandledPromise.get(x, prop),
+  });
 
-  const makeEGetterProxy = x =>
-    new Proxy(Object.create(null), {
-      ...baseFreezableProxyHandler,
-      has(_target, _prop) {
-        return true;
-      },
-      get(_target, prop) {
-        return HandledPromise.get(x, prop);
+/**
+ * @param {import('./types').HandledPromiseConstructor} HandledPromise
+ */
+const makeE = HandledPromise => {
+  return harden(
+    assign(
+      /**
+       * E(x) returns a proxy on which you can call arbitrary methods. Each of these
+       * method calls returns a promise. The method will be invoked on whatever
+       * 'x' designates (or resolves to) in a future turn, not this one.
+       *
+       * @template T
+       * @param {T} x target for method/function call
+       * @returns {ECallableOrMethods<RemoteFunctions<T>>} method/function call proxy
+       */
+      x => harden(new Proxy(() => {}, makeEProxyHandler(x, HandledPromise))),
+      {
+        /**
+         * E.get(x) returns a proxy on which you can get arbitrary properties.
+         * Each of these properties returns a promise for the property.  The promise
+         * value will be the property fetched from whatever 'x' designates (or
+         * resolves to) in a future turn, not this one.
+         *
+         * @template T
+         * @param {T} x target for property get
+         * @returns {EGetters<LocalRecord<T>>} property get proxy
+         * @readonly
+         */
+        get: x =>
+          harden(
+            new Proxy(create(null), makeEGetProxyHandler(x, HandledPromise)),
+          ),
+
+        /**
+         * E.resolve(x) converts x to a handled promise. It is
+         * shorthand for HandledPromise.resolve(x)
+         *
+         * @template T
+         * @param {T} x value to convert to a handled promise
+         * @returns {Promise<Awaited<T>>} handled promise for x
+         * @readonly
+         */
+        resolve: HandledPromise.resolve,
+
+        /**
+         * E.sendOnly returns a proxy similar to E, but for which the results
+         * are ignored (undefined is returned).
+         *
+         * @template T
+         * @param {T} x target for method/function call
+         * @returns {ESendOnlyCallableOrMethods<RemoteFunctions<T>>} method/function call proxy
+         * @readonly
+         */
+        sendOnly: x =>
+          harden(
+            new Proxy(() => {}, makeESendOnlyProxyHandler(x, HandledPromise)),
+          ),
+
+        /**
+         * E.when(x, res, rej) is equivalent to
+         * HandledPromise.resolve(x).then(res, rej)
+         *
+         * @template T
+         * @template [U = T]
+         * @param {T|PromiseLike<T>} x value to convert to a handled promise
+         * @param {(value: T) => ERef<U>} [onfulfilled]
+         * @param {(reason: any) => ERef<U>} [onrejected]
+         * @returns {Promise<U>}
+         * @readonly
+         */
+        when: (x, onfulfilled, onrejected) =>
+          HandledPromise.resolve(x).then(
+            ...trackTurns([onfulfilled, onrejected]),
+          ),
       },
-    });
-
-  E.get = makeEGetterProxy;
-  E.resolve = HandledPromise.resolve;
-  E.sendOnly = x => {
-    const handler = EsendOnlyProxyHandler(x, HandledPromise);
-    return harden(new Proxy(() => {}, handler));
-  };
-
-  E.when = (x, onfulfilled, onrejected) => {
-    const [onsuccess, onfailure] = trackTurns([onfulfilled, onrejected]);
-    return HandledPromise.resolve(x).then(onsuccess, onfailure);
-  };
-
-  return harden(E);
-}
+    ),
+  );
+};
+
+export default makeE;
+
+/** @typedef {ReturnType<makeE>} EProxy */
+
+/**
+ * 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=DataOnly<Primary>] The local properties of the object.
+ * @typedef {ERef<Local & import('./types').RemotableBrand<Local, Primary>>} FarRef
+ */
+
+/**
+ * `DataOnly<T>` means to return a record type `T2` consisting only of
+ * properties that are *not* functions.
+ *
+ * @template T The type to be filtered.
+ * @typedef {Omit<T, FilteredKeys<T, import('./types').Callable>>} DataOnly
+ */
+
+/**
+ * @see {@link https://github.com/microsoft/TypeScript/issues/31394}
+ * @template T
+ * @typedef {PromiseLike<T> | T} ERef
+ */
+
+/**
+ * @template {import('./types').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
+ * )} ECallable
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *   readonly [P in keyof T]: T[P] extends import('./types').Callable
+ *     ? ECallable<T[P]>
+ *     : never;
+ * }} EMethods
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *   readonly [P in keyof T]: T[P] extends PromiseLike<infer U>
+ *     ? T[P]
+ *     : Promise<Awaited<T[P]>>;
+ * }} EGetters
+ */
+
+/**
+ * @template {import('./types').Callable} T
+ * @typedef {(...args: Parameters<T>) => Promise<void>} ESendOnlyCallable
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *   readonly [P in keyof T]: T[P] extends import('./types').Callable
+ *     ? ESendOnlyCallable<T[P]>
+ *     : never;
+ * }} ESendOnlyMethods
+ */
+
+/**
+ * @template T
+ * @typedef {(
+ *   T extends import('./types').Callable
+ *     ? ESendOnlyCallable<T> & ESendOnlyMethods<Required<T>>
+ *     : ESendOnlyMethods<Required<T>>
+ * )} ESendOnlyCallableOrMethods
+ */
+
+/**
+ * @template T
+ * @typedef {(
+ *   T extends import('./types').Callable
+ *     ? ECallable<T> & EMethods<Required<T>>
+ *     : EMethods<Required<T>>
+ * )} ECallableOrMethods
+ */
+
+/**
+ * Return a union of property names/symbols/numbers P for which the record element T[P]'s type extends U.
+ *
+ * Given const x = { a: 123, b: 'hello', c: 42, 49: () => {}, 53: 67 },
+ *
+ * FilteredKeys<typeof x, number> is the type 'a' | 'c' | 53.
+ * FilteredKeys<typeof x, string> is the type 'b'.
+ * FilteredKeys<typeof x, 42 | 67> is the type 'c' | 53.
+ * FilteredKeys<typeof x, boolean> is the type never.
+ *
+ * @template T
+ * @template U
+ * @typedef {{ [P in keyof T]: T[P] extends U ? P : never; }[keyof T]} FilteredKeys
+ */
+
+/**
+ * `PickCallable<T>` means to return a single root callable or a record type
+ * consisting only of properties that are functions.
+ *
+ * @template T
+ * @typedef {(
+ *   T extends import('./types').Callable
+ *     ? (...args: Parameters<T>) => ReturnType<T>                     // a root callable, no methods
+ *     : Pick<T, FilteredKeys<T, import('./types').Callable>>          // any callable methods
+ * )} PickCallable
+ */
+
+/**
+ * `RemoteFunctions<T>` means to return the functions and properties that are remotely callable.
+ *
+ * @template T
+ * @typedef {(
+ *   T extends import('./types').RemotableBrand<infer L, infer R>     // if a given T is some remote interface R
+ *     ? PickCallable<R>                                              // then return the callable properties of R
+ *     : Awaited<T> extends import('./types').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
+ *     : T extends PromiseLike<infer U>                               // otherwise, if T is a promise
+ *     ? Awaited<T>                                                   // then return resolved value T
+ *     : T                                                            // otherwise, return T
+ * )} RemoteFunctions
+ */
+
+/**
+ * @template T
+ * @typedef {(
+ *   T extends import('./types').RemotableBrand<infer L, infer R>
+ *     ? L
+ *     : Awaited<T> extends import('./types').RemotableBrand<infer L, infer R>
+ *     ? L
+ *     : T extends PromiseLike<infer U>
+ *     ? Awaited<T>
+ *     : T
+ * )} LocalRecord
+ */
+
+/**
+ * @template [R = unknown]
+ * @typedef {{
+ *   promise: Promise<R>;
+ *   settler: import('./types').Settler<R>;
+ * }} EPromiseKit
+ */
+
+/**
+ * Type for an object that must only be invoked with E.  It supports a given
+ * interface but declares all the functions as asyncable.
+ *
+ * @template T
+ * @typedef {(
+ *   T extends import('./types').Callable
+ *     ? (...args: Parameters<T>) => ERef<Awaited<EOnly<ReturnType<T>>>>
+ *     : T extends Record<PropertyKey, import('./types').Callable>
+ *     ? {
+ *         [K in keyof T]: T[K] extends import('./types').Callable
+ *           ? (...args: Parameters<T[K]>) => ERef<Awaited<EOnly<ReturnType<T[K]>>>>
+ *           : T[K];
+ *       }
+ *     : T
+ * )} EOnly
+ */

package/src/exports.d.ts

@@ -0,0 +1,31 @@
+import type { HandledPromiseConstructor } from './types.d.ts';
+
+// Package Types /////////////////////////////////////////////////////
+//
+//   Types exported to consumers.
+//
+
+export type {
+  RemotableBrand,
+  DataOnly,
+  FarRef,
+  ERef,
+  EProxy,
+  EOnly,
+  RemoteFunctions,
+  LocalRecord,
+  FilteredKeys,
+  PickCallable,
+  EPromiseKit as RemoteKit,
+  ResolveWithPresenceOptionsBag,
+  HandledExecutor,
+  Settler,
+  HandledPromiseStaticMethods,
+  HandledPromiseConstructor,
+  Handler as EHandler,
+} from './types.d.ts';
+
+declare global {
+  // eslint-disable-next-line vars-on-top,no-var
+  var HandledPromise: HandledPromiseConstructor;
+}

package/src/exports.js

@@ -0,0 +1,2 @@
+// Just a dummy to use exports.d.ts and satisfy runtime imports.
+export {};

package/src/exports.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=exports.test-d.d.ts.map

package/src/exports.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exports.test-d.d.ts","sourceRoot":"","sources":["exports.test-d.ts"],"names":[],"mappings":""}

package/src/{index.test-d.ts → exports.test-d.ts}

@@ -1,12 +1,7 @@
 /* eslint-disable @endo/no-polymorphic-call, import/no-extraneous-dependencies, no-restricted-globals */
 import { expectType } from 'tsd';
 import { E } from '../test/get-hp.js';
-import { DataOnly, ERef } from './index.js';
-
-type FarRef<
-  Primary,
-  Local = DataOnly<Primary>,
-> = import('@endo/eventual-send').FarRef<Primary, Local>;
+import type { ERef, FarRef } from './exports.js';
 
 // Check the legacy ERef type
 const foo = async (a: ERef<{ bar(): string; baz: number }>) => {