@agoric/network 0.1.1-orchestration-dev-096c4e8.0 → 0.1.1-other-dev-3eb1a1d.0

package/src/router.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @import {Endpoint, Port, Protocol, ProtocolHandler} from './types.js';
+ * @import {PromiseVow, Remote, VowTools} from '@agoric/vow';
+ */
 /**
  * @template T
  * @typedef {object} Router A delimited string router implementation
@@ -13,7 +17,7 @@ export const RouterI: import("@endo/patterns").InterfaceGuard<{
     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<{
+export function prepareRouter<T>(zone: import("@agoric/base-zone").Zone): () => import("@endo/exo").Guarded<{
     /** @param {Endpoint} addr */
     getRoutes(addr: Endpoint): [string, T][];
     /**
@@ -27,35 +31,28 @@ 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;
-    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>>;
+export function prepareRouterProtocol(zone: import("@agoric/base-zone").Zone, powers: import("./network.js").Powers, E?: ((<T>(x: T) => import("../../../node_modules/@endo/eventual-send/src/E.js").ECallableOrMethods<import("@endo/eventual-send").RemoteFunctions<T>>) & {
+    readonly get: <T>(x: T) => import("../../../node_modules/@endo/eventual-send/src/E.js").EGetters<import("@endo/eventual-send").LocalRecord<T>>;
     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>>;
+        <T>(value: T): Promise<Awaited<T>>;
+        <T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
     };
-    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): () => import("@endo/exo/src/exo-makers.js").Guarded<{
+    readonly sendOnly: <T>(x: T) => import("../../../node_modules/@endo/eventual-send/src/E.js").ESendOnlyCallableOrMethods<import("@endo/eventual-send").RemoteFunctions<T>>;
+    readonly when: <T, U = T>(x: T | PromiseLike<T>, onfulfilled?: ((value: T) => 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 {ProtocolHandler} protocolHandler
+     * @param {Remote<ProtocolHandler>} protocolHandler
      */
-    registerProtocolHandler(paths: string[], protocolHandler: ProtocolHandler): void;
+    registerProtocolHandler(paths: string[], protocolHandler: Remote<ProtocolHandler>): void;
     /**
      * @param {string} prefix
-     * @param {ProtocolHandler} protocolHandler
+     * @param {Remote<ProtocolHandler>} protocolHandler
      */
-    unregisterProtocolHandler(prefix: string, protocolHandler: ProtocolHandler): void;
+    unregisterProtocolHandler(prefix: string, protocolHandler: Remote<ProtocolHandler>): void;
     /** @param {Endpoint} localAddr */
-    bind(localAddr: Endpoint): Promise<Port | import("@agoric/vow").Vow<Port>>;
+    bindPort(localAddr: Endpoint): Promise<Port | import("@agoric/vow").Vow<Port>>;
 }>;
 /**
  * A delimited string router implementation
@@ -78,8 +75,13 @@ export type Router<T> = {
     unregister: (prefix: string, route: T) => void;
 };
 export type RouterProtocol = {
-    bind: (prefix: string) => PromiseVow<Port>;
+    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 { ProtocolHandler } from './types.js';
+import type { Remote } from '@agoric/vow';
+import type { Port } from './types.js';
+import type { PromiseVow } from '@agoric/vow';
 //# sourceMappingURL=router.d.ts.map

package/src/router.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"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,OAAO,cAAc,EAAE,MAAM;;;;;;;;gEAjGR,CAAC,+EAItB,CAAC;;IAiIN;;;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;;8BA3FZ,YAAY;qCAAZ,YAAY;4BACzB,aAAa;0BADA,YAAY;gCACzB,aAAa"}

package/src/router.js

@@ -1,15 +1,18 @@
 // @ts-check
+
+/// <reference types="@agoric/store/exported.js" />
+/// <reference path="./types.js" />
+
+import { Fail } from '@endo/errors';
 import { E as defaultE } from '@endo/far';
 import { M } from '@endo/patterns';
-import { Fail } from '@agoric/assert';
-import {
-  ENDPOINT_SEPARATOR,
-  Shape,
-  prepareNetworkProtocol,
-} from './network.js';
-
-import '@agoric/store/exported.js';
-/// <reference path="./types.js" />
+import { ENDPOINT_SEPARATOR, prepareNetworkProtocol } from './network.js';
+import { Shape } from './shapes.js';
+
+/**
+ * @import {Endpoint, Port, Protocol, ProtocolHandler} from './types.js';
+ * @import {PromiseVow, Remote, VowTools} from '@agoric/vow';
+ */
 
 /**
  * @template T
@@ -59,7 +62,7 @@ export const prepareRouter = zone => {
             ret.push([prefix, this.state.prefixToRoute.get(prefix)]);
           }
           // Trim off the last value (after the slash).
-          const defaultPrefix = prefix.substr(
+          const defaultPrefix = prefix.slice(
             0,
             prefix.lastIndexOf(ENDPOINT_SEPARATOR) + 1,
           );
@@ -96,7 +99,7 @@ export const prepareRouter = zone => {
 
 /**
  * @typedef {object} RouterProtocol
- * @property {(prefix: string) => PromiseVow<Port>} bind
+ * @property {(prefix: string) => PromiseVow<Port>} bindPort
  * @property {(paths: string[], protocolHandler: ProtocolHandler) => void} registerProtocolHandler
  * @property {(prefix: string, protocolHandler: ProtocolHandler) => void} unregisterProtocolHandler
  */
@@ -105,7 +108,7 @@ export const prepareRouter = zone => {
  * Create a router that behaves like a Protocol.
  *
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {import('./network.js').Powers} powers
  * @param {typeof defaultE} [E] Eventual sender
  */
 export const prepareRouterProtocol = (zone, powers, E = defaultE) => {
@@ -122,7 +125,7 @@ export const prepareRouterProtocol = (zone, powers, E = defaultE) => {
         M.remotable(),
       ).returns(),
       unregisterProtocolHandler: M.call(M.string(), M.remotable()).returns(),
-      bind: M.callWhen(Shape.Endpoint).returns(Shape.Vow$(Shape.Port)),
+      bindPort: M.callWhen(Shape.Endpoint).returns(Shape.Vow$(Shape.Port)),
     }),
     () => {
       /** @type {Router<Protocol>} */
@@ -131,7 +134,7 @@ export const prepareRouterProtocol = (zone, powers, E = defaultE) => {
       /** @type {MapStore<string, Protocol>} */
       const protocols = detached.mapStore('prefix');
 
-      /** @type {MapStore<string, ProtocolHandler>} */
+      /** @type {MapStore<string, Remote<ProtocolHandler>>} */
       const protocolHandlers = detached.mapStore('prefix');
 
       return {
@@ -143,7 +146,7 @@ export const prepareRouterProtocol = (zone, powers, E = defaultE) => {
     {
       /**
        * @param {string[]} paths
-       * @param {ProtocolHandler} protocolHandler
+       * @param {Remote<ProtocolHandler>} protocolHandler
        */
       registerProtocolHandler(paths, protocolHandler) {
         const protocol = makeNetworkProtocol(protocolHandler);
@@ -157,13 +160,13 @@ export const prepareRouterProtocol = (zone, powers, E = defaultE) => {
       // Needs to account for multiple paths.
       /**
        * @param {string} prefix
-       * @param {ProtocolHandler} protocolHandler
+       * @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 hanlders to their corresponding protocol
+        // TODO: unmap protocol handlers to their corresponding protocol
         // e.g. using a map
         // before unregistering
         // @ts-expect-error note FIXME above
@@ -172,10 +175,10 @@ export const prepareRouterProtocol = (zone, powers, E = defaultE) => {
         this.state.protocolHandlers.delete(prefix);
       },
       /** @param {Endpoint} localAddr */
-      async bind(localAddr) {
+      async bindPort(localAddr) {
         const [route] = this.state.router.getRoutes(localAddr);
         route !== undefined || Fail`No registered router for ${localAddr}`;
-        return E(route[1]).bind(localAddr);
+        return E(route[1]).bindPort(localAddr);
       },
     },
   );

package/src/shapes.d.ts

@@ -0,0 +1,117 @@
+export namespace Shape {
+    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;
+        }>;
+    }
+    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 };
+    }
+    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 };
+    }
+    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 };
+    }
+    let ProtocolImplI: import("@endo/patterns").InterfaceGuard<{
+        bindPort: import("@endo/patterns").MethodGuard;
+        inbound: import("@endo/patterns").MethodGuard;
+        outbound: import("@endo/patterns").MethodGuard;
+    }>;
+    function Vow$(shape: any): import("@endo/patterns").Matcher;
+    let AttemptDescription: import("@endo/patterns").Matcher;
+    let Opts: import("@endo/patterns").Matcher;
+    let Data: import("@endo/patterns").Matcher;
+    let Bytes: import("@endo/patterns").Matcher;
+    let Endpoint: import("@endo/patterns").Matcher;
+    let Vow: import("@endo/patterns").Matcher;
+    let ConnectionHandler: import("@endo/patterns").Matcher;
+    let Connection: import("@endo/patterns").Matcher;
+    let InboundAttempt: import("@endo/patterns").Matcher;
+    let Listener: import("@endo/patterns").Matcher;
+    let ListenHandler: import("@endo/patterns").Matcher;
+    let Port: import("@endo/patterns").Matcher;
+    let ProtocolHandler: import("@endo/patterns").Matcher;
+    let ProtocolImpl: import("@endo/patterns").Matcher;
+}
+//# 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA6BQ,4DAAgC"}

package/src/shapes.js

@@ -0,0 +1,191 @@
+// @ts-check
+import { M } from '@endo/patterns';
+
+const Shape1 = /** @type {const} */ ({
+  /**
+   * Data is string | Buffer | ArrayBuffer
+   * but only string is passable
+   */
+  Data: M.string(),
+  Bytes: M.string(),
+  Endpoint: M.string(),
+  Vow: M.tagged(
+    'Vow',
+    harden({
+      vowV0: M.remotable('VowV0'),
+    }),
+  ),
+  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,
+  Vow$: shape => M.or(shape, Shape1.Vow),
+  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(M.any()),
+    }),
+    protocolHandlerInstantiateWatcher: M.interface(
+      'ProtocolHandlerInstantiateWatcher',
+      {
+        onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
+      },
+    ),
+    protocolHandlerConnectWatcher: M.interface(
+      'ProtocolHandlerConnectWatcher',
+      {
+        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()),
+    }),
+  },
+
+  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)),
+  }),
+});