@agoric/network 0.1.1-dev-7ffae88.0 → 0.1.1-orchestration-dev-096c4e8.0

package/src/router.d.ts

@@ -8,26 +8,33 @@
  * @property {(prefix: string, route: T) => void} unregister Remove a
  *   prefix->route from the database
  */
-/**
- * Create a slash-delimited router.
- *
- * @template T
- * @returns {Router<T>} a new Router
- */
-export default function makeRouter<T>(): Router<T>;
-/**
- * @typedef {object} RouterProtocol
- * @property {(prefix: string) => Promise<Port>} bind
- * @property {(paths: string[], protocolHandler: ProtocolHandler) => void} registerProtocolHandler
- * @property {(prefix: string, protocolHandler: ProtocolHandler) => void} unregisterProtocolHandler
- */
-/**
- * Create a router that behaves like a Protocol.
- *
- * @param {typeof defaultE} [E] Eventual sender
- * @returns {RouterProtocol} The new delegated protocol
- */
-export function makeRouterProtocol(E?: ((<T>(x: T) => import("@endo/eventual-send/src/E.js").ECallableOrMethods<import("@endo/eventual-send").RemoteFunctions<T>>) & {
+export const RouterI: import("@endo/patterns").InterfaceGuard<{
+    getRoutes: import("@endo/patterns").MethodGuard;
+    register: import("@endo/patterns").MethodGuard;
+    unregister: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareRouter<T>(zone: import('@agoric/base-zone').Zone): () => import("@endo/exo/src/exo-makers.js").Guarded<{
+    /** @param {Endpoint} addr */
+    getRoutes(addr: Endpoint): [string, T][];
+    /**
+     * @param {string} prefix
+     * @param {T} route
+     */
+    register(prefix: string, route: T): void;
+    /**
+     * @param {string} prefix
+     * @param {T} route
+     */
+    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;
+    watchPromise?: ((p: PromiseLike<any>, watcher: import("@agoric/vow/src/watch-promise.js").PromiseWatcher, ...args: unknown[]) => void) | undefined;
+} | undefined) => {
+    when: <T = any, TResult1 = import("@agoric/vow/src/E.js").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow/src/E.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("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: unknown) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
+    makeVowKit: <T_2>() => import("@agoric/vow").VowKit<T_2>;
+}>, E?: ((<T_3>(x: T_3) => import("@endo/eventual-send/src/E.js").ECallableOrMethods<import("@endo/eventual-send").RemoteFunctions<T_3>>) & {
     readonly get: <T_1>(x: T_1) => import("@endo/eventual-send/src/E.js").EGetters<import("@endo/eventual-send").LocalRecord<T_1>>;
     readonly resolve: {
         (): Promise<void>;
@@ -36,7 +43,20 @@ export function makeRouterProtocol(E?: ((<T>(x: T) => import("@endo/eventual-sen
     };
     readonly sendOnly: <T_4>(x: T_4) => import("@endo/eventual-send/src/E.js").ESendOnlyCallableOrMethods<import("@endo/eventual-send").RemoteFunctions<T_4>>;
     readonly when: <T_5, U = T_5>(x: T_5 | PromiseLike<T_5>, onfulfilled?: ((value: T_5) => import("@endo/eventual-send").ERef<U>) | undefined, onrejected?: ((reason: any) => import("@endo/eventual-send").ERef<U>) | undefined) => Promise<U>;
-}) | undefined): RouterProtocol;
+}) | undefined): () => import("@endo/exo/src/exo-makers.js").Guarded<{
+    /**
+     * @param {string[]} paths
+     * @param {ProtocolHandler} protocolHandler
+     */
+    registerProtocolHandler(paths: string[], protocolHandler: ProtocolHandler): void;
+    /**
+     * @param {string} prefix
+     * @param {ProtocolHandler} protocolHandler
+     */
+    unregisterProtocolHandler(prefix: string, protocolHandler: ProtocolHandler): void;
+    /** @param {Endpoint} localAddr */
+    bind(localAddr: Endpoint): Promise<Port | import("@agoric/vow").Vow<Port>>;
+}>;
 /**
  * A delimited string router implementation
  */
@@ -58,7 +78,7 @@ export type Router<T> = {
     unregister: (prefix: string, route: T) => void;
 };
 export type RouterProtocol = {
-    bind: (prefix: string) => Promise<Port>;
+    bind: (prefix: string) => PromiseVow<Port>;
     registerProtocolHandler: (paths: string[], protocolHandler: ProtocolHandler) => void;
     unregisterProtocolHandler: (prefix: string, protocolHandler: ProtocolHandler) => void;
 };

package/src/router.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["router.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AAEH;;;;;GAKG;AACH,mDAkCC;AAED;;;;;GAKG;AAEH;;;;;GAKG;AACH;;;;;;;;;iBAFa,cAAc,CAyC1B;;;;;;;;;sBAtGoB,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE;;;;;uBAEtB,MAAM,SAAS,CAAC,KAAK,IAAI;;;;;yBAEzB,MAAM,SAAS,CAAC,KAAK,IAAI;;;mBAgDzB,MAAM,KAAK,QAAQ,IAAI,CAAC;qCACzB,MAAM,EAAE,mBAAmB,eAAe,KAAK,IAAI;wCAClD,MAAM,mBAAmB,eAAe,KAAK,IAAI"}
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["router.js"],"names":[],"mappings":"AAaA;;;;;;;;;GASG;AAEH;;;;GAIG;AAMI,uCAFI,OAAO,mBAAmB,EAAE,IAAI;IAiBrC,6BAA6B;oBAAjB,QAAQ;IAyBpB;;;OAGG;qBAFQ,MAAM;IAMjB;;;OAGG;uBAFQ,MAAM;GAYtB;AAgBM,4CAJI,OAAO,mBAAmB,EAAE,IAAI,UAChC;;;;;;;EAAiD;;;;;;;;;;IAoCtD;;;OAGG;mCAFQ,MAAM,EAAE,mBACR,eAAe;IAY1B;;;OAGG;sCAFQ,MAAM,mBACN,eAAe;IAc1B,kCAAkC;oBAAtB,QAAQ;GAUzB;;;;;;;;;sBAvKoB,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE;;;;;uBAEtB,MAAM,SAAS,CAAC,KAAK,IAAI;;;;;yBAEzB,MAAM,SAAS,CAAC,KAAK,IAAI;;;mBA8EzB,MAAM,KAAK,WAAW,IAAI,CAAC;qCAC5B,MAAM,EAAE,mBAAmB,eAAe,KAAK,IAAI;wCAClD,MAAM,mBAAmB,eAAe,KAAK,IAAI"}

package/src/router.js

@@ -1,7 +1,12 @@
-import { Far, E as defaultE } from '@endo/far';
-import { makeScalarMapStore } from '@agoric/store';
+// @ts-check
+import { E as defaultE } from '@endo/far';
+import { M } from '@endo/patterns';
 import { Fail } from '@agoric/assert';
-import { makeNetworkProtocol, ENDPOINT_SEPARATOR } from './network.js';
+import {
+  ENDPOINT_SEPARATOR,
+  Shape,
+  prepareNetworkProtocol,
+} from './network.js';
 
 import '@agoric/store/exported.js';
 /// <reference path="./types.js" />
@@ -17,51 +22,81 @@ import '@agoric/store/exported.js';
  *   prefix->route from the database
  */
 
+export const RouterI = M.interface('Router', {
+  getRoutes: M.call(Shape.Endpoint).returns(M.arrayOf([M.string(), M.any()])),
+  register: M.call(M.string(), M.any()).returns(M.undefined()),
+  unregister: M.call(M.string(), M.any()).returns(M.undefined()),
+});
+
 /**
- * Create a slash-delimited router.
- *
  * @template T
- * @returns {Router<T>} a new Router
+ * @param {import('@agoric/base-zone').Zone} zone
  */
-export default function makeRouter() {
-  /** @type {MapStore<string, T>} */
-  const prefixToRoute = makeScalarMapStore('prefix');
-  return Far('Router', {
-    getRoutes(addr) {
-      const parts = addr.split(ENDPOINT_SEPARATOR);
-      /** @type {[string, T][]} */
-      const ret = [];
-      for (let i = parts.length; i > 0; i -= 1) {
-        // Try most specific match.
-        const prefix = parts.slice(0, i).join(ENDPOINT_SEPARATOR);
-        if (prefixToRoute.has(prefix)) {
-          ret.push([prefix, prefixToRoute.get(prefix)]);
-        }
-        // Trim off the last value (after the slash).
-        const defaultPrefix = prefix.substr(
-          0,
-          prefix.lastIndexOf(ENDPOINT_SEPARATOR) + 1,
-        );
-        if (prefixToRoute.has(defaultPrefix)) {
-          ret.push([defaultPrefix, prefixToRoute.get(defaultPrefix)]);
-        }
-      }
-      return harden(ret);
-    },
-    register(prefix, route) {
-      prefixToRoute.init(prefix, route);
+export const prepareRouter = zone => {
+  const detached = zone.detached();
+
+  const makeRouter = zone.exoClass(
+    'Router',
+    RouterI,
+    () => {
+      /** @type {MapStore<string, T>} */
+      const prefixToRoute = detached.mapStore('prefix');
+
+      return {
+        prefixToRoute,
+      };
     },
-    unregister(prefix, route) {
-      prefixToRoute.get(prefix) === route ||
-        Fail`Router is not registered at prefix ${prefix}`;
-      prefixToRoute.delete(prefix);
+    {
+      /** @param {Endpoint} addr */
+      getRoutes(addr) {
+        const parts = addr.split(ENDPOINT_SEPARATOR);
+        /** @type {[string, T][]} */
+        const ret = [];
+        for (let i = parts.length; i > 0; i -= 1) {
+          // Try most specific match.
+          const prefix = parts.slice(0, i).join(ENDPOINT_SEPARATOR);
+          if (this.state.prefixToRoute.has(prefix)) {
+            ret.push([prefix, this.state.prefixToRoute.get(prefix)]);
+          }
+          // Trim off the last value (after the slash).
+          const defaultPrefix = prefix.substr(
+            0,
+            prefix.lastIndexOf(ENDPOINT_SEPARATOR) + 1,
+          );
+          if (this.state.prefixToRoute.has(defaultPrefix)) {
+            ret.push([
+              defaultPrefix,
+              this.state.prefixToRoute.get(defaultPrefix),
+            ]);
+          }
+        }
+        return harden(ret);
+      },
+      /**
+       * @param {string} prefix
+       * @param {T} route
+       */
+      register(prefix, route) {
+        this.state.prefixToRoute.init(prefix, route);
+      },
+      /**
+       * @param {string} prefix
+       * @param {T} route
+       */
+      unregister(prefix, route) {
+        this.state.prefixToRoute.get(prefix) === route ||
+          Fail`Router is not registered at prefix ${prefix}`;
+        this.state.prefixToRoute.delete(prefix);
+      },
     },
-  });
-}
+  );
+
+  return makeRouter;
+};
 
 /**
  * @typedef {object} RouterProtocol
- * @property {(prefix: string) => Promise<Port>} bind
+ * @property {(prefix: string) => PromiseVow<Port>} bind
  * @property {(paths: string[], protocolHandler: ProtocolHandler) => void} registerProtocolHandler
  * @property {(prefix: string, protocolHandler: ProtocolHandler) => void} unregisterProtocolHandler
  */
@@ -69,46 +104,81 @@ export default function makeRouter() {
 /**
  * Create a router that behaves like a Protocol.
  *
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
  * @param {typeof defaultE} [E] Eventual sender
- * @returns {RouterProtocol} The new delegated protocol
  */
-export function makeRouterProtocol(E = defaultE) {
-  const router = makeRouter();
-  /** @type {MapStore<string, Protocol>} */
-  const protocols = makeScalarMapStore('prefix');
-  /** @type {MapStore<string, ProtocolHandler>} */
-  const protocolHandlers = makeScalarMapStore('prefix');
+export const prepareRouterProtocol = (zone, powers, E = defaultE) => {
+  const detached = zone.detached();
+
+  const makeRouter = prepareRouter(zone);
+  const makeNetworkProtocol = prepareNetworkProtocol(zone, powers);
+
+  const makeRouterProtocol = zone.exoClass(
+    'RouterProtocol',
+    M.interface('RouterProtocol', {
+      registerProtocolHandler: M.call(
+        M.arrayOf(M.string()),
+        M.remotable(),
+      ).returns(),
+      unregisterProtocolHandler: M.call(M.string(), M.remotable()).returns(),
+      bind: M.callWhen(Shape.Endpoint).returns(Shape.Vow$(Shape.Port)),
+    }),
+    () => {
+      /** @type {Router<Protocol>} */
+      const router = makeRouter();
 
-  function registerProtocolHandler(paths, protocolHandler) {
-    const protocol = makeNetworkProtocol(protocolHandler);
-    for (const prefix of paths) {
-      router.register(prefix, protocol);
-      protocols.init(prefix, protocol);
-      protocolHandlers.init(prefix, protocolHandler);
-    }
-  }
+      /** @type {MapStore<string, Protocol>} */
+      const protocols = detached.mapStore('prefix');
 
-  // FIXME: Buggy.
-  // Needs to account for multiple paths.
-  function unregisterProtocolHandler(prefix, protocolHandler) {
-    const ph = protocolHandlers.get(prefix);
-    ph === protocolHandler ||
-      Fail`Protocol handler is not registered at prefix ${prefix}`;
-    router.unregister(prefix, ph);
-    protocols.delete(prefix);
-    protocolHandlers.delete(prefix);
-  }
+      /** @type {MapStore<string, ProtocolHandler>} */
+      const protocolHandlers = detached.mapStore('prefix');
 
-  /** @type {Protocol['bind']} */
-  async function bind(localAddr) {
-    const [route] = router.getRoutes(localAddr);
-    route !== undefined || Fail`No registered router for ${localAddr}`;
-    return E(route[1]).bind(localAddr);
-  }
+      return {
+        router,
+        protocolHandlers,
+        protocols,
+      };
+    },
+    {
+      /**
+       * @param {string[]} paths
+       * @param {ProtocolHandler} protocolHandler
+       */
+      registerProtocolHandler(paths, protocolHandler) {
+        const protocol = makeNetworkProtocol(protocolHandler);
+        for (const prefix of paths) {
+          this.state.router.register(prefix, protocol);
+          this.state.protocols.init(prefix, protocol);
+          this.state.protocolHandlers.init(prefix, protocolHandler);
+        }
+      },
+      // FIXME: Buggy.
+      // Needs to account for multiple paths.
+      /**
+       * @param {string} prefix
+       * @param {ProtocolHandler} protocolHandler
+       */
+      unregisterProtocolHandler(prefix, protocolHandler) {
+        const ph = this.state.protocolHandlers.get(prefix);
+        ph === protocolHandler ||
+          Fail`Protocol handler is not registered at prefix ${prefix}`;
+        // TODO: unmap protocol hanlders to their corresponding protocol
+        // e.g. using a map
+        // before unregistering
+        // @ts-expect-error note FIXME above
+        this.state.router.unregister(prefix, ph);
+        this.state.protocols.delete(prefix);
+        this.state.protocolHandlers.delete(prefix);
+      },
+      /** @param {Endpoint} localAddr */
+      async bind(localAddr) {
+        const [route] = this.state.router.getRoutes(localAddr);
+        route !== undefined || Fail`No registered router for ${localAddr}`;
+        return E(route[1]).bind(localAddr);
+      },
+    },
+  );
 
-  return Far('RouterProtocol', {
-    bind,
-    registerProtocolHandler,
-    unregisterProtocolHandler,
-  });
-}
+  return makeRouterProtocol;
+};

package/src/types.d.ts

@@ -1,3 +1,4 @@
+type PromiseVow<T> = Promise<T | import('@agoric/vow').Vow<T>>;
 type Data = string | Buffer | ArrayBuffer;
 type Bytes = string;
 /**
@@ -12,7 +13,7 @@ type Closable = {
     /**
      * Terminate the object
      */
-    close: () => Promise<void>;
+    close: () => PromiseVow<void>;
 };
 /**
  * The network Protocol
@@ -22,7 +23,7 @@ type Protocol = {
      * Claim a port, or if
      * ending in ENDPOINT_SEPARATOR, a fresh name
      */
-    bind: (prefix: Endpoint) => Promise<Port>;
+    bind: (prefix: Endpoint) => PromiseVow<Port>;
 };
 /**
  * A port that has been bound to a protocol
@@ -36,15 +37,15 @@ type Port = {
     /**
      *   Begin accepting incoming connections
      */
-    addListener: (acceptHandler: ListenHandler) => Promise<void>;
+    addListener: (acceptHandler: ListenHandler) => PromiseVow<void>;
     /**
      *   Make an outbound connection
      */
-    connect: (remote: Endpoint, connectionHandler?: ConnectionHandler) => Promise<Connection>;
+    connect: (remote: Endpoint, connectionHandler?: ConnectionHandler) => PromiseVow<Connection>;
     /**
      *   Remove the currently-bound listener
      */
-    removeListener: (acceptHandler: ListenHandler) => Promise<void>;
+    removeListener: (acceptHandler: ListenHandler) => PromiseVow<void>;
     /**
      * Deallocate the port entirely, removing all
      * listeners and closing all active connections
@@ -59,34 +60,34 @@ type ListenHandler = {
      * The
      * listener has been registered
      */
-    onListen?: ((port: Port, l: ListenHandler) => Promise<void>) | undefined;
+    onListen?: ((port: Port, l: ListenHandler) => PromiseVow<void>) | undefined;
     /**
      *   A new connection is incoming
      */
-    onAccept: (port: Port, localAddr: Endpoint, remoteAddr: Endpoint, l: ListenHandler) => Promise<ConnectionHandler>;
+    onAccept: (port: Port, localAddr: Endpoint, remoteAddr: Endpoint, l: ListenHandler) => PromiseVow<ConnectionHandler>;
     /**
      * The connection was rejected
      */
-    onReject?: ((port: Port, localAddr: Endpoint, remoteAddr: Endpoint, l: ListenHandler) => Promise<void>) | undefined;
+    onReject?: ((port: Port, localAddr: Endpoint, remoteAddr: Endpoint, l: ListenHandler) => PromiseVow<void>) | undefined;
     /**
      * There was an error while listening
      */
-    onError?: ((port: Port, rej: any, l: ListenHandler) => Promise<void>) | undefined;
+    onError?: ((port: Port, rej: any, l: ListenHandler) => PromiseVow<void>) | undefined;
     /**
      * The
      * listener has been removed
      */
-    onRemove?: ((port: Port, l: ListenHandler) => Promise<void>) | undefined;
+    onRemove?: ((port: Port, l: ListenHandler) => PromiseVow<void>) | undefined;
 };
 type Connection = {
     /**
      *   Send a packet on the connection
      */
-    send: (packetBytes: Data, opts?: Record<string, any>) => Promise<Bytes>;
+    send: (packetBytes: Data, opts?: Record<string, any>) => PromiseVow<Bytes>;
     /**
      * Close both ends of the connection
      */
-    close: () => Promise<void>;
+    close: () => PromiseVow<void>;
     /**
      * Get the locally bound name of this
      * connection
@@ -104,15 +105,15 @@ type ConnectionHandler = {
     /**
      * The connection has been opened
      */
-    onOpen?: ((connection: Connection, localAddr: Endpoint, remoteAddr: Endpoint, c: ConnectionHandler) => void) | undefined;
+    onOpen?: ((connection: Connection, localAddr: Endpoint, remoteAddr: Endpoint, c: ConnectionHandler) => PromiseVow<void>) | undefined;
     /**
      * The connection received a packet
      */
-    onReceive?: ((connection: Connection, packetBytes: Bytes, c: ConnectionHandler, opts?: Record<string, any>) => Promise<Data>) | undefined;
+    onReceive?: ((connection: Connection, ack: Bytes, c: ConnectionHandler, opts?: Record<string, any>) => PromiseVow<Data>) | undefined;
     /**
      * The connection has been closed
      */
-    onClose?: ((connection: Connection, reason?: CloseReason, c?: ConnectionHandler) => Promise<void>) | undefined;
+    onClose?: ((connection: Connection, reason?: CloseReason, c?: ConnectionHandler) => PromiseVow<void>) | undefined;
 };
 /**
  * The reason a connection was closed
@@ -131,35 +132,35 @@ type ProtocolHandler = {
     /**
      *   This protocol is created
      */
-    onCreate: (protocol: ProtocolImpl, p: ProtocolHandler) => Promise<void>;
+    onCreate: (protocol: ProtocolImpl, p: ProtocolHandler) => PromiseVow<void>;
     /**
      *   Create a fresh port identifier for this protocol
      */
-    generatePortID: (localAddr: Endpoint, p: ProtocolHandler) => Promise<string>;
+    generatePortID: (localAddr: Endpoint, p: ProtocolHandler) => PromiseVow<string>;
     /**
      *   A port will be bound
      */
-    onBind: (port: Port, localAddr: Endpoint, p: ProtocolHandler) => Promise<void>;
+    onBind: (port: Port, localAddr: Endpoint, p: ProtocolHandler) => PromiseVow<void>;
     /**
      *   A port was listening
      */
-    onListen: (port: Port, localAddr: Endpoint, listenHandler: ListenHandler, p: ProtocolHandler) => Promise<void>;
+    onListen: (port: Port, localAddr: Endpoint, listenHandler: ListenHandler, p: ProtocolHandler) => PromiseVow<void>;
     /**
      *   A port listener has been reset
      */
-    onListenRemove: (port: Port, localAddr: Endpoint, listenHandler: ListenHandler, p: ProtocolHandler) => Promise<void>;
+    onListenRemove: (port: Port, localAddr: Endpoint, listenHandler: ListenHandler, p: ProtocolHandler) => PromiseVow<void>;
     /**
      * Return unique suffix for local address
      */
-    onInstantiate?: ((port: Port, localAddr: Endpoint, remote: Endpoint, p: ProtocolHandler) => Promise<Endpoint>) | undefined;
+    onInstantiate?: ((port: Port, localAddr: Endpoint, remote: Endpoint, p: ProtocolHandler) => PromiseVow<Endpoint>) | undefined;
     /**
      *   A port initiates an outbound connection
      */
-    onConnect: (port: Port, localAddr: Endpoint, remote: Endpoint, c: ConnectionHandler, p: ProtocolHandler) => Promise<AttemptDescription>;
+    onConnect: (port: Port, localAddr: Endpoint, remote: Endpoint, c: ConnectionHandler, p: ProtocolHandler) => PromiseVow<AttemptDescription>;
     /**
      *   The port is being completely destroyed
      */
-    onRevoke: (port: Port, localAddr: Endpoint, p: ProtocolHandler) => Promise<void>;
+    onRevoke: (port: Port, localAddr: Endpoint, p: ProtocolHandler) => PromiseVow<void>;
 };
 /**
  * An inbound connection attempt
@@ -168,7 +169,7 @@ type InboundAttempt = {
     /**
      *   Establish the connection
      */
-    accept: (desc: AttemptDescription) => Promise<Connection>;
+    accept: (desc: AttemptDescription) => PromiseVow<Connection>;
     /**
      * Return the local address for this
      * attempt
@@ -182,7 +183,7 @@ type InboundAttempt = {
     /**
      * Abort the attempt
      */
-    close: () => Promise<void>;
+    close: () => PromiseVow<void>;
 };
 /**
  * Things the protocol can do for us
@@ -192,14 +193,14 @@ type ProtocolImpl = {
      * Claim a port, or if
      * ending in ENDPOINT_SEPARATOR, a fresh name
      */
-    bind: (prefix: Endpoint) => Promise<Port>;
+    bind: (prefix: Endpoint) => PromiseVow<Port>;
     /**
      *   Make an attempt to connect into this protocol
      */
-    inbound: (listenAddr: Endpoint, remoteAddr: Endpoint) => Promise<InboundAttempt>;
+    inbound: (listenAddr: Endpoint, remoteAddr: Endpoint) => PromiseVow<InboundAttempt>;
     /**
      *   Create an outbound connection
      */
-    outbound: (port: Port, remoteAddr: Endpoint, connectionHandler: ConnectionHandler) => Promise<Connection>;
+    outbound: (port: Port, remoteAddr: Endpoint, connectionHandler: ConnectionHandler) => PromiseVow<Connection>;
 };
 //# sourceMappingURL=types.d.ts.map

package/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"YACa,MAAM,GAAG,MAAM,GAAG,WAAW;aAE7B,MAAM;;;;;gBAIN,MAAM;;;;;;;;WAML,MAAM,QAAQ,IAAI,CAAC;;;;;;;;;;mBAKV,QAAQ,KAAK,QAAQ,IAAI,CAAC;;;;;;;;;;qBAMnC,MAAM,QAAQ;;;;iCAEE,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;sBAGhD,QAAQ,sBACI,iBAAiB,KAClC,QAAQ,UAAU,CAAC;;;;oCAEG,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;;YAE/C,MAAM,IAAI;;;;;;;;;;uBAMH,IAAI,KAAK,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;qBAGlD,IAAI,aACC,QAAQ,cACP,QAAQ,KACjB,aAAa,KACb,QAAQ,iBAAiB,CAAC;;;;uBAGvB,IAAI,aACC,QAAQ,cACP,QAAQ,KACjB,aAAa,KACb,QAAQ,IAAI,CAAC;;;;sBAEA,IAAI,OAAO,GAAG,KAAK,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;;uBAElD,IAAI,KAAK,aAAa,KAAK,QAAQ,IAAI,CAAC;;;;;;wBAO3C,IAAI,SACV,OAAO,MAAM,EAAE,GAAG,CAAC,KACvB,QAAQ,KAAK,CAAC;;;;WAER,MAAM,QAAQ,IAAI,CAAC;;;;;qBACnB,MAAM,QAAQ;;;;sBAEd,MAAM,QAAQ;;;;;;;;;2BAMX,UAAU,aACX,QAAQ,cACP,QAAQ,KACjB,iBAAiB,KACjB,IAAI;;;;8BAGK,UAAU,eACT,KAAK,KACf,iBAAiB,SACb,OAAO,MAAM,EAAE,GAAG,CAAC,KACvB,QAAQ,IAAI,CAAC;;;;4BAGJ,UAAU,WACb,WAAW,MAChB,iBAAiB,KAClB,QAAQ,IAAI,CAAC;;;;;mBAGR,GAAG,GAAG,IAAI;;aAKT,iBAAiB;;;;;;;;;;;;yBAQN,YAAY,KAAK,eAAe,KAAK,QAAQ,IAAI,CAAC;;;;gCAEjD,QAAQ,KAAK,eAAe,KAAK,QAAQ,MAAM,CAAC;;;;mBAG/D,IAAI,aACC,QAAQ,KAChB,eAAe,KACf,QAAQ,IAAI,CAAC;;;;qBAGV,IAAI,aACC,QAAQ,iBACJ,aAAa,KACzB,eAAe,KACf,QAAQ,IAAI,CAAC;;;;2BAGV,IAAI,aACC,QAAQ,iBACJ,aAAa,KACzB,eAAe,KACf,QAAQ,IAAI,CAAC;;;;4BAGV,IAAI,aACC,QAAQ,UACX,QAAQ,KACb,eAAe,KACf,QAAQ,QAAQ,CAAC;;;;sBAGd,IAAI,aACC,QAAQ,UACX,QAAQ,KACb,iBAAiB,KACjB,eAAe,KACf,QAAQ,kBAAkB,CAAC;;;;qBAGxB,IAAI,aACC,QAAQ,KAChB,eAAe,KACf,QAAQ,IAAI,CAAC;;;;;;;;;mBAIA,kBAAkB,KAAK,QAAQ,UAAU,CAAC;;;;;qBAEjD,MAAM,QAAQ;;;;;sBAEd,MAAM,QAAQ;;;;WAEd,MAAM,QAAQ,IAAI,CAAC;;;;;;;;;;mBAGV,QAAQ,KAAK,QAAQ,IAAI,CAAC;;;;0BAGhC,QAAQ,cACR,QAAQ,KACjB,QAAQ,cAAc,CAAC;;;;qBAGpB,IAAI,cACE,QAAQ,qBACD,iBAAiB,KACjC,QAAQ,UAAU,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":"qBAIa,QAAQ,CAAC,GAAG,OAAO,aAAa,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;YAIzC,MAAM,GAAG,MAAM,GAAG,WAAW;aAE7B,MAAM;;;;;gBAIN,MAAM;;;;;;;;WAML,MAAM,WAAW,IAAI,CAAC;;;;;;;;;;mBAKb,QAAQ,KAAK,WAAW,IAAI,CAAC;;;;;;;;;;qBAMtC,MAAM,QAAQ;;;;iCAEE,aAAa,KAAK,WAAW,IAAI,CAAC;;;;sBAGnD,QAAQ,sBACI,iBAAiB,KAClC,WAAW,UAAU,CAAC;;;;oCAEA,aAAa,KAAK,WAAW,IAAI,CAAC;;;;;YAElD,MAAM,IAAI;;;;;;;;;;uBAMH,IAAI,KAAK,aAAa,KAAK,WAAW,IAAI,CAAC;;;;qBAGrD,IAAI,aACC,QAAQ,cACP,QAAQ,KACjB,aAAa,KACb,WAAW,iBAAiB,CAAC;;;;uBAG1B,IAAI,aACC,QAAQ,cACP,QAAQ,KACjB,aAAa,KACb,WAAW,IAAI,CAAC;;;;sBAEH,IAAI,OAAO,GAAG,KAAK,aAAa,KAAK,WAAW,IAAI,CAAC;;;;;uBAErD,IAAI,KAAK,aAAa,KAAK,WAAW,IAAI,CAAC;;;;;;wBAO9C,IAAI,SACV,OAAO,MAAM,EAAE,GAAG,CAAC,KACvB,WAAW,KAAK,CAAC;;;;WAEX,MAAM,WAAW,IAAI,CAAC;;;;;qBACtB,MAAM,QAAQ;;;;sBAEd,MAAM,QAAQ;;;;;;;;;2BAMX,UAAU,aACX,QAAQ,cACP,QAAQ,KACjB,iBAAiB,KACjB,WAAW,IAAI,CAAC;;;;8BAGP,UAAU,OACjB,KAAK,KACP,iBAAiB,SACb,OAAO,MAAM,EAAE,GAAG,CAAC,KACvB,WAAW,IAAI,CAAC;;;;4BAGP,UAAU,WACb,WAAW,MAChB,iBAAiB,KAClB,WAAW,IAAI,CAAC;;;;;mBAGX,GAAG,GAAG,IAAI;;aAKT,iBAAiB;;;;;;;;;;;;yBAQN,YAAY,KAAK,eAAe,KAAK,WAAW,IAAI,CAAC;;;;gCAEpD,QAAQ,KAAK,eAAe,KAAK,WAAW,MAAM,CAAC;;;;mBAGlE,IAAI,aACC,QAAQ,KAChB,eAAe,KACf,WAAW,IAAI,CAAC;;;;qBAGb,IAAI,aACC,QAAQ,iBACJ,aAAa,KACzB,eAAe,KACf,WAAW,IAAI,CAAC;;;;2BAGb,IAAI,aACC,QAAQ,iBACJ,aAAa,KACzB,eAAe,KACf,WAAW,IAAI,CAAC;;;;4BAGb,IAAI,aACC,QAAQ,UACX,QAAQ,KACb,eAAe,KACf,WAAW,QAAQ,CAAC;;;;sBAGjB,IAAI,aACC,QAAQ,UACX,QAAQ,KACb,iBAAiB,KACjB,eAAe,KACf,WAAW,kBAAkB,CAAC;;;;qBAG3B,IAAI,aACC,QAAQ,KAChB,eAAe,KACf,WAAW,IAAI,CAAC;;;;;;;;;mBAIH,kBAAkB,KAAK,WAAW,UAAU,CAAC;;;;;qBAEpD,MAAM,QAAQ;;;;;sBAEd,MAAM,QAAQ;;;;WAEd,MAAM,WAAW,IAAI,CAAC;;;;;;;;;;mBAGb,QAAQ,KAAK,WAAW,IAAI,CAAC;;;;0BAGnC,QAAQ,cACR,QAAQ,KACjB,WAAW,cAAc,CAAC;;;;qBAGvB,IAAI,cACE,QAAQ,qBACD,iBAAiB,KACjC,WAAW,UAAU,CAAC"}