@agoric/network 0.1.1-upgrade-16-dev-8879538.0 → 0.1.1-upgrade-16-dev-24665a9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/network",
-  "version": "0.1.1-upgrade-16-dev-8879538.0+8879538",
+  "version": "0.1.1-upgrade-16-dev-24665a9.0+24665a9",
   "description": "Agoric's network protocol API",
   "type": "module",
   "main": "./src/index.js",
@@ -21,20 +21,21 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-upgrade-16-dev-8879538.0+8879538",
-    "@agoric/internal": "0.3.3-upgrade-16-dev-8879538.0+8879538",
-    "@agoric/store": "0.9.3-upgrade-16-dev-8879538.0+8879538",
-    "@agoric/vat-data": "0.5.3-upgrade-16-dev-8879538.0+8879538",
+    "@agoric/assert": "0.6.1-upgrade-16-dev-24665a9.0+24665a9",
+    "@agoric/internal": "0.3.3-upgrade-16-dev-24665a9.0+24665a9",
+    "@agoric/store": "0.9.3-upgrade-16-dev-24665a9.0+24665a9",
+    "@agoric/vat-data": "0.5.3-upgrade-16-dev-24665a9.0+24665a9",
     "@endo/base64": "^1.0.5",
     "@endo/far": "^1.1.2",
+    "@endo/pass-style": "^1.4.0",
     "@endo/patterns": "^1.4.0",
     "@endo/promise-kit": "^1.1.2"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-upgrade-16-dev-8879538.0+8879538",
-    "@agoric/swingset-vat": "0.32.3-upgrade-16-dev-8879538.0+8879538",
-    "@agoric/vow": "0.1.1-upgrade-16-dev-8879538.0+8879538",
-    "@agoric/zone": "0.2.3-upgrade-16-dev-8879538.0+8879538",
+    "@agoric/swingset-liveslots": "0.10.3-upgrade-16-dev-24665a9.0+24665a9",
+    "@agoric/swingset-vat": "0.32.3-upgrade-16-dev-24665a9.0+24665a9",
+    "@agoric/vow": "0.1.1-upgrade-16-dev-24665a9.0+24665a9",
+    "@agoric/zone": "0.2.3-upgrade-16-dev-24665a9.0+24665a9",
     "@endo/bundle-source": "^3.2.3",
     "ava": "^5.3.0",
     "c8": "^9.1.0"
@@ -65,7 +66,7 @@
     "workerThreads": false
   },
   "typeCoverage": {
-    "atLeast": 89.39
+    "atLeast": 89.7
   },
-  "gitHead": "8879538cd1d125a08346f02dd5701d0d70c90bb8"
+  "gitHead": "24665a97248b854fcb01185d360429301470ed57"
 }

package/src/bytes.d.ts

@@ -1,3 +1,16 @@
+/**
+ * @import {Bytes} from './types.js';
+ */
+/** @typedef {Bytes | Buffer | Uint8Array | Iterable<number>} ByteSource */
+/**
+ * This function is a coercer instead of an asserter because in a future where
+ * binary data has better support across vats and potentially its own type, we
+ * might allow more `specimen`s than just `ByteSource`.
+ *
+ * @param {unknown} specimen
+ * @returns {ByteSource}
+ */
+export function coerceToByteSource(specimen: unknown): ByteSource;
 /**
  * Convert a Uint8Array or other sequence of octets to a string representation
  * that `@endo/marshal` accepts as Passable.
@@ -19,7 +32,7 @@ export function bytesToString(bytes: string): string;
  * @param {ByteSource} byteSource
  * @returns {string} base64 encoding
  */
-export function dataToBase64(byteSource: ByteSource): string;
+export function byteSourceToBase64(byteSource: ByteSource): string;
 /**
  * Decodes a base64 string into bytes.
  *

package/src/bytes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["bytes.js"],"names":[],"mappings":"AAgCA;;;;;;GAMG;AACH,oCAHW,UAAU,UAQpB;AAED;;;;;GAKG;AACH,8CAFa,MAAM,CAIlB;AAED;;;;;GAKG;AACH,yCAHW,UAAU,GACR,MAAM,CAKlB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,UAKhB"}
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["bytes.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH,2EAA2E;AAE3E;;;;;;;GAOG;AACH,6CAHW,OAAO,GACL,UAAU,CAmBtB;AAuBD;;;;;;GAMG;AACH,oCAHW,UAAU,UAQpB;AAED;;;;;GAKG;AACH,8CAFa,MAAM,CAIlB;AAED;;;;;GAKG;AACH,+CAHW,UAAU,GACR,MAAM,CAKlB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,UAKhB"}

package/src/bytes.js

@@ -1,7 +1,7 @@
 // @ts-check
-/// <reference path="./types.js" />
-import { Fail } from '@agoric/assert';
+import { details, Fail } from '@agoric/assert';
 import { encodeBase64, decodeBase64 } from '@endo/base64';
+import { isObject } from '@endo/pass-style';
 
 /**
  * @import {Bytes} from './types.js';
@@ -9,6 +9,33 @@ import { encodeBase64, decodeBase64 } from '@endo/base64';
 
 /** @typedef {Bytes | Buffer | Uint8Array | Iterable<number>} ByteSource */
 
+/**
+ * This function is a coercer instead of an asserter because in a future where
+ * binary data has better support across vats and potentially its own type, we
+ * might allow more `specimen`s than just `ByteSource`.
+ *
+ * @param {unknown} specimen
+ * @returns {ByteSource}
+ */
+export function coerceToByteSource(specimen) {
+  if (typeof specimen === 'string') {
+    return specimen;
+  }
+
+  isObject(specimen) ||
+    assert.fail(details`non-object ${specimen} is not a ByteSource`, TypeError);
+
+  const obj = /** @type {{}} */ (specimen);
+  typeof obj[Symbol.iterator] === 'function' ||
+    assert.fail(
+      details`non-iterable ${specimen} is not a ByteSource`,
+      TypeError,
+    );
+
+  // Good enough... it's iterable and can be converted later.
+  return /** @type {ByteSource} */ (specimen);
+}
+
 /**
  * @param {ByteSource} contents
  */
@@ -60,7 +87,7 @@ export function bytesToString(bytes) {
  * @param {ByteSource} byteSource
  * @returns {string} base64 encoding
  */
-export function dataToBase64(byteSource) {
+export function byteSourceToBase64(byteSource) {
   const bytes = coerceToByteArray(byteSource);
   return encodeBase64(bytes);
 }

package/src/network.d.ts

@@ -4,6 +4,7 @@
  * @param {string} addr
  */
 export function getPrefixes(addr: string): string[];
+/** @typedef {ReturnType<typeof prepareEchoConnectionKit>} MakeEchoConnectionKit */
 /**
  * Create a protocol handler that just connects to itself.
  *
@@ -11,12 +12,12 @@ export function getPrefixes(addr: string): string[];
  * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
  */
 export function prepareLoopbackProtocolHandler(zone: import("@agoric/base-zone").Zone, { watch, allVows }: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
-    isRetryableReason?: ((reason: any) => boolean) | undefined;
+    isRetryableReason?: import("@agoric/vow").IsRetryableReason | undefined;
 } | undefined) => {
-    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
+    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 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
     makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
-    allVows: (vows: any) => import("@agoric/vow").Vow<any>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
 }>): (instancePrefix?: string | undefined) => import("@endo/exo").Guarded<{
     onCreate(_impl: any, _protocolHandler: any): Promise<void>;
     generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
@@ -36,7 +37,25 @@ export function prepareLoopbackProtocolHandler(zone: import("@agoric/base-zone")
      * @param {import('@agoric/vow').Remote<ListenHandler>} listenHandler
      * @param {*} _protocolHandler
      */
-    onListenRemove(port: import("@agoric/vow").Remote<Port, never>, localAddr: string, listenHandler: import("@agoric/vow").Remote<ListenHandler, never>, _protocolHandler: any): Promise<void>;
+    onListenRemove(port: import("@agoric/vow").Remote<Port, {}>, localAddr: string, listenHandler: import("@agoric/vow").Remote<ListenHandler, {
+        /**
+         * The listener has been registered
+         */
+        onListen?: undefined;
+        /**
+         * The connection was rejected
+         */
+        onReject?: undefined;
+        /**
+         * There was an error while listening
+         */
+        onError?: undefined;
+        /**
+         * The
+         * listener has been removed
+         */
+        onRemove?: undefined;
+    }>, _protocolHandler: any): Promise<void>;
     onRevoke(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
 }>;
 /**
@@ -48,15 +67,20 @@ export function prepareLoopbackProtocolHandler(zone: import("@agoric/base-zone")
  */
 export const ENDPOINT_SEPARATOR: "/";
 export function rethrowUnlessMissing(err: unknown): undefined;
-export function crossoverConnection(zone: import("@agoric/zone").Zone, handler0: import("@agoric/vow").Remote<Required<ConnectionHandler>, never>, addr0: string, handler1: import("@agoric/vow").Remote<Required<ConnectionHandler>, never>, addr1: string, makeConnection: (opts: ConnectionOpts) => Connection, current?: globalThis.WeakSetStore<Closable> | undefined): Connection[];
+export function crossoverConnection(zone: import("@agoric/zone").Zone, handler0: import("@agoric/vow").Remote<Required<ConnectionHandler>, {}>, addr0: string, handler1: import("@agoric/vow").Remote<Required<ConnectionHandler>, {}>, addr1: string, makeConnection: (opts: ConnectionOpts) => Connection, current?: globalThis.WeakSetStore<Closable> | undefined): Connection[];
 export function prepareNetworkProtocol(zone: import("@agoric/base-zone").Zone, powers: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
-    isRetryableReason?: ((reason: any) => boolean) | undefined;
+    isRetryableReason?: import("@agoric/vow").IsRetryableReason | undefined;
 } | undefined) => {
-    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
+    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 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
     makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
-    allVows: (vows: any) => import("@agoric/vow").Vow<any>;
-}>): (protocolHandler: import("@agoric/vow").Remote<ProtocolHandler, never>) => Protocol;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
+}>): (protocolHandler: import("@agoric/vow").Remote<ProtocolHandler, {
+    /**
+     * Return unique suffix for local address
+     */
+    onInstantiate?: undefined;
+}>) => Protocol;
 export function prepareEchoConnectionKit(zone: import("@agoric/base-zone").Zone): () => import("@endo/exo").GuardedKit<{
     handler: {
         /**
@@ -91,26 +115,30 @@ export function prepareEchoConnectionKit(zone: import("@agoric/base-zone").Zone)
     };
 }>;
 export function preparePortAllocator(zone: import("@agoric/base-zone").Zone, { watch }: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
-    isRetryableReason?: ((reason: any) => boolean) | undefined;
+    isRetryableReason?: import("@agoric/vow").IsRetryableReason | undefined;
 } | undefined) => {
-    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
+    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 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
     makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
-    allVows: (vows: any) => import("@agoric/vow").Vow<any>;
-}>): (args_0?: any) => import("@endo/exo").Guarded<{
-    allocateCustomIBCPort(specifiedName?: string): import("@agoric/vow").Vow<any>;
-    allocateICAControllerPort(): import("@agoric/vow").Vow<any>;
-    allocateICQControllerPort(): import("@agoric/vow").Vow<any>;
-    allocateCustomLocalPort(specifiedName?: string): import("@agoric/vow").Vow<any>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
+}>): (args_0: {
+    protocol: Protocol;
+}) => import("@endo/exo").Guarded<{
+    allocateCustomIBCPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<Port>>;
+    allocateICAControllerPort(): Promise<import("@agoric/vow").Vow<Port>>;
+    allocateICQControllerPort(): Promise<import("@agoric/vow").Vow<Port>>;
+    allocateCustomLocalPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<Port>>;
 }>;
+export type MakeEchoConnectionKit = ReturnType<typeof prepareEchoConnectionKit>;
 export type ConnectionOpts = {
     addrs: string[];
-    handlers: import("@agoric/vow").Remote<Required<ConnectionHandler>, never>[];
+    handlers: import("@agoric/vow").Remote<Required<ConnectionHandler>, {}>[];
     conns: globalThis.MapStore<number, Connection>;
     current: globalThis.WeakSetStore<Closable>;
     l: 0 | 1;
     r: 0 | 1;
 };
+export type PortAllocator = ReturnType<ReturnType<typeof preparePortAllocator>>;
 import type { AttemptDescription } from './types.js';
 import type { Port } from './types.js';
 import type { ListenHandler } from './types.js';

package/src/network.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["network.js"],"names":[],"mappings":"AAkCA;;;;GAIG;AACH,kCAFW,MAAM,YAahB;AA0tCD;;;;;GAKG;AACH,qDAHW,OAAO,mBAAmB,EAAE,IAAI,sBAChC,UAAU;;;uFApwCoG,CAAC;;;;EAowC9D;;;;IAmCpD;;;;;OAKG;;;;IAgEH;;;;;OAKG;;;GA8CV;AAh6CD;;GAEG;AAEH;;;GAGG;AACH,qCAAsC;AAG/B,0CADK,OAAO,aAWlB;AAyJM,0CARI,OAAO,cAAc,EAAE,IAAI,+MAKpB,cAAc,wFAgD/B;AAi7BM,6CAHI,OAAO,mBAAmB,EAAE,IAAI,UAChC,UAAU;;;;;;;EAAuC,uFAkC3D;AAOM,+CAFI,OAAO,mBAAmB,EAAE,IAAI;;QAsCnC;;;;WAIG;;QASH;;;;WAIG;;;;;YAjBH;;;;eAIG;;YASH;;;;eAIG;;;;;GAuBV;AAwKM,2CAHI,OAAO,mBAAmB,EAAE,IAAI,aAChC,UAAU;;;;;;;EAAuC;;;;;GA+DzD;;;;;;OAv6CW,CAAC,GAAC,CAAC;OACH,CAAC,GAAC,CAAC;;wCA7DyJ,YAAY;0BAAZ,YAAY;mCAAZ,YAAY;uCAAZ,YAAY;gCAAZ,YAAY;8BAAZ,YAAY;qCAAZ,YAAY;8BAAZ,YAAY"}
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["network.js"],"names":[],"mappings":"AAkCA;;;;GAIG;AACH,kCAFW,MAAM,YAahB;AAutCD,mFAAmF;AAEnF;;;;;GAKG;AACH,qDAHW,OAAO,mBAAmB,EAAE,IAAI,sBAChC,UAAU;;;wFAnwC0J,CAAC;;;oBAiB5K,SAAI;EAkvCoD;;;;IAmCpD;;;;;OAKG;;;;IAgEH;;;;;OAKG;;;;;;;;;;;;;;;;;;;;;GA8CV;AA/5CD;;GAEG;AAEH;;;GAGG;AACH,qCAAsC;AAG/B,0CADK,OAAO,aAWlB;AAyJM,0CARI,OAAO,cAAc,EAAE,IAAI,yMAKpB,cAAc,wFAgD/B;AA+6BM,6CAHI,OAAO,mBAAmB,EAAE,IAAI,UAChC,UAAU;;;;;;;EAAuC;;;;;gBAkC3D;AAOM,+CAFI,OAAO,mBAAmB,EAAE,IAAI;;QAsCnC;;;;WAIG;;QASH;;;;WAIG;;;;;YAjBH;;;;eAIG;;YASH;;;;eAIG;;;;;GAuBV;AAyKM,2CAHI,OAAO,mBAAmB,EAAE,IAAI,aAChC,UAAU;;;;;;;EAAuC;;;;;;;GAoEzD;oCA1OW,UAAU,CAAC,OAAO,wBAAwB,CAAC;;;;;;OAjsC3C,CAAC,GAAC,CAAC;OACH,CAAC,GAAC,CAAC;;4BA26CH,UAAU,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;wCAx+CyG,YAAY;0BAAZ,YAAY;mCAAZ,YAAY;uCAAZ,YAAY;gCAAZ,YAAY;8BAAZ,YAAY;qCAAZ,YAAY;8BAAZ,YAAY"}

package/src/network.js

@@ -584,9 +584,7 @@ const preparePort = (zone, powers) => {
         // Clean up everything we did.
         const values = [...currentConnections.get(port).values()];
 
-        /** @type {import('@agoric/vow').Specimen[]} */
         const ps = [];
-
         ps.push(
           ...values.map(conn =>
             watch(E(conn).close(), this.facets.sinkWatcher),
@@ -1289,6 +1287,7 @@ export const prepareEchoConnectionKit = zone => {
 
   return makeEchoConnectionKit;
 };
+/** @typedef {ReturnType<typeof prepareEchoConnectionKit>} MakeEchoConnectionKit */
 
 /**
  * Create a protocol handler that just connects to itself.
@@ -1469,9 +1468,14 @@ export const preparePortAllocator = (zone, { watch }) =>
         .optional(M.string())
         .returns(Shape.Vow$(Shape.Port)),
     }),
+    /**
+     *
+     * @param {object} opts
+     * @param {Protocol} opts.protocol
+     */
     ({ protocol }) => ({ protocol, lastICAPortNum: 0n, lastICQPortNum: 0n }),
     {
-      allocateCustomIBCPort(specifiedName = '') {
+      async allocateCustomIBCPort(specifiedName = '') {
         const { state } = this;
         let localAddr = `/ibc-port/`;
 
@@ -1484,7 +1488,7 @@ export const preparePortAllocator = (zone, { watch }) =>
         // Allocate an IBC port with a unique generated name.
         return watch(E(state.protocol).bindPort(localAddr));
       },
-      allocateICAControllerPort() {
+      async allocateICAControllerPort() {
         const { state } = this;
         state.lastICAPortNum += 1n;
         return watch(
@@ -1493,7 +1497,7 @@ export const preparePortAllocator = (zone, { watch }) =>
           ),
         );
       },
-      allocateICQControllerPort() {
+      async allocateICQControllerPort() {
         const { state } = this;
         state.lastICQPortNum += 1n;
         return watch(
@@ -1502,7 +1506,7 @@ export const preparePortAllocator = (zone, { watch }) =>
           ),
         );
       },
-      allocateCustomLocalPort(specifiedName = '') {
+      async allocateCustomLocalPort(specifiedName = '') {
         const { state } = this;
 
         let localAddr = `/local/`;
@@ -1518,3 +1522,4 @@ export const preparePortAllocator = (zone, { watch }) =>
       },
     },
   );
+/** @typedef {ReturnType<ReturnType<typeof preparePortAllocator>>} PortAllocator */

package/src/router.d.ts

@@ -32,12 +32,12 @@ export function prepareRouter<T>(zone: import("@agoric/base-zone").Zone): () =>
     unregister(prefix: string, route: T): void;
 }>;
 export function prepareRouterProtocol(zone: import("@agoric/base-zone").Zone, powers: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
-    isRetryableReason?: ((reason: any) => boolean) | undefined;
+    isRetryableReason?: import("@agoric/vow").IsRetryableReason | undefined;
 } | undefined) => {
-    when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
+    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 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
     makeVowKit: <T_2>() => VowKit<T_2>;
-    allVows: (vows: any) => import("@agoric/vow").Vow<any>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
 }>, E?: ((<T_3>(x: T_3) => import("../../../node_modules/@endo/eventual-send/src/E.js").ECallableOrMethods<import("@endo/eventual-send").RemoteFunctions<T_3>>) & {
     readonly get: <T_1_1>(x: T_1_1) => import("../../../node_modules/@endo/eventual-send/src/E.js").EGetters<import("@endo/eventual-send").LocalRecord<T_1_1>>;
     readonly resolve: {

package/src/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["router.js"],"names":[],"mappings":"AAWA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAMI,8BAiDU,CAAC,QAnDP,OAAO,mBAAmB,EAAE,IAAI;IAiBrC,6BAA6B;;IAyB7B;;;OAGG;qBAFQ,MAAM,SAQN,CAAC,AAPA;IAKZ;;;OAGG;uBAFQ,MAAM,SACN,CAAC;GAWjB;AAgBM,4CAJI,OAAO,mBAAmB,EAAE,IAAI,UAChC,UAAU;;;uFAlGmD,CAAC;;;;EAkGb,iBA5GnD,GAAE;6BAGoB,KAAI;;;uBAGoB,KAAI;uBAC7B,KAAI;QAElC;;;WAGG;QAEH;;;;;;;;;WASG;QAEH,YAfO,KAAG,CAAC;;gCAAgE,GAAI;qCAC3D,GAAI,GAAE,YAAc,GAAE,CAAC,gBAAe,CAAE,CAAC,OAAO,GAAG,KAAI,OAC1E,oDAEE,EACF,IAAI,CAAC,CAAC,CAAC,CAAC,YACH,eAAe,CAAC,CAAC,WAAW,KAAI,OAAS,oDAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,YACzD;;IA+HD;;;OAGG;mCAFQ,MAAM,EAAE;IAanB;;;OAGG;sCAFQ,MAAM;IAejB,kCAAkC;;GAUvC;;;;mBAnKqC,CAAC;;;;;eAJzB,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,MAAM,EAID,CAAC,AAJG,CAAC,EAAE;;;;;cAE/B,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAEE,CAAC,AAFA,KAAK,IAAI;;;;;gBAElC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI;;;uBA8EzB,MAAM;qCACP,MAAM,EAAE,uCAAuC,IAAI;wCAClD,MAAM,uCAAuC,IAAI;;4BA1FJ,aAAa;qCADyF,YAAY;4BAClH,aAAa;0BADyF,YAAY;gCAClH,aAAa"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["router.js"],"names":[],"mappings":"AAWA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAMI,8BAiDU,CAAC,QAnDP,OAAO,mBAAmB,EAAE,IAAI;IAiBrC,6BAA6B;;IAyB7B;;;OAGG;qBAFQ,MAAM,SAQN,CAAC,AAPA;IAKZ;;;OAGG;uBAFQ,MAAM,SACN,CAAC;GAWjB;AAgBM,4CAJI,OAAO,mBAAmB,EAAE,IAAI,UAChC,UAAU;;;wFAlGyG,CAAC;;;oBAU1H,SAAM;EAwFiD,iBA5GnD,GAAE;6BAGoB,KAAI;;;uBAGoB,KAAI;uBAC7B,KAAI;QAElC;;;WAGG;QAEH;;;;;;;;;WASG;QAEH,YAfO,KAAG,CAAC;;gCAAgE,GAAI;qCAC3D,GAAI,GAAE,YAAc,GAAE,CAAC,gBAAe,CAAE,CAAC,OAAO,GAAG,KAAI,OAC1E,oDAEE,EACF,IAAI,CAAC,CAAC,CAAC,CAAC,YACH,eAAe,CAAC,CAAC,WAAW,KAAI,OAAS,oDAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,YACzD;;IA+HD;;;OAGG;mCAFQ,MAAM,EAAE;IAanB;;;OAGG;sCAFQ,MAAM;IAejB,kCAAkC;;GAUvC;;;;mBAnKqC,CAAC;;;;;eAJzB,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,MAAM,EAID,CAAC,AAJG,CAAC,EAAE;;;;;cAE/B,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAEE,CAAC,AAFA,KAAK,IAAI;;;;;gBAElC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI;;;uBA8EzB,MAAM;qCACP,MAAM,EAAE,uCAAuC,IAAI;wCAClD,MAAM,uCAAuC,IAAI;;4BA1FJ,aAAa;qCADyF,YAAY;4BAClH,aAAa;0BADyF,YAAY;gCAClH,aAAa"}

package/src/types.d.ts

@@ -212,7 +212,6 @@ export type ProtocolImpl = {
      */
     outbound: (port: Remote<Port>, remoteAddr: Endpoint, connectionHandler: Remote<ConnectionHandler>) => PromiseVow<Connection>;
 };
-export type PortAllocator = ReturnType<ReturnType<typeof import("@agoric/network").preparePortAllocator>>;
 import type { PromiseVow } from '@agoric/vow';
 import type { RemotableObject } from '@endo/pass-style';
 import type { Remote } from '@agoric/vow';

package/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;4BAa8D,CAAC,sCAAqB,CAAC,mBAD7D,GAAG,EAAE,KAAK,GAAG,IACyB,CAAC,AAAjD,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,OAAO,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC;;;;oBAK5E,MAAM;;;;;uBAIN,MAAM;;;;;;;;;;;;;;;;;;;uBAcI,QAAQ;;;;;;;;;;qBAMjB,MAAM,QAAQ;;;;;;;;sBAKf,QAAQ;;;;;;;;;;;;;;;;;;;;;;8CAeL,QAAQ,cACP,QAAQ;;;;gDAMT,QAAQ,cACP,QAAQ;;;;yCAIe,GAAG;;;;;;;;;;;wBASzB,KAAK,SACX,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;;;;;;qBAIjB,MAAM,QAAQ;;;;sBAEd,MAAM,QAAQ;;;;;;;;;;0DAUZ,QAAQ,cACP,QAAQ;;;;uDAMf,KAAK,uCAEH,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;yDAKjB,WAAW;;;;;0BAKZ,GAAG,GAAG,IAAI;;;;;;;;;;;;;;;;;;gCAeG,QAAQ;;;;4CAIlB,QAAQ;;;;8CAMR,QAAQ;;;;oDAOR,QAAQ;;;;qDAOR,QAAQ,UACX,QAAQ;;;;+CAML,QAAQ,UACX,QAAQ;;;;8CAOL,QAAQ;;;;;;;;;mBAMH,kBAAkB;;;;;qBAEzB,MAAM,QAAQ;;;;;sBAEd,MAAM,QAAQ;;;;;;;;;;;;;;uBAKL,QAAQ;;;;0BAGd,QAAQ,cACR,QAAQ;;;;+CAKR,QAAQ;;4BAMX,UAAU,CAAC,UAAU,CAAC,cAAc,iBAAiB,EAAE,oBAAoB,CAAC,CAAC;gCApMtD,aAAa;qCADN,kBAAkB;4BACzB,aAAa"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";;;4BAa8D,CAAC,sCAAqB,CAAC,mBAD7D,GAAG,EAAE,KAAK,GAAG,IACyB,CAAC,AAAjD,GAAG,QAAQ,CAAC;IAAE,IAAI,EAAE,OAAO,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAAC,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC;;;;oBAK5E,MAAM;;;;;uBAIN,MAAM;;;;;;;;;;;;;;;;;;;uBAcI,QAAQ;;;;;;;;;;qBAMjB,MAAM,QAAQ;;;;;;;;sBAKf,QAAQ;;;;;;;;;;;;;;;;;;;;;;8CAeL,QAAQ,cACP,QAAQ;;;;gDAMT,QAAQ,cACP,QAAQ;;;;yCAIe,GAAG;;;;;;;;;;;wBASzB,KAAK,SACX,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;;;;;;qBAIjB,MAAM,QAAQ;;;;sBAEd,MAAM,QAAQ;;;;;;;;;;0DAUZ,QAAQ,cACP,QAAQ;;;;uDAMf,KAAK,uCAEH,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;yDAKjB,WAAW;;;;;0BAKZ,GAAG,GAAG,IAAI;;;;;;;;;;;;;;;;;;gCAeG,QAAQ;;;;4CAIlB,QAAQ;;;;8CAMR,QAAQ;;;;oDAOR,QAAQ;;;;qDAOR,QAAQ,UACX,QAAQ;;;;+CAML,QAAQ,UACX,QAAQ;;;;8CAOL,QAAQ;;;;;;;;;mBAMH,kBAAkB;;;;;qBAEzB,MAAM,QAAQ;;;;;sBAEd,MAAM,QAAQ;;;;;;;;;;;;;;uBAKL,QAAQ;;;;0BAGd,QAAQ,cACR,QAAQ;;;;+CAKR,QAAQ;;gCA9LY,aAAa;qCADN,kBAAkB;4BACzB,aAAa"}

package/src/types.js

@@ -200,5 +200,3 @@ export {};
  * ) => PromiseVow<Connection>} outbound
  *   Create an outbound connection
  */
-
-/** @typedef {ReturnType<ReturnType<typeof import('@agoric/network').preparePortAllocator>>} PortAllocator */