@agoric/network 0.2.0-upgrade-16-dev-12b78e3.0 → 0.2.0-upgrade-17-dev-a61cdab.0

package/CHANGELOG.md

@@ -3,15 +3,7 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [0.2.0-u16.1](https://github.com/Agoric/agoric-sdk/compare/@agoric/network@0.2.0-u16.0...@agoric/network@0.2.0-u16.1) (2024-07-10)
-
-**Note:** Version bump only for package @agoric/network
-
-
-
-
-
-## 0.2.0-u16.0 (2024-07-02)
+## 0.2.0-u17.0 (2024-09-17)
 
 
 ### ⚠ BREAKING CHANGES
@@ -32,6 +24,7 @@ See [Conventional Commits](https://conventionalcommits.org) for commit guideline
 * **network:** Connection should have negotiated remoteAddress and localAddress ([2184ea3](https://github.com/Agoric/agoric-sdk/commit/2184ea3d655c1334653e27d163a09ceb5f61fd50)), closes [#9064](https://github.com/Agoric/agoric-sdk/issues/9064)
 * **network:** create and use `coerceToData` ([39beecb](https://github.com/Agoric/agoric-sdk/commit/39beecba84ef6dfafca902a28a651dbba77cdb1e))
 * **network:** improve naming and data coercion ([8bcd9e2](https://github.com/Agoric/agoric-sdk/commit/8bcd9e2100f4973fd788a6edf42c144d916c173d))
-* **network:** use new `ERef` and `FarRef` ([55adb2b](https://github.com/Agoric/agoric-sdk/commit/55adb2b1f5b644ef5b7cf40ea8b7d87488218229))
+* **network:** introduce `Finalizer` to close network ([54b9b00](https://github.com/Agoric/agoric-sdk/commit/54b9b009fff3fd3ab54f731adee97195acaa238f))
+* **network:** use new `ERef` and `FarRef` ([3027adf](https://github.com/Agoric/agoric-sdk/commit/3027adf8613154dec167c5fccf5f207f6d2af701))
 * **network:** use vow types, correct revealed problems ([d1c1240](https://github.com/Agoric/agoric-sdk/commit/d1c1240bcf534a316533d4c203f45f01fdfc825d))
 * **vats:** `vtransfer` code cleanup ([8ac8197](https://github.com/Agoric/agoric-sdk/commit/8ac819709ef9ced0badee25e6715a5847b1e3f4c))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/network",
-  "version": "0.2.0-upgrade-16-dev-12b78e3.0+12b78e3",
+  "version": "0.2.0-upgrade-17-dev-a61cdab.0+a61cdab",
   "description": "Agoric's network protocol API",
   "type": "module",
   "main": "./src/index.js",
@@ -21,22 +21,22 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-upgrade-16-dev-12b78e3.0+12b78e3",
-    "@agoric/internal": "0.4.0-upgrade-16-dev-12b78e3.0+12b78e3",
-    "@agoric/store": "0.9.3-upgrade-16-dev-12b78e3.0+12b78e3",
-    "@agoric/vat-data": "0.5.3-upgrade-16-dev-12b78e3.0+12b78e3",
-    "@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"
+    "@agoric/internal": "0.4.0-upgrade-17-dev-a61cdab.0+a61cdab",
+    "@agoric/store": "0.9.3-upgrade-17-dev-a61cdab.0+a61cdab",
+    "@agoric/vat-data": "0.5.3-upgrade-17-dev-a61cdab.0+a61cdab",
+    "@endo/base64": "^1.0.7",
+    "@endo/errors": "^1.2.5",
+    "@endo/far": "^1.1.5",
+    "@endo/pass-style": "^1.4.3",
+    "@endo/patterns": "^1.4.3",
+    "@endo/promise-kit": "^1.1.5"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-upgrade-16-dev-12b78e3.0+12b78e3",
-    "@agoric/swingset-vat": "0.33.0-upgrade-16-dev-12b78e3.0+12b78e3",
-    "@agoric/vow": "0.2.0-upgrade-16-dev-12b78e3.0+12b78e3",
-    "@agoric/zone": "0.3.0-upgrade-16-dev-12b78e3.0+12b78e3",
-    "@endo/bundle-source": "^3.2.3",
+    "@agoric/swingset-liveslots": "0.10.3-upgrade-17-dev-a61cdab.0+a61cdab",
+    "@agoric/swingset-vat": "0.33.0-upgrade-17-dev-a61cdab.0+a61cdab",
+    "@agoric/vow": "0.2.0-upgrade-17-dev-a61cdab.0+a61cdab",
+    "@agoric/zone": "0.3.0-upgrade-17-dev-a61cdab.0+a61cdab",
+    "@endo/bundle-source": "^3.4.0",
     "ava": "^5.3.0",
     "c8": "^9.1.0"
   },
@@ -66,7 +66,7 @@
     "workerThreads": false
   },
   "typeCoverage": {
-    "atLeast": 89.7
+    "atLeast": 91.15
   },
-  "gitHead": "12b78e307e22d0dc0c95f40099300e16655781c4"
+  "gitHead": "a61cdabb23bd2c846e003dee7326018a7462a929"
 }

package/src/bytes.d.ts.map

@@ -1 +1 @@
-{"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,GACR,KAAK,CAOjB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,GACH,MAAM,CAIlB;AAED;;;;;GAKG;AACH,+CAHW,UAAU,GACR,MAAM,CAKlB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,GACJ,KAAK,CAIjB;yBA7Fa,KAAK,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC;2BAHpC,YAAY;sCAAZ,YAAY"}
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["bytes.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH,2EAA2E;AAE3E;;;;;;;GAOG;AACH,6CAHW,OAAO,GACL,UAAU,CAgBtB;AAuBD;;;;;;GAMG;AACH,oCAHW,UAAU,GACR,KAAK,CAOjB;AAED;;;;;GAKG;AACH,qCAHW,KAAK,GACH,MAAM,CAIlB;AAED;;;;;GAKG;AACH,+CAHW,UAAU,GACR,MAAM,CAKlB;AAED;;;;;GAKG;AACH,sCAHW,MAAM,GACJ,KAAK,CAIjB;yBA1Fa,KAAK,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC;2BAHpC,YAAY;sCAAZ,YAAY"}

package/src/bytes.js

@@ -1,5 +1,5 @@
 // @ts-check
-import { details, Fail } from '@agoric/assert';
+import { X, Fail } from '@endo/errors';
 import { encodeBase64, decodeBase64 } from '@endo/base64';
 import { isObject } from '@endo/pass-style';
 
@@ -23,14 +23,11 @@ export function coerceToByteSource(specimen) {
   }
 
   isObject(specimen) ||
-    assert.fail(details`non-object ${specimen} is not a ByteSource`, TypeError);
+    assert.fail(X`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,
-    );
+    assert.fail(X`non-iterable ${specimen} is not a ByteSource`, TypeError);
 
   // Good enough... it's iterable and can be converted later.
   return /** @type {ByteSource} */ (specimen);

package/src/network.d.ts

@@ -9,18 +9,9 @@ export function getPrefixes(addr: string): string[];
  * Create a protocol handler that just connects to itself.
  *
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {VowTools} powers
  */
-export function prepareLoopbackProtocolHandler(zone: import("@agoric/base-zone").Zone, { watch, allVows }: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
-    isRetryableReason?: import("@agoric/vow").IsRetryableReason | undefined;
-} | undefined) => {
-    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>() => import("@agoric/vow").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>) => import("@agoric/vow").Vow<Awaited<T>>;
-    asPromise: import("@agoric/vow").AsPromiseFunction;
-}>): (instancePrefix?: string | undefined) => import("@endo/exo").Guarded<{
+export function prepareLoopbackProtocolHandler(zone: import("@agoric/base-zone").Zone, { watch, allVows }: VowTools): (instancePrefix?: string | undefined) => import("@endo/exo").Guarded<{
     onCreate(_impl: any, _protocolHandler: any): Promise<void>;
     generatePortID(_localAddr: any, _protocolHandler: any): Promise<string>;
     onBind(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
@@ -34,34 +25,23 @@ export function prepareLoopbackProtocolHandler(zone: import("@agoric/base-zone")
     onInstantiate(_port: any, _localAddr: any, _remote: any, _protocol: any): Promise<string>;
     onListen(port: any, localAddr: any, listenHandler: any, _protocolHandler: any): Promise<void>;
     /**
-     * @param {import('@agoric/vow').Remote<Port>} port
+     * @param {Remote<Port>} port
      * @param {Endpoint} localAddr
-     * @param {import('@agoric/vow').Remote<ListenHandler>} listenHandler
+     * @param {Remote<ListenHandler>} listenHandler
      * @param {*} _protocolHandler
      */
-    onListenRemove(port: import("@agoric/vow").Remote<Port>, localAddr: Endpoint, listenHandler: import("@agoric/vow").Remote<ListenHandler>, _protocolHandler: any): Promise<void>;
+    onListenRemove(port: Remote<Port>, localAddr: Endpoint, listenHandler: Remote<ListenHandler>, _protocolHandler: any): Promise<void>;
     onRevoke(_port: any, _localAddr: any, _protocolHandler: any): Promise<void>;
 }>;
-/**
- * @import {AttemptDescription, Bytes, Closable, CloseReason, Connection, ConnectionHandler, Endpoint, ListenHandler, Port, Protocol, ProtocolHandler, ProtocolImpl} from './types.js';
- */
 /**
  * Compatibility note: this must match what our peers use, so don't change it
  * casually.
  */
 export const ENDPOINT_SEPARATOR: "/";
+export const CLOSE_REASON_FINALIZER: "closed-by-finalizer";
 export function rethrowUnlessMissing(err: unknown): undefined;
-export function crossoverConnection(zone: import("@agoric/zone").Zone, handler0: import("@agoric/vow").Remote<Required<ConnectionHandler>>, addr0: Endpoint, handler1: import("@agoric/vow").Remote<Required<ConnectionHandler>>, addr1: Endpoint, 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?: import("@agoric/vow").IsRetryableReason | undefined;
-} | undefined) => {
-    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>() => import("@agoric/vow").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>) => import("@agoric/vow").Vow<Awaited<T>>;
-    asPromise: import("@agoric/vow").AsPromiseFunction;
-}>): (protocolHandler: import("@agoric/vow").Remote<ProtocolHandler>) => Protocol;
+export function crossoverConnection(zone: import("@agoric/zone").Zone, handler0: Remote<Required<ConnectionHandler>>, addr0: Endpoint, handler1: Remote<Required<ConnectionHandler>>, addr1: Endpoint, makeConnection: (opts: ConnectionOpts) => Connection, finalizer: Finalizer, current?: globalThis.WeakSetStore<Closable> | undefined): Connection[];
+export function prepareNetworkProtocol(zone: import("@agoric/base-zone").Zone, powers: Powers): (protocolHandler: Remote<ProtocolHandler>) => Protocol;
 export function prepareEchoConnectionKit(zone: import("@agoric/base-zone").Zone): () => import("@endo/exo").GuardedKit<{
     handler: {
         /**
@@ -72,10 +52,10 @@ export function prepareEchoConnectionKit(zone: import("@agoric/base-zone").Zone)
         onReceive(_connection: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
         /**
          * @param {Connection} _connection
-         * @param {CloseReason} [_reason]
+         * @param {CloseReason} [reason]
          * @param {ConnectionHandler} [_connectionHandler]
          */
-        onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+        onClose(_connection: Connection, reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
     };
     listener: {
         onAccept(_port: any, _localAddr: any, _remoteAddr: any, _listenHandler: any): Promise<import("@endo/exo").Guarded<{
@@ -87,24 +67,15 @@ export function prepareEchoConnectionKit(zone: import("@agoric/base-zone").Zone)
             onReceive(_connection: Connection, bytes: Bytes, _connectionHandler: ConnectionHandler): Promise<string>;
             /**
              * @param {Connection} _connection
-             * @param {CloseReason} [_reason]
+             * @param {CloseReason} [reason]
              * @param {ConnectionHandler} [_connectionHandler]
              */
-            onClose(_connection: Connection, _reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
+            onClose(_connection: Connection, reason?: CloseReason, _connectionHandler?: ConnectionHandler | undefined): Promise<void>;
         }>>;
         onListen(port: any, _listenHandler: any): Promise<void>;
     };
 }>;
-export function preparePortAllocator(zone: import("@agoric/base-zone").Zone, { watch }: ReturnType<(zone: import("@agoric/base-zone").Zone, powers?: {
-    isRetryableReason?: import("@agoric/vow").IsRetryableReason | undefined;
-} | undefined) => {
-    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>() => import("@agoric/vow").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>) => import("@agoric/vow").Vow<Awaited<T>>;
-    asPromise: import("@agoric/vow").AsPromiseFunction;
-}>): (args_0: {
+export function preparePortAllocator(zone: import("@agoric/base-zone").Zone, { watch }: Powers): (args_0: {
     protocol: Protocol;
 }) => import("@endo/exo").Guarded<{
     allocateCustomIBCPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<Port>>;
@@ -112,19 +83,26 @@ export function preparePortAllocator(zone: import("@agoric/base-zone").Zone, { w
     allocateICQControllerPort(): Promise<import("@agoric/vow").Vow<Port>>;
     allocateCustomLocalPort(specifiedName?: string): Promise<import("@agoric/vow").Vow<Port>>;
 }>;
+export function prepareNetworkPowers(zone: import("@agoric/base-zone").Zone, vowTools: VowTools): Powers;
 export type MakeEchoConnectionKit = ReturnType<typeof prepareEchoConnectionKit>;
+export type Powers = VowTools & {
+    finalizer: Finalizer;
+};
 export type ConnectionOpts = {
     addrs: Endpoint[];
-    handlers: import("@agoric/vow").Remote<Required<ConnectionHandler>>[];
+    handlers: Remote<Required<ConnectionHandler>>[];
     conns: MapStore<number, Connection>;
     current: WeakSetStore<Closable>;
     l: 0 | 1;
     r: 0 | 1;
 };
 export type PortAllocator = ReturnType<ReturnType<typeof preparePortAllocator>>;
+export type Finalizer = ReturnType<typeof prepareFinalizer>;
+import type { VowTools } from '@agoric/vow';
 import type { Endpoint } from './types.js';
 import type { AttemptDescription } from './types.js';
 import type { Port } from './types.js';
+import type { Remote } from '@agoric/vow';
 import type { ListenHandler } from './types.js';
 import type { ConnectionHandler } from './types.js';
 import type { Connection } from './types.js';
@@ -133,4 +111,38 @@ import type { ProtocolHandler } from './types.js';
 import type { Protocol } from './types.js';
 import type { Bytes } from './types.js';
 import type { CloseReason } from './types.js';
+/** @typedef {ReturnType<ReturnType<typeof preparePortAllocator>>} PortAllocator */
+/**
+ * Return a package-specific singleton that pins objects until they are
+ * explicitly unpinned or finalized.  It needs to pin objects only because they
+ * are resources that need to be released.
+ *
+ * The reason this functionality wasn't just baked into the other network exos
+ * is to maintain upgrade-compatible with minimal additional changes.
+ *
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {VowTools} vowTools
+ */
+declare function prepareFinalizer(zone: import("@agoric/base-zone").Zone, { watch }: VowTools): import("@endo/exo").Guarded<{
+    has(obj: any): boolean;
+    /**
+     * Add a connection and handler for an `onClose` method to be called upon
+     * finalization.
+     * @param {Remote<Connection>} conn
+     * @param {Remote<Required<ConnectionHandler>>} handler
+     */
+    initConnection(conn: Remote<Connection>, handler: Remote<Required<ConnectionHandler>>): void;
+    /**
+     * Add an object with a `close` method to be called (such as an
+     * `inboundAttempt`) upon finalization.
+     * @param {Remote<{ close(): PromiseVow<any> }>} closer
+     */
+    initCloser(closer: Remote<{
+        close(): PromiseVow<any>;
+    }>): void;
+    finalize(obj: any): import("@agoric/vow").Vow<any> | undefined;
+    unpin(obj: any): void;
+}>;
+import type { PromiseVow } from '@agoric/vow';
+export {};
 //# sourceMappingURL=network.d.ts.map

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;AAutCD,mFAAmF;AAEnF;;;;;GAKG;AACH,qDAHW,OAAO,mBAAmB,EAAE,IAAI,sBAChC,UAAU,CAAC;;;;;;;oCAlrCN,GAAG;;CAkrCwC,CAAC;;;;IAmCpD;;;;;OAKG;qBAJQ,GAAC,aACD,QAAQ,cACR,QAAQ,GACN,OAAO,aAAa,EAAE,UAAU,CAAC,kBAAkB,CAAC;;;IAiEjE;;;;;OAKG;yBAJQ,OAAO,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,aAClC,QAAQ,iBACR,OAAO,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,oBAC3C,GAAC;;GA+CnB;AA/5CD;;GAEG;AAEH;;;GAGG;AACH,qCAAsC;AAG/B,0CADK,OAAO,aAWlB;AAyJM,0CARI,OAAO,cAAc,EAAE,IAAI,YAC3B,OAAO,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC,SACzD,QAAQ,YACR,OAAO,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC,SACzD,QAAQ,kBACR,CAAC,IAAI,EAAE,cAAc,KAAK,UAAU,yEAgD9C;AA+6BM,6CAHI,OAAO,mBAAmB,EAAE,IAAI,UAChC,UAAU,CAAC;;;;;;;oCAtjCN,GAAG;;CAsjCwC,CAAC,qBAM/C,OAAO,aAAa,EAAE,MAAM,CAAC,eAAe,CAAC,KAC3C,QAAQ,CA2BtB;AAOM,+CAFI,OAAO,mBAAmB,EAAE,IAAI;;QAsCnC;;;;WAIG;+BAHQ,UAAU,SACV,KAAK,sBACL,iBAAiB;QAU5B;;;;WAIG;6BAHQ,UAAU,YACV,WAAW;;;;YAftB;;;;eAIG;mCAHQ,UAAU,SACV,KAAK,sBACL,iBAAiB;YAU5B;;;;eAIG;iCAHQ,UAAU,YACV,WAAW;;;;GAyB7B;AAyKM,2CAHI,OAAO,mBAAmB,EAAE,IAAI,aAChC,UAAU,CAAC;;;;;;;oCAl1CN,GAAG;;CAk1CwC,CAAC;cAkB7C,QAAQ;;;;;;GAkDpB;oCA1OW,UAAU,CAAC,OAAO,wBAAwB,CAAC;;WArsC3C,QAAQ,EAAE;cACV,OAAO,aAAa,EAAE,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAC,EAAE;WAC3D,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;aAC5B,YAAY,CAAC,QAAQ,CAAC;OACtB,CAAC,GAAC,CAAC;OACH,CAAC,GAAC,CAAC;;4BA26CH,UAAU,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;8BAx+CyG,YAAY;wCAAZ,YAAY;0BAAZ,YAAY;mCAAZ,YAAY;uCAAZ,YAAY;gCAAZ,YAAY;8BAAZ,YAAY;qCAAZ,YAAY;8BAAZ,YAAY;2BAAZ,YAAY;iCAAZ,YAAY"}
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["network.js"],"names":[],"mappings":"AA2CA;;;;GAIG;AACH,kCAFW,MAAM,YAahB;AAutCD,mFAAmF;AAEnF;;;;;GAKG;AACH,qDAHW,OAAO,mBAAmB,EAAE,IAAI,sBAChC,QAAQ;;;;IAmCX;;;;;OAKG;qBAJQ,GAAC,aACD,QAAQ,cACR,QAAQ,GACN,OAAO,aAAa,EAAE,UAAU,CAAC,kBAAkB,CAAC;;;IA+DjE;;;;;OAKG;yBAJQ,OAAO,IAAI,CAAC,aACZ,QAAQ,iBACR,OAAO,aAAa,CAAC,oBACrB,GAAC;;GA+CnB;AA55CD;;;GAGG;AACH,qCAAsC;AAGtC,2DAA4D;AAGrD,0CADK,OAAO,aAWlB;AA4JM,0CATI,OAAO,cAAc,EAAE,IAAI,YAC3B,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC,SACnC,QAAQ,YACR,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC,SACnC,QAAQ,kBACR,CAAC,IAAI,EAAE,cAAc,KAAK,UAAU,aACpC,SAAS,yEAqDnB;AAu6BM,6CAHI,OAAO,mBAAmB,EAAE,IAAI,UAChC,MAAM,qBAMJ,OAAO,eAAe,CAAC,KACrB,QAAQ,CA2BtB;AAOM,+CAFI,OAAO,mBAAmB,EAAE,IAAI;;QAsCnC;;;;WAIG;+BAHQ,UAAU,SACV,KAAK,sBACL,iBAAiB;QAU5B;;;;WAIG;6BAHQ,UAAU,WACV,WAAW;;;;YAftB;;;;eAIG;mCAHQ,UAAU,SACV,KAAK,sBACL,iBAAiB;YAU5B;;;;eAIG;iCAHQ,UAAU,WACV,WAAW;;;;GAyB7B;AAuKM,2CAHI,OAAO,mBAAmB,EAAE,IAAI,aAChC,MAAM;cAkBF,QAAQ;;;;;;GAkDpB;AAwEI,2CAJI,OAAO,mBAAmB,EAAE,IAAI,YAChC,QAAQ,GACN,MAAM,CAKlB;oCAnTa,UAAU,CAAC,OAAO,wBAAwB,CAAC;qBAlwC3C,QAAQ,GAAG;IAAE,SAAS,EAAE,SAAS,CAAA;CAAE;;WA6DnC,QAAQ,EAAE;cACV,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC,EAAE;WACrC,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;aAC5B,YAAY,CAAC,QAAQ,CAAC;OACtB,CAAC,GAAC,CAAC;OACH,CAAC,GAAC,CAAC;;4BAy6CH,UAAU,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC;wBA4EnD,UAAU,CAAC,OAAO,gBAAgB,CAAC;8BA1jDF,aAAa;8BAD8G,YAAY;wCAAZ,YAAY;0BAAZ,YAAY;4BACvI,aAAa;mCAD8G,YAAY;uCAAZ,YAAY;gCAAZ,YAAY;8BAAZ,YAAY;qCAAZ,YAAY;8BAAZ,YAAY;2BAAZ,YAAY;iCAAZ,YAAY;AA++CtL,mFAAmF;AAEnF;;;;;;;;;;GAUG;AACH,wCAHW,OAAO,mBAAmB,EAAE,IAAI,aAChC,QAAQ;;IAcf;;;;;OAKG;yBAFQ,OAAO,UAAU,CAAC,WAClB,OAAO,QAAQ,CAAC,iBAAiB,CAAC,CAAC;IAK9C;;;;OAIG;uBADQ,OAAO;QAAE,KAAK,IAAI,WAAW,GAAG,CAAC,CAAA;KAAE,CAAC;;;GA0BlD;gCA7iD8C,aAAa"}

package/src/network.js

@@ -2,23 +2,32 @@
 
 /// <reference types="@agoric/store/exported.js" />
 
+import { Fail } from '@endo/errors';
 import { E } from '@endo/far';
 import { M } from '@endo/patterns';
-import { Fail } from '@agoric/assert';
 import { toBytes } from './bytes.js';
 import { Shape } from './shapes.js';
 
 /// <reference path="./types.js" />
 /**
- * @import {AttemptDescription, Bytes, Closable, CloseReason, Connection, ConnectionHandler, Endpoint, ListenHandler, Port, Protocol, ProtocolHandler, ProtocolImpl} from './types.js';
+ * @import {AttemptDescription, Bytes, CloseReason, Closable, Connection, ConnectionHandler, Endpoint, ListenHandler, Port, Protocol, ProtocolHandler, ProtocolImpl} from './types.js';
+ * @import {PromiseVow, Remote, VowTools} from '@agoric/vow';
  */
 
+/** @typedef {VowTools & { finalizer: Finalizer }} Powers */
+
+const sink = () => {};
+harden(sink);
+
 /**
  * Compatibility note: this must match what our peers use, so don't change it
  * casually.
  */
 export const ENDPOINT_SEPARATOR = '/';
 
+// Mark the finalizer close reason.
+export const CLOSE_REASON_FINALIZER = 'closed-by-finalizer';
+
 /** @param {unknown} err */
 export const rethrowUnlessMissing = err => {
   // Ugly hack rather than being able to determine if the function
@@ -60,14 +69,14 @@ function throwIfInvalidPortName(specifiedName) {
   // Valid symbols: ., ,, _, +, -, #, [, ], <, >
   const portNameRegex = new RegExp('^[a-zA-Z0-9.,_+\\-#<>\\[\\]]{2,128}$');
   if (!portNameRegex.test(specifiedName)) {
-    throw new Error(`Invalid IBC port name: ${specifiedName}`);
+    throw Error(`Invalid IBC port name: ${specifiedName}`);
   }
 }
 
 /**
  * @typedef {object} ConnectionOpts
  * @property {Endpoint[]} addrs
- * @property {import('@agoric/vow').Remote<Required<ConnectionHandler>>[]} handlers
+ * @property {Remote<Required<ConnectionHandler>>[]} handlers
  * @property {MapStore<number, Connection>} conns
  * @property {WeakSetStore<Closable>} current
  * @property {0|1} l
@@ -76,9 +85,9 @@ function throwIfInvalidPortName(specifiedName) {
 
 /**
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {Powers} powers
  */
-const prepareHalfConnection = (zone, { watch }) => {
+const prepareHalfConnection = (zone, { watch, allVows, finalizer }) => {
   const makeHalfConnectionKit = zone.exoClassKit(
     'Connection',
     Shape.ConnectionI,
@@ -123,18 +132,20 @@ const prepareHalfConnection = (zone, { watch }) => {
           return watch(innerVow, this.facets.rethrowUnlessMissingWatcher);
         },
         async close() {
-          const { closed, current, conns, l, handlers } = this.state;
+          const { closed, current, conns, l, r } = this.state;
           if (closed) {
             throw Error(closed);
           }
           this.state.closed = 'Connection closed';
-          current.delete(conns.get(l));
+
+          // Tear down both sides.
+          const lconn = conns.get(l);
+          const rconn = conns.get(r);
+          current.delete(lconn);
+          current.delete(rconn);
+
           const innerVow = watch(
-            E(this.state.handlers[l]).onClose(
-              conns.get(l),
-              undefined,
-              handlers[l],
-            ),
+            allVows([finalizer.finalize(lconn), finalizer.finalize(rconn)]),
             this.facets.sinkWatcher,
           );
 
@@ -176,11 +187,12 @@ const prepareHalfConnection = (zone, { watch }) => {
 
 /**
  * @param {import('@agoric/zone').Zone} zone
- * @param {import('@agoric/vow').Remote<Required<ConnectionHandler>>} handler0
+ * @param {Remote<Required<ConnectionHandler>>} handler0
  * @param {Endpoint} addr0
- * @param {import('@agoric/vow').Remote<Required<ConnectionHandler>>} handler1
+ * @param {Remote<Required<ConnectionHandler>>} handler1
  * @param {Endpoint} addr1
  * @param {(opts: ConnectionOpts) => Connection} makeConnection
+ * @param {Finalizer} finalizer
  * @param {WeakSetStore<Closable>} [current]
  */
 export const crossoverConnection = (
@@ -190,6 +202,7 @@ export const crossoverConnection = (
   handler1,
   addr1,
   makeConnection,
+  finalizer,
   current = zone.detached().weakSetStore('crossoverCurrentConnections'),
 ) => {
   const detached = zone.detached();
@@ -197,7 +210,7 @@ export const crossoverConnection = (
   /** @type {MapStore<number, Connection>} */
   const conns = detached.mapStore('addrToConnections');
 
-  /** @type {import('@agoric/vow').Remote<Required<ConnectionHandler>>[]} */
+  /** @type {Remote<Required<ConnectionHandler>>[]} */
   const handlers = harden([handler0, handler1]);
   /** @type {Endpoint[]} */
   const addrs = harden([addr0, addr1]);
@@ -215,9 +228,13 @@ export const crossoverConnection = (
    * @param {number} r remote side of the connection
    */
   const openHalfConnection = (l, r) => {
-    current.add(conns.get(l));
+    const lconn = conns.get(l);
+    current.add(lconn);
+    if (!finalizer.has(lconn)) {
+      finalizer.initConnection(lconn, handlers[l]);
+    }
     E(handlers[l])
-      .onOpen(conns.get(l), addrs[l], addrs[r], handlers[l])
+      .onOpen(lconn, addrs[l], addrs[r], handlers[l])
       .catch(rethrowUnlessMissing);
   };
 
@@ -233,9 +250,9 @@ export const crossoverConnection = (
 /**
  * @param {import('@agoric/zone').Zone} zone
  * @param {(opts: ConnectionOpts) => Connection} makeConnection
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {Powers} powers
  */
-const prepareInboundAttempt = (zone, makeConnection, { watch }) => {
+const prepareInboundAttempt = (zone, makeConnection, { watch, finalizer }) => {
   const makeInboundAttemptKit = zone.exoClassKit(
     'InboundAttempt',
     Shape.InboundAttemptI,
@@ -245,7 +262,7 @@ const prepareInboundAttempt = (zone, makeConnection, { watch }) => {
      * @param {string} opts.remoteAddr
      * @param {MapStore<Port, SetStore<Closable>>} opts.currentConnections
      * @param {string} opts.listenPrefix
-     * @param {MapStore<Endpoint, [Port, import('@agoric/vow').Remote<Required<ListenHandler>>]>} opts.listening
+     * @param {MapStore<Endpoint, [Port, Remote<Required<ListenHandler>>]>} opts.listening
      */
     ({
       localAddr,
@@ -288,6 +305,7 @@ const prepareInboundAttempt = (zone, makeConnection, { watch }) => {
 
           const current = currentConnections.get(port);
           current.delete(this.facets.inboundAttempt);
+          finalizer.unpin(this.facets.inboundAttempt);
 
           const innerVow = watch(
             E(listener).onReject(port, localAddr, remoteAddr, listener),
@@ -300,7 +318,7 @@ const prepareInboundAttempt = (zone, makeConnection, { watch }) => {
          * @param {object} opts
          * @param {string} [opts.localAddress]
          * @param {string} [opts.remoteAddress]
-         * @param {import('@agoric/vow').Remote<ConnectionHandler>} opts.handler
+         * @param {Remote<ConnectionHandler>} opts.handler
          */
         async accept({ localAddress, remoteAddress, handler: rchandler }) {
           const { consummated, localAddr, remoteAddr } = this.state;
@@ -342,15 +360,12 @@ const prepareInboundAttempt = (zone, makeConnection, { watch }) => {
 
           return crossoverConnection(
             zone,
-            /** @type {import('@agoric/vow').Remote<Required<ConnectionHandler>>} */ (
-              lchandler
-            ),
+            /** @type {Remote<Required<ConnectionHandler>>} */ (lchandler),
             localAddress,
-            /** @type {import('@agoric/vow').Remote<Required<ConnectionHandler>>} */ (
-              rchandler
-            ),
+            /** @type {Remote<Required<ConnectionHandler>>} */ (rchandler),
             remoteAddress,
             makeConnection,
+            finalizer,
             current,
           )[1];
         },
@@ -398,22 +413,22 @@ const RevokeState = /** @type {const} */ ({
 
 /**
  * @param {import('@agoric/zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {Powers} powers
  */
 const preparePort = (zone, powers) => {
   const makeIncapable = zone.exoClass('Incapable', undefined, () => ({}), {});
 
-  const { watch, allVows } = powers;
+  const { finalizer, watch, allVows } = powers;
 
   /**
    * @param {object} opts
    * @param {Endpoint} opts.localAddr
-   * @param {MapStore<Endpoint, [Port, import('@agoric/vow').Remote<Required<ListenHandler>>]>} opts.listening
-   * @param {SetStore<import('@agoric/vow').Remote<Connection>>} opts.openConnections
+   * @param {MapStore<Endpoint, [Port, Remote<Required<ListenHandler>>]>} opts.listening
+   * @param {SetStore<Remote<Connection>>} opts.openConnections
    * @param {MapStore<Port, SetStore<Closable>>} opts.currentConnections
    * @param {MapStore<string, Port>} opts.boundPorts
-   * @param {import('@agoric/vow').Remote<ProtocolHandler>} opts.protocolHandler
-   * @param {import('@agoric/vow').Remote<ProtocolImpl>} opts.protocolImpl
+   * @param {Remote<ProtocolHandler>} opts.protocolHandler
+   * @param {Remote<ProtocolImpl>} opts.protocolImpl
    */
   const initPort = ({
     localAddr,
@@ -443,7 +458,7 @@ const preparePort = (zone, powers) => {
         // Works even after revoke().
         return this.state.localAddr;
       },
-      /** @param {import('@agoric/vow').Remote<ListenHandler>} listenHandler */
+      /** @param {Remote<ListenHandler>} listenHandler */
       async addListener(listenHandler) {
         const { revoked, listening, localAddr, protocolHandler } = this.state;
 
@@ -458,9 +473,7 @@ const preparePort = (zone, powers) => {
           }
           listening.set(localAddr, [
             this.facets.port,
-            /** @type {import('@agoric/vow').Remote<Required<ListenHandler>>} */ (
-              listenHandler
-            ),
+            /** @type {Remote<Required<ListenHandler>>} */ (listenHandler),
           ]);
           E(lhandler).onRemove(lport, lhandler).catch(rethrowUnlessMissing);
         } else {
@@ -468,9 +481,7 @@ const preparePort = (zone, powers) => {
             localAddr,
             harden([
               this.facets.port,
-              /** @type {import('@agoric/vow').Remote<Required<ListenHandler>>} */ (
-                listenHandler
-              ),
+              /** @type {Remote<Required<ListenHandler>>} */ (listenHandler),
             ]),
           );
         }
@@ -489,7 +500,7 @@ const preparePort = (zone, powers) => {
         );
         return watch(innerVow, this.facets.rethrowUnlessMissingWatcher);
       },
-      /** @param {import('@agoric/vow').Remote<ListenHandler>} listenHandler */
+      /** @param {Remote<ListenHandler>} listenHandler */
       async removeListener(listenHandler) {
         const { listening, localAddr, protocolHandler } = this.state;
         listening.has(localAddr) || Fail`Port ${localAddr} is not listening`;
@@ -511,11 +522,11 @@ const preparePort = (zone, powers) => {
       },
       /**
        * @param {Endpoint} remotePort
-       * @param {import('@agoric/vow').Remote<ConnectionHandler>} [connectionHandler]
+       * @param {Remote<ConnectionHandler>} [connectionHandler]
        */
       async connect(
         remotePort,
-        connectionHandler = /** @type {import('@agoric/vow').Remote<ConnectionHandler>} */ (
+        connectionHandler = /** @type {Remote<ConnectionHandler>} */ (
           makeIncapable()
         ),
       ) {
@@ -527,7 +538,7 @@ const preparePort = (zone, powers) => {
         return watch(
           E(protocolImpl).outbound(this.facets.port, dst, connectionHandler),
           this.facets.portConnectWatcher,
-          { revoked },
+          { chandler: connectionHandler },
         );
       },
       async revoke() {
@@ -538,7 +549,6 @@ const preparePort = (zone, powers) => {
           Fail`Port ${localAddr} is already revoked`;
 
         this.state.revoked = RevokeState.REVOKING;
-
         const revokeVow = watch(
           E(protocolHandler).onRevoke(
             this.facets.port,
@@ -564,15 +574,16 @@ const preparePort = (zone, powers) => {
       },
     },
     portConnectWatcher: {
-      onFulfilled(conn, watchContext) {
-        const { revoked } = watchContext;
-        const { openConnections } = this.state;
+      onFulfilled(conn, { chandler }) {
+        const { openConnections, revoked } = this.state;
 
+        if (!finalizer.has(conn)) {
+          finalizer.initConnection(conn, chandler);
+        }
         if (revoked) {
-          void E(conn).close();
-        } else {
-          openConnections.add(conn);
+          return finalizer.finalize(conn);
         }
+        openConnections.add(conn);
         return conn;
       },
     },
@@ -586,8 +597,8 @@ const preparePort = (zone, powers) => {
 
         const ps = [];
         ps.push(
-          ...values.map(conn =>
-            watch(E(conn).close(), this.facets.sinkWatcher),
+          ...values.map(obj =>
+            watch(finalizer.finalize(obj), this.facets.sinkWatcher),
           ),
         );
 
@@ -650,12 +661,12 @@ const preparePort = (zone, powers) => {
 
 /**
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {Powers} powers
  */
 const prepareBinder = (zone, powers) => {
   const makeConnection = prepareHalfConnection(zone, powers);
 
-  const { watch } = powers;
+  const { watch, finalizer } = powers;
 
   const makeInboundAttempt = prepareInboundAttempt(
     zone,
@@ -730,8 +741,8 @@ const prepareBinder = (zone, powers) => {
      * @param {object} opts
      * @param {MapStore<Port, SetStore<Closable>>} opts.currentConnections
      * @param {MapStore<string, Port>} opts.boundPorts
-     * @param {MapStore<Endpoint, [Port, import('@agoric/vow').Remote<Required<ListenHandler>>]>} opts.listening
-     * @param {import('@agoric/vow').Remote<ProtocolHandler>} opts.protocolHandler
+     * @param {MapStore<Endpoint, [Port, Remote<Required<ListenHandler>>]>} opts.listening
+     * @param {Remote<ProtocolHandler>} opts.protocolHandler
      */
     ({ currentConnections, boundPorts, listening, protocolHandler }) => {
       /** @type {SetStore<Connection>} */
@@ -777,7 +788,7 @@ const prepareBinder = (zone, powers) => {
 
           const innerVow = watch(
             E(
-              /** @type {import('@agoric/vow').Remote<Required<ProtocolHandler>>} */ (
+              /** @type {Remote<Required<ProtocolHandler>>} */ (
                 protocolHandler
               ),
             ).onInstantiate(
@@ -819,7 +830,7 @@ const prepareBinder = (zone, powers) => {
           // Allocate a local address.
           const instantiateInnerVow = watch(
             E(
-              /** @type {import('@agoric/vow').Remote<Required<ProtocolHandler>>} */ (
+              /** @type {Remote<Required<ProtocolHandler>>} */ (
                 protocolHandler
               ),
             ).onInstantiate(port, localAddr, remoteAddr, protocolHandler),
@@ -904,6 +915,7 @@ const prepareBinder = (zone, powers) => {
           });
 
           current.add(inboundAttempt);
+          finalizer.initCloser(inboundAttempt);
           return inboundAttempt;
         },
       },
@@ -945,7 +957,7 @@ const prepareBinder = (zone, powers) => {
 
           const innerVow = watch(
             E(
-              /** @type {import('@agoric/vow').Remote<Required<ProtocolHandler>>} */ (
+              /** @type {Remote<Required<ProtocolHandler>>} */ (
                 protocolHandler
               ),
             ).onInstantiate(
@@ -1008,15 +1020,12 @@ const prepareBinder = (zone, powers) => {
 
           return crossoverConnection(
             zone,
-            /** @type {import('@agoric/vow').Remote<Required<ConnectionHandler>>} */ (
-              lchandler
-            ),
+            /** @type {Remote<Required<ConnectionHandler>>} */ (lchandler),
             negotiatedLocalAddress || requestedLocalAddress,
-            /** @type {import('@agoric/vow').Remote<Required<ConnectionHandler>>} */ (
-              rchandler
-            ),
+            /** @type {Remote<Required<ConnectionHandler>>} */ (rchandler),
             negotiatedRemoteAddress || requestedRemoteAddress,
             makeConnection,
+            finalizer,
             current,
           )[0];
         },
@@ -1169,13 +1178,13 @@ const prepareBinder = (zone, powers) => {
 
 /**
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {Powers} powers
  */
 export const prepareNetworkProtocol = (zone, powers) => {
   const makeBinderKit = prepareBinder(zone, powers);
 
   /**
-   * @param {import('@agoric/vow').Remote<ProtocolHandler>} protocolHandler
+   * @param {Remote<ProtocolHandler>} protocolHandler
    * @returns {Protocol}
    */
   const makeNetworkProtocol = protocolHandler => {
@@ -1187,7 +1196,7 @@ export const prepareNetworkProtocol = (zone, powers) => {
     /** @type {MapStore<string, Port>} */
     const boundPorts = detached.mapStore('addrToPort');
 
-    /** @type {MapStore<Endpoint, [Port, import('@agoric/vow').Remote<Required<ListenHandler>>]>} */
+    /** @type {MapStore<Endpoint, [Port, Remote<Required<ListenHandler>>]>} */
     const listening = detached.mapStore('listening');
 
     const { binder, protocolImpl } = makeBinderKit({
@@ -1261,17 +1270,17 @@ export const prepareEchoConnectionKit = zone => {
         },
         /**
          * @param {Connection} _connection
-         * @param {CloseReason} [_reason]
+         * @param {CloseReason} [reason]
          * @param {ConnectionHandler} [_connectionHandler]
          */
-        async onClose(_connection, _reason, _connectionHandler) {
+        async onClose(_connection, reason, _connectionHandler) {
           const { closed } = this.state;
 
           if (closed) {
             throw Error(closed);
           }
 
-          this.state.closed = 'Connection closed';
+          this.state.closed = reason || 'Connection closed';
         },
       },
       listener: {
@@ -1293,14 +1302,14 @@ export const prepareEchoConnectionKit = zone => {
  * Create a protocol handler that just connects to itself.
  *
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {VowTools} powers
  */
 export function prepareLoopbackProtocolHandler(zone, { watch, allVows }) {
   const detached = zone.detached();
 
   /** @param {string} [instancePrefix] */
   const initHandler = (instancePrefix = 'nonce/') => {
-    /** @type {MapStore<string, [import('@agoric/vow').Remote<Port>, import('@agoric/vow').Remote<Required<ListenHandler>>]>} */
+    /** @type {MapStore<string, [Remote<Port>, Remote<Required<ListenHandler>>]>} */
     const listeners = detached.mapStore('localAddr');
 
     return {
@@ -1379,7 +1388,7 @@ export function prepareLoopbackProtocolHandler(zone, { watch, allVows }) {
                 localAddr,
                 harden([
                   port,
-                  /** @type {import('@agoric/vow').Remote<Required<ListenHandler>>} */ (
+                  /** @type {Remote<Required<ListenHandler>>} */ (
                     listenHandler
                   ),
                 ]),
@@ -1390,17 +1399,15 @@ export function prepareLoopbackProtocolHandler(zone, { watch, allVows }) {
               localAddr,
               harden([
                 port,
-                /** @type {import('@agoric/vow').Remote<Required<ListenHandler>>} */ (
-                  listenHandler
-                ),
+                /** @type {Remote<Required<ListenHandler>>} */ (listenHandler),
               ]),
             );
           }
         },
         /**
-         * @param {import('@agoric/vow').Remote<Port>} port
+         * @param {Remote<Port>} port
          * @param {Endpoint} localAddr
-         * @param {import('@agoric/vow').Remote<ListenHandler>} listenHandler
+         * @param {Remote<ListenHandler>} listenHandler
          * @param {*} _protocolHandler
          */
         async onListenRemove(port, localAddr, listenHandler, _protocolHandler) {
@@ -1453,7 +1460,7 @@ export function prepareLoopbackProtocolHandler(zone, { watch, allVows }) {
 /**
  *
  * @param {import('@agoric/base-zone').Zone} zone
- * @param {ReturnType<import('@agoric/vow').prepareVowTools>} powers
+ * @param {Powers} powers
  */
 export const preparePortAllocator = (zone, { watch }) =>
   zone.exoClass(
@@ -1523,3 +1530,79 @@ export const preparePortAllocator = (zone, { watch }) =>
     },
   );
 /** @typedef {ReturnType<ReturnType<typeof preparePortAllocator>>} PortAllocator */
+
+/**
+ * Return a package-specific singleton that pins objects until they are
+ * explicitly unpinned or finalized.  It needs to pin objects only because they
+ * are resources that need to be released.
+ *
+ * The reason this functionality wasn't just baked into the other network exos
+ * is to maintain upgrade-compatible with minimal additional changes.
+ *
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {VowTools} vowTools
+ */
+const prepareFinalizer = (zone, { watch }) => {
+  /**
+   * @type {MapStore<{},
+   *   { conn: Remote<Connection>, handler: Remote<Required<ConnectionHandler>>} |
+   *   { closer: Remote<{ close(): PromiseVow<any> }> }
+   * >}
+   */
+  const objToFinalizerInfo = zone.mapStore('objToFinalizerInfo');
+  return zone.exo('NetworkFinalizer', undefined, {
+    has(obj) {
+      return objToFinalizerInfo.has(obj);
+    },
+    /**
+     * Add a connection and handler for an `onClose` method to be called upon
+     * finalization.
+     * @param {Remote<Connection>} conn
+     * @param {Remote<Required<ConnectionHandler>>} handler
+     */
+    initConnection(conn, handler) {
+      objToFinalizerInfo.init(conn, harden({ conn, handler }));
+    },
+    /**
+     * Add an object with a `close` method to be called (such as an
+     * `inboundAttempt`) upon finalization.
+     * @param {Remote<{ close(): PromiseVow<any> }>} closer
+     */
+    initCloser(closer) {
+      objToFinalizerInfo.init(closer, harden({ closer }));
+    },
+    finalize(obj) {
+      if (!objToFinalizerInfo.has(obj)) {
+        return;
+      }
+      const disposeInfo = objToFinalizerInfo.get(obj);
+      if ('conn' in disposeInfo) {
+        // A connection+handler.
+        const { conn, handler } = disposeInfo;
+        objToFinalizerInfo.delete(obj);
+        return watch(E(handler).onClose(conn, CLOSE_REASON_FINALIZER, handler));
+      } else if ('closer' in disposeInfo) {
+        // Just something with a `close` method.
+        const { closer } = disposeInfo;
+        objToFinalizerInfo.delete(obj);
+        return watch(E(closer).close());
+      }
+    },
+    unpin(obj) {
+      objToFinalizerInfo.delete(obj);
+    },
+  });
+};
+harden(prepareFinalizer);
+
+/**
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {VowTools} vowTools
+ * @returns {Powers}
+ */
+export const prepareNetworkPowers = (zone, vowTools) => {
+  const finalizer = prepareFinalizer(zone, vowTools);
+  return harden({ ...vowTools, finalizer });
+};
+
+/** @typedef {ReturnType<typeof prepareFinalizer>} Finalizer */

package/src/router.d.ts

@@ -1,6 +1,6 @@
 /**
- * @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';
+ * @import {Endpoint, Port, Protocol, ProtocolHandler} from './types.js';
+ * @import {PromiseVow, Remote, VowTools} from '@agoric/vow';
  */
 /**
  * @template T
@@ -31,24 +31,15 @@ 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?: import("@agoric/vow").IsRetryableReason | undefined;
-} | undefined) => {
-    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>) => 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>>;
+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("../../../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>;
+    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
@@ -89,7 +80,6 @@ export type RouterProtocol = {
     unregisterProtocolHandler: (prefix: string, protocolHandler: ProtocolHandler) => void;
 };
 import type { Endpoint } from './types.js';
-import type { VowKit } from '@agoric/vow';
 import type { ProtocolHandler } from './types.js';
 import type { Remote } from '@agoric/vow';
 import type { Port } from './types.js';

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,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;;;;;;;oCAnCI,GACzB;;CAkC0D,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;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,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

@@ -3,15 +3,15 @@
 /// <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, 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';
+ * @import {Endpoint, Port, Protocol, ProtocolHandler} from './types.js';
+ * @import {PromiseVow, Remote, VowTools} from '@agoric/vow';
  */
 
 /**
@@ -108,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) => {

package/src/shapes.js

@@ -158,18 +158,18 @@ export const Shape = /** @type {const} */ harden({
       ).returns(Shape2.Vow$(M.undefined())),
     }),
     protocolHandlerAcceptWatcher: M.interface('ProtocolHandlerAcceptWatcher', {
-      onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+      onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
     }),
     protocolHandlerInstantiateWatcher: M.interface(
       'ProtocolHandlerInstantiateWatcher',
       {
-        onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+        onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
       },
     ),
     protocolHandlerConnectWatcher: M.interface(
       'ProtocolHandlerConnectWatcher',
       {
-        onFulfilled: M.call(M.any()).rest(M.any()).returns(),
+        onFulfilled: M.call(M.any()).rest(M.any()).returns(M.any()),
       },
     ),
     rethrowUnlessMissingWatcher: M.interface('RethrowUnlessMissingWatcher', {