@agoric/network 0.1.1-calypso-dev-84eb287.0

package/src/router.d.ts

@@ -0,0 +1,106 @@
+/**
+ * @import {AttemptDescription, Bytes, Closable, CloseReason, Connection, ConnectionHandler, Endpoint, ListenHandler, Port, Protocol, ProtocolHandler, ProtocolImpl} from './types.js';
+ * @import {PromiseVow, Remote, VowKit, VowResolver, VowTools} from '@agoric/vow';
+ */
+/**
+ * @template T
+ * @typedef {object} Router A delimited string router implementation
+ * @property {(addr: string) => [string, T][]} getRoutes Return the match and
+ *   route in order of preference
+ * @property {(prefix: string, route: T) => void} register Add a prefix->route
+ *   to the database
+ * @property {(prefix: string, route: T) => void} unregister Remove a
+ *   prefix->route from the database
+ */
+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").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?: import("@agoric/vow").IsRetryableReason | undefined;
+} | undefined) => {
+    E: (<T>(x: T, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => ECallableOrMethods<RemoteFunctions<T>>) & {
+        readonly get: <T>(x: T, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => EGetters<LocalRecord<T>>;
+        readonly resolve: <T>(x: T, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => Promise<Awaited<T>>;
+        readonly sendOnly: <T>(x: T, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => ESendOnlyCallableOrMethods<RemoteFunctions<T>>;
+        readonly when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(x: import("@agoric/vow/src/E.js").ERef<T>, onfulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => ERef<TResult1>) | undefined, onrejected?: ((reason: any) => ERef<TResult2>) | undefined, opts?: import("@agoric/vow").EUnwrapOptions | undefined) => Promise<TResult1 | TResult2>;
+    } & {
+        when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+        watch: <T = any, TResult1 = T, TResult2 = never, C extends any[] = any[]>(specimenP: import("@agoric/vow").EVow<T>, watcher?: import("@agoric/vow").Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => import("@agoric/vow").Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
+    };
+    when: <T, TResult1 = import("@agoric/vow").EUnwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").EUnwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
+    watch: <T = any, TResult1 = T, TResult2 = never, C extends any[] = any[]>(specimenP: import("@agoric/vow").EVow<T>, watcher?: import("@agoric/vow").Watcher<T, TResult1, TResult2, C> | undefined, ...watcherArgs: C) => import("@agoric/vow").Vow<Exclude<TResult1, void> | Exclude<TResult2, void> extends never ? TResult1 : Exclude<TResult1, void> | Exclude<TResult2, void>>;
+    makeVowKit: <T>() => VowKit<T>;
+    allVows: (maybeVows: import("@agoric/vow").EVow<unknown>[]) => import("@agoric/vow").Vow<any[]>;
+    asVow: <T extends unknown>(fn: (...args: any[]) => import("@agoric/vow").Vow<Awaited<T>> | Awaited<T> | PromiseVow<T>) => import("@agoric/vow").Vow<Awaited<T>>;
+    asPromise: import("@agoric/vow").AsPromiseFunction;
+}>, E?: ((<T>(x: T) => import("../../../node_modules/@endo/eventual-send/src/E.js").ECallableOrMethods<import("@endo/eventual-send").RemoteFunctions<T>>) & {
+    readonly get: <T_1>(x: T_1) => import("../../../node_modules/@endo/eventual-send/src/E.js").EGetters<import("@endo/eventual-send").LocalRecord<T_1>>;
+    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>>;
+    };
+    readonly sendOnly: <T_4>(x: T_4) => import("../../../node_modules/@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): () => import("@endo/exo").Guarded<{
+    /**
+     * @param {string[]} paths
+     * @param {Remote<ProtocolHandler>} protocolHandler
+     */
+    registerProtocolHandler(paths: string[], protocolHandler: Remote<ProtocolHandler>): void;
+    /**
+     * @param {string} prefix
+     * @param {Remote<ProtocolHandler>} protocolHandler
+     */
+    unregisterProtocolHandler(prefix: string, protocolHandler: Remote<ProtocolHandler>): void;
+    /** @param {Endpoint} localAddr */
+    bindPort(localAddr: Endpoint): Promise<Port | import("@agoric/vow").Vow<Port>>;
+}>;
+/**
+ * A delimited string router implementation
+ */
+export type Router<T> = {
+    /**
+     * Return the match and
+     * route in order of preference
+     */
+    getRoutes: (addr: string) => [string, T][];
+    /**
+     * Add a prefix->route
+     * to the database
+     */
+    register: (prefix: string, route: T) => void;
+    /**
+     * Remove a
+     * prefix->route from the database
+     */
+    unregister: (prefix: string, route: T) => void;
+};
+export type RouterProtocol = {
+    bindPort: (prefix: string) => PromiseVow<Port>;
+    registerProtocolHandler: (paths: string[], protocolHandler: ProtocolHandler) => void;
+    unregisterProtocolHandler: (prefix: string, protocolHandler: ProtocolHandler) => void;
+};
+import type { Endpoint } from './types.js';
+import type { VowKit } from '@agoric/vow';
+import type { PromiseVow } from '@agoric/vow';
+import type { ProtocolHandler } from './types.js';
+import type { Remote } from '@agoric/vow';
+import type { Port } from './types.js';
+//# sourceMappingURL=router.d.ts.map

package/src/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["router.js"],"names":[],"mappings":"AAWA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAMI,8BAHM,CAAC,QACH,OAAO,mBAAmB,EAAE,IAAI;IAiBrC,6BAA6B;oBAAjB,QAAQ;IAyBpB;;;OAGG;qBAFQ,MAAM,SACN,CAAC;IAKZ;;;OAGG;uBAFQ,MAAM,SACN,CAAC;GAWjB;AAgBM,4CAJI,OAAO,mBAAmB,EAAE,IAAI,UAChC,UAAU,CAAC;;;;;;;;;;;;;;;;oCArBoB,GAAG;;CAqBc,CAAC;;;;;;;;wEAjGJ,CAAC,0BACxD,qBAEE,kCAEe,CAAC,2BAA4B,qBAAO;;IAgIhD;;;OAGG;mCAFQ,MAAM,EAAE,mBACR,OAAO,eAAe,CAAC;IAYlC;;;OAGG;sCAFQ,MAAM,mBACN,OAAO,eAAe,CAAC;IAclC,kCAAkC;wBAAtB,QAAQ;GAUzB;;;;mBAzKY,CAAC;;;;;eAEA,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE;;;;;cAE/B,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI;;;;;gBAElC,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI;;;cA8ElC,CAAC,MAAM,EAAE,MAAM,KAAK,WAAW,IAAI,CAAC;6BACpC,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,eAAe,EAAE,eAAe,KAAK,IAAI;+BAC3D,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,eAAe,KAAK,IAAI;;8BA3FkG,YAAY;4BAClH,aAAa;gCAAb,aAAa;qCADyF,YAAY;4BAClH,aAAa;0BADyF,YAAY"}

package/src/router.js

@@ -0,0 +1,187 @@
+// @ts-check
+
+/// <reference types="@agoric/store/exported.js" />
+/// <reference path="./types.js" />
+
+import { E as defaultE } from '@endo/far';
+import { M } from '@endo/patterns';
+import { Fail } from '@agoric/assert';
+import { ENDPOINT_SEPARATOR, prepareNetworkProtocol } from './network.js';
+import { Shape } from './shapes.js';
+
+/**
+ * @import {AttemptDescription, Bytes, Closable, CloseReason, Connection, ConnectionHandler, Endpoint, ListenHandler, Port, Protocol, ProtocolHandler, ProtocolImpl} from './types.js';
+ * @import {PromiseVow, Remote, VowKit, VowResolver, VowTools} from '@agoric/vow';
+ */
+
+/**
+ * @template T
+ * @typedef {object} Router A delimited string router implementation
+ * @property {(addr: string) => [string, T][]} getRoutes Return the match and
+ *   route in order of preference
+ * @property {(prefix: string, route: T) => void} register Add a prefix->route
+ *   to the database
+ * @property {(prefix: string, route: T) => void} unregister Remove a
+ *   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()),
+});
+
+/**
+ * @template T
+ * @param {import('@agoric/base-zone').Zone} zone
+ */
+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,
+      };
+    },
+    {
+      /** @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.slice(
+            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) => PromiseVow<Port>} bindPort
+ * @property {(paths: string[], protocolHandler: ProtocolHandler) => void} registerProtocolHandler
+ * @property {(prefix: string, protocolHandler: ProtocolHandler) => void} unregisterProtocolHandler
+ */
+
+/**
+ * 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
+ */
+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(),
+      bindPort: M.callWhen(Shape.Endpoint).returns(Shape.Vow$(Shape.Port)),
+    }),
+    () => {
+      /** @type {Router<Protocol>} */
+      const router = makeRouter();
+
+      /** @type {MapStore<string, Protocol>} */
+      const protocols = detached.mapStore('prefix');
+
+      /** @type {MapStore<string, Remote<ProtocolHandler>>} */
+      const protocolHandlers = detached.mapStore('prefix');
+
+      return {
+        router,
+        protocolHandlers,
+        protocols,
+      };
+    },
+    {
+      /**
+       * @param {string[]} paths
+       * @param {Remote<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 {Remote<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 handlers 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 bindPort(localAddr) {
+        const [route] = this.state.router.getRoutes(localAddr);
+        route !== undefined || Fail`No registered router for ${localAddr}`;
+        return E(route[1]).bindPort(localAddr);
+      },
+    },
+  );
+
+  return makeRouterProtocol;
+};

package/src/shapes.d.ts

@@ -0,0 +1,119 @@
+export namespace Shape {
+    export namespace ConnectionI {
+        let connection: import("@endo/patterns").InterfaceGuard<{
+            send: import("@endo/patterns").MethodGuard;
+            close: import("@endo/patterns").MethodGuard;
+            getLocalAddress: import("@endo/patterns").MethodGuard;
+            getRemoteAddress: import("@endo/patterns").MethodGuard;
+        }>;
+        let openConnectionAckWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        let rethrowUnlessMissingWatcher: import("@endo/patterns").InterfaceGuard<{
+            onRejected: import("@endo/patterns").MethodGuard;
+        }>;
+        let sinkWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+    }
+    export namespace InboundAttemptI {
+        export let inboundAttempt: import("@endo/patterns").InterfaceGuard<{
+            accept: import("@endo/patterns").MethodGuard;
+            getLocalAddress: import("@endo/patterns").MethodGuard;
+            getRemoteAddress: import("@endo/patterns").MethodGuard;
+            close: import("@endo/patterns").MethodGuard;
+        }>;
+        export let inboundAttemptAcceptWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        let rethrowUnlessMissingWatcher_1: import("@endo/patterns").InterfaceGuard<{
+            onRejected: import("@endo/patterns").MethodGuard;
+        }>;
+        export { rethrowUnlessMissingWatcher_1 as rethrowUnlessMissingWatcher };
+        let sinkWatcher_1: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        export { sinkWatcher_1 as sinkWatcher };
+    }
+    export namespace PortI {
+        export let port: import("@endo/patterns").InterfaceGuard<{
+            getLocalAddress: import("@endo/patterns").MethodGuard;
+            addListener: import("@endo/patterns").MethodGuard;
+            connect: import("@endo/patterns").MethodGuard;
+            removeListener: import("@endo/patterns").MethodGuard;
+            revoke: import("@endo/patterns").MethodGuard;
+        }>;
+        export let portAddListenerWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        export let portRemoveListenerWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        export let portConnectWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        export let portRevokeWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        export let portRevokeCleanupWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        let rethrowUnlessMissingWatcher_2: import("@endo/patterns").InterfaceGuard<{
+            onRejected: import("@endo/patterns").MethodGuard;
+        }>;
+        export { rethrowUnlessMissingWatcher_2 as rethrowUnlessMissingWatcher };
+        let sinkWatcher_2: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+            onRejected: import("@endo/patterns").MethodGuard;
+        }>;
+        export { sinkWatcher_2 as sinkWatcher };
+    }
+    export namespace ProtocolHandlerI {
+        export let protocolHandler: import("@endo/patterns").InterfaceGuard<{
+            onCreate: import("@endo/patterns").MethodGuard;
+            generatePortID: import("@endo/patterns").MethodGuard;
+            onBind: import("@endo/patterns").MethodGuard;
+            onListen: import("@endo/patterns").MethodGuard;
+            onListenRemove: import("@endo/patterns").MethodGuard;
+            onInstantiate: import("@endo/patterns").MethodGuard;
+            onConnect: import("@endo/patterns").MethodGuard;
+            onRevoke: import("@endo/patterns").MethodGuard;
+        }>;
+        export let protocolHandlerAcceptWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        export let protocolHandlerInstantiateWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        export let protocolHandlerConnectWatcher: import("@endo/patterns").InterfaceGuard<{
+            onFulfilled: import("@endo/patterns").MethodGuard;
+        }>;
+        let rethrowUnlessMissingWatcher_3: import("@endo/patterns").InterfaceGuard<{
+            onRejected: import("@endo/patterns").MethodGuard;
+        }>;
+        export { rethrowUnlessMissingWatcher_3 as rethrowUnlessMissingWatcher };
+    }
+    export let ProtocolImplI: import("@endo/patterns").InterfaceGuard<{
+        bindPort: import("@endo/patterns").MethodGuard;
+        inbound: import("@endo/patterns").MethodGuard;
+        outbound: import("@endo/patterns").MethodGuard;
+    }>;
+    export let AttemptDescription: import("@endo/patterns").Matcher;
+    export let Opts: import("@endo/patterns").Matcher;
+    export let Data: import("@endo/patterns").Matcher;
+    export let Bytes: import("@endo/patterns").Matcher;
+    export let Endpoint: import("@endo/patterns").Matcher;
+    export { OrVow$ as Vow$ };
+    export { VowShape as Vow };
+    export let ConnectionHandler: import("@endo/patterns").Matcher;
+    export let Connection: import("@endo/patterns").Matcher;
+    export let InboundAttempt: import("@endo/patterns").Matcher;
+    export let Listener: import("@endo/patterns").Matcher;
+    export let ListenHandler: import("@endo/patterns").Matcher;
+    export let Port: import("@endo/patterns").Matcher;
+    export let ProtocolHandler: import("@endo/patterns").Matcher;
+    export let ProtocolImpl: import("@endo/patterns").Matcher;
+}
+import { OrVow$ } from '@agoric/vow';
+import { VowShape } from '@agoric/vow';
+//# sourceMappingURL=shapes.d.ts.map

package/src/shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shapes.d.ts","sourceRoot":"","sources":["shapes.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAEiC,aAAa;yBAAb,aAAa"}

package/src/shapes.js

@@ -0,0 +1,187 @@
+// @ts-check
+import { M } from '@endo/patterns';
+import { VowShape, OrVow$ } from '@agoric/vow';
+
+const Shape1 = /** @type {const} */ ({
+  /**
+   * Data is string | Buffer | ArrayBuffer
+   * but only string is passable
+   */
+  Data: M.string(),
+  Bytes: M.string(),
+  Endpoint: M.string(),
+  Vow$: OrVow$,
+  Vow: VowShape,
+  ConnectionHandler: M.remotable('ConnectionHandler'),
+  Connection: M.remotable('Connection'),
+  InboundAttempt: M.remotable('InboundAttempt'),
+  Listener: M.remotable('Listener'),
+  ListenHandler: M.remotable('ListenHandler'),
+  Port: M.remotable('Port'),
+  ProtocolHandler: M.remotable('ProtocolHandler'),
+  ProtocolImpl: M.remotable('ProtocolImpl'),
+});
+
+const Shape2 = /** @type {const} */ ({
+  ...Shape1,
+  AttemptDescription: M.splitRecord(
+    { handler: Shape1.ConnectionHandler },
+    { remoteAddress: Shape1.Endpoint, localAddress: Shape1.Endpoint },
+  ),
+  Opts: M.recordOf(M.string(), M.any()),
+});
+
+export const Shape = /** @type {const} */ harden({
+  ...Shape2,
+  ConnectionI: {
+    connection: M.interface('Connection', {
+      send: M.callWhen(Shape2.Data)
+        .optional(Shape2.Opts)
+        .returns(Shape2.Vow$(Shape2.Bytes)),
+      close: M.callWhen().returns(Shape2.Vow$(M.undefined())),
+      getLocalAddress: M.call().returns(Shape2.Endpoint),
+      getRemoteAddress: M.call().returns(Shape2.Endpoint),
+    }),
+    openConnectionAckWatcher: M.interface('OpenConnectionAckWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    rethrowUnlessMissingWatcher: M.interface('RethrowUnlessMissingWatcher', {
+      onRejected: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    sinkWatcher: M.interface('SinkWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+    }),
+  },
+  InboundAttemptI: {
+    inboundAttempt: M.interface('InboundAttempt', {
+      accept: M.callWhen(Shape2.AttemptDescription).returns(
+        Shape2.Vow$(Shape2.Connection),
+      ),
+      getLocalAddress: M.call().returns(Shape2.Endpoint),
+      getRemoteAddress: M.call().returns(Shape2.Endpoint),
+      close: M.callWhen().returns(Shape2.Vow$(M.undefined())),
+    }),
+    inboundAttemptAcceptWatcher: M.interface('InboundAttemptAcceptWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    rethrowUnlessMissingWatcher: M.interface('RethrowUnlessMissingWatcher', {
+      onRejected: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    sinkWatcher: M.interface('SinkWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+    }),
+  },
+  PortI: {
+    port: M.interface('Port', {
+      getLocalAddress: M.call().returns(Shape2.Endpoint),
+      addListener: M.callWhen(Shape2.Listener).returns(
+        Shape2.Vow$(M.undefined()),
+      ),
+      connect: M.callWhen(Shape2.Endpoint)
+        .optional(Shape2.ConnectionHandler)
+        .returns(Shape2.Vow$(Shape2.Connection)),
+      removeListener: M.callWhen(Shape2.Listener).returns(
+        Shape2.Vow$(M.undefined()),
+      ),
+      revoke: M.callWhen().returns(Shape2.Vow$(M.undefined())),
+    }),
+    portAddListenerWatcher: M.interface('PortAddListenerWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    portRemoveListenerWatcher: M.interface('PortRemoveListenerWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    portConnectWatcher: M.interface('PortConnectWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    portRevokeWatcher: M.interface('PortRevokeWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    portRevokeCleanupWatcher: M.interface('PortRevokeCleanupWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    rethrowUnlessMissingWatcher: M.interface('RethrowUnlessMissingWatcher', {
+      onRejected: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+    sinkWatcher: M.interface('SinkWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+      onRejected: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+  },
+  ProtocolHandlerI: {
+    protocolHandler: M.interface('ProtocolHandler', {
+      onCreate: M.callWhen(M.remotable(), Shape2.ProtocolHandler).returns(
+        Shape2.Vow$(M.undefined()),
+      ),
+      generatePortID: M.callWhen(
+        Shape2.Endpoint,
+        Shape2.ProtocolHandler,
+      ).returns(Shape2.Vow$(M.string())),
+      onBind: M.callWhen(
+        Shape2.Port,
+        Shape2.Endpoint,
+        Shape2.ProtocolHandler,
+      ).returns(Shape2.Vow$(M.undefined())),
+      onListen: M.callWhen(
+        Shape2.Port,
+        Shape2.Endpoint,
+        Shape2.ListenHandler,
+        Shape2.ProtocolHandler,
+      ).returns(Shape2.Vow$(M.undefined())),
+      onListenRemove: M.callWhen(
+        Shape2.Port,
+        Shape2.Endpoint,
+        Shape2.ListenHandler,
+        Shape2.ProtocolHandler,
+      ).returns(Shape2.Vow$(M.undefined())),
+      onInstantiate: M.callWhen(
+        Shape2.Port,
+        Shape2.Endpoint,
+        Shape2.Endpoint,
+        Shape2.ProtocolHandler,
+      ).returns(Shape2.Vow$(Shape2.Endpoint)),
+      onConnect: M.callWhen(
+        Shape2.Port,
+        Shape2.Endpoint,
+        Shape2.Endpoint,
+        Shape2.ConnectionHandler,
+        Shape2.ProtocolHandler,
+      ).returns(Shape2.Vow$(Shape2.AttemptDescription)),
+      onRevoke: M.callWhen(
+        Shape2.Port,
+        Shape2.Endpoint,
+        Shape2.ProtocolHandler,
+      ).returns(Shape2.Vow$(M.undefined())),
+    }),
+    protocolHandlerAcceptWatcher: M.interface('ProtocolHandlerAcceptWatcher', {
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+    }),
+    protocolHandlerInstantiateWatcher: M.interface(
+      'ProtocolHandlerInstantiateWatcher',
+      {
+        onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+      },
+    ),
+    protocolHandlerConnectWatcher: M.interface(
+      'ProtocolHandlerConnectWatcher',
+      {
+        onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+      },
+    ),
+    rethrowUnlessMissingWatcher: M.interface('RethrowUnlessMissingWatcher', {
+      onRejected: M.call(M.any()).rest(M.any()).returns(M.any()),
+    }),
+  },
+
+  ProtocolImplI: M.interface('ProtocolImpl', {
+    bindPort: M.callWhen(Shape2.Endpoint).returns(Shape2.Vow$(Shape2.Port)),
+    inbound: M.callWhen(Shape2.Endpoint, Shape2.Endpoint).returns(
+      Shape2.Vow$(Shape2.InboundAttempt),
+    ),
+    outbound: M.callWhen(
+      Shape2.Port,
+      Shape2.Endpoint,
+      Shape2.ConnectionHandler,
+    ).returns(Shape2.Vow$(Shape2.Connection)),
+  }),
+});