@agoric/vats 0.15.2-dev-c19f1b5.0 → 0.15.2-dev-27cc9b8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/vats",
-  "version": "0.15.2-dev-c19f1b5.0+c19f1b5",
+  "version": "0.15.2-dev-27cc9b8.0+27cc9b8",
   "description": "Agoric's Vat library",
   "type": "module",
   "main": "./index.js",
@@ -22,21 +22,20 @@
   "author": "Agoric",
   "license": "Apache-2.0",
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-c19f1b5.0+c19f1b5",
-    "@agoric/cosmic-proto": "0.4.1-dev-c19f1b5.0+c19f1b5",
-    "@agoric/ertp": "0.16.3-dev-c19f1b5.0+c19f1b5",
-    "@agoric/governance": "0.10.4-dev-c19f1b5.0+c19f1b5",
-    "@agoric/internal": "0.3.3-dev-c19f1b5.0+c19f1b5",
-    "@agoric/network": "0.1.1-dev-c19f1b5.0+c19f1b5",
-    "@agoric/notifier": "0.6.3-dev-c19f1b5.0+c19f1b5",
-    "@agoric/store": "0.9.3-dev-c19f1b5.0+c19f1b5",
-    "@agoric/swingset-vat": "0.32.3-dev-c19f1b5.0+c19f1b5",
-    "@agoric/time": "0.3.3-dev-c19f1b5.0+c19f1b5",
-    "@agoric/vat-data": "0.5.3-dev-c19f1b5.0+c19f1b5",
-    "@agoric/vow": "0.1.1-dev-c19f1b5.0+c19f1b5",
-    "@agoric/zoe": "0.26.3-dev-c19f1b5.0+c19f1b5",
-    "@agoric/zone": "0.2.3-dev-c19f1b5.0+c19f1b5",
-    "@endo/base64": "^1.0.5",
+    "@agoric/assert": "0.6.1-dev-27cc9b8.0+27cc9b8",
+    "@agoric/cosmic-proto": "0.4.1-dev-27cc9b8.0+27cc9b8",
+    "@agoric/ertp": "0.16.3-dev-27cc9b8.0+27cc9b8",
+    "@agoric/governance": "0.10.4-dev-27cc9b8.0+27cc9b8",
+    "@agoric/internal": "0.3.3-dev-27cc9b8.0+27cc9b8",
+    "@agoric/network": "0.1.1-dev-27cc9b8.0+27cc9b8",
+    "@agoric/notifier": "0.6.3-dev-27cc9b8.0+27cc9b8",
+    "@agoric/store": "0.9.3-dev-27cc9b8.0+27cc9b8",
+    "@agoric/swingset-vat": "0.32.3-dev-27cc9b8.0+27cc9b8",
+    "@agoric/time": "0.3.3-dev-27cc9b8.0+27cc9b8",
+    "@agoric/vat-data": "0.5.3-dev-27cc9b8.0+27cc9b8",
+    "@agoric/vow": "0.1.1-dev-27cc9b8.0+27cc9b8",
+    "@agoric/zoe": "0.26.3-dev-27cc9b8.0+27cc9b8",
+    "@agoric/zone": "0.2.3-dev-27cc9b8.0+27cc9b8",
     "@endo/far": "^1.1.2",
     "@endo/import-bundle": "^1.1.2",
     "@endo/marshal": "^1.5.0",
@@ -47,7 +46,7 @@
     "jessie.js": "^0.3.4"
   },
   "devDependencies": {
-    "@agoric/swingset-liveslots": "0.10.3-dev-c19f1b5.0+c19f1b5",
+    "@agoric/swingset-liveslots": "0.10.3-dev-27cc9b8.0+27cc9b8",
     "@endo/bundle-source": "^3.2.3",
     "@endo/init": "^1.1.2",
     "ava": "^5.3.0",
@@ -79,5 +78,5 @@
   "typeCoverage": {
     "atLeast": 91.21
   },
-  "gitHead": "c19f1b5b918e83f8f45c05c0683ee0f97ed0e415"
+  "gitHead": "27cc9b8be59abb048f1ea226b96697c3dccc4d0f"
 }

package/src/bridge-target.d.ts

@@ -0,0 +1,193 @@
+/**
+ * @typedef {object} TargetApp an object representing the app that receives
+ *   upcalls from the low-level TargetHost on the other side of a bridge
+ * @property {(obj: MostlyPureData) => Promise<MostlyPureData>} receiveUpcall
+ *   receive data from the TargetHost, and return a data result
+ */
+export const TargetAppI: import("@endo/patterns").InterfaceGuard<{
+    receiveUpcall: import("@endo/patterns").MethodGuard;
+}>;
+/**
+ * @typedef {object} TargetHost an object representing the host that receives
+ *   downcalls from the high-level TargetApp over a bridge
+ * @property {(obj: MostlyPureData) => Promise<MostlyPureData>} sendDowncall
+ *   send data to the TargetHost, which returns a data result
+ */
+export const TargetHostI: import("@endo/patterns").InterfaceGuard<{
+    sendDowncall: import("@endo/patterns").MethodGuard;
+}>;
+/**
+ * @typedef {object} AppTransformer an object for replacing a TargetApp,
+ *   generally with a wrapper that intercepts its inputs and/or results to
+ *   ensure conformance with a protocol and/or interface (e.g., an active tap
+ *   can encode results of the wrapped TargetApp into an acknowledgement
+ *   message)
+ * @property {(
+ *   app: ERef<TargetApp>,
+ *   targetHost: ERef<TargetHost>,
+ *   ...args: unknown[]
+ * ) => ERef<TargetApp>} wrapApp
+ */
+export const AppTransformerI: import("@endo/patterns").InterfaceGuard<{
+    wrapApp: import("@endo/patterns").MethodGuard;
+}>;
+/**
+ * @typedef {object} TargetRegistration is an ExoClass of its own, and each
+ *   instance is an attenuation of a BridgeTargetKit `targetRegistry` facet that
+ *   has access to internal state thereof but has been scoped down to a single
+ *   target.
+ * @property {() => Promise<void>} revoke performs unregistration (and sends the
+ *   corresponding "BRIDGE_TARGET_UNREGISTER" message to the targetHost).
+ * @property {(targetApp: ERef<TargetApp>) => Promise<void>} updateTargetApp
+ *   replaces the app associated with the target (but with no corresponding
+ *   message).
+ */
+export const TargetRegistrationI: import("@endo/patterns").InterfaceGuard<{
+    updateTargetApp: import("@endo/patterns").MethodGuard;
+    revoke: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareTargetRegistration(zone: import("@agoric/base-zone").Zone): (target: string, registry: TargetRegistry, args: unknown[] | null) => import("@endo/exo").Guarded<{
+    /**
+     * Atomically point the registration at a different app.
+     *
+     * @param {TargetApp} app new app to handle messages for the target
+     */
+    updateTargetApp(app: TargetApp): Promise<void>;
+    /** Atomically delete the registration. */
+    revoke(): Promise<void>;
+}>;
+export function prepareBridgeTargetKit(zone: import("@agoric/base-zone").Zone, makeTargetRegistration: ReturnType<typeof prepareTargetRegistration>): (manager: import("./types").ScopedBridgeManager<import("@agoric/internal").BridgeIdValue>, inboundEventType: string, appTransformer?: AppTransformer | undefined) => import("@endo/exo").GuardedKit<{
+    bridgeHandler: {
+        fromBridge(obj: any): Promise<any>;
+    };
+    targetHost: {
+        sendDowncall(obj: any): Promise<any>;
+    };
+    targetRegistry: {
+        /**
+         * Register an app to handle messages for a target.
+         *
+         * @param {string} target
+         * @param {TargetApp} app
+         * @param {unknown[]} [args]
+         * @returns {Promise<TargetRegistration>} power to set or delete the
+         *   registration
+         */
+        register(target: string, app: TargetApp, args?: unknown[] | undefined): Promise<TargetRegistration>;
+        /**
+         * Update the app that handles messages for a target.
+         *
+         * @param {string} target
+         * @param {TargetApp} app
+         * @param {unknown[]} [args]
+         * @returns {Promise<void>}
+         */
+        reregister(target: string, app: TargetApp, args?: unknown[] | undefined): Promise<void>;
+        /**
+         * Unregister the target, bypassing the attenuated `TargetRegistration`
+         * API.
+         *
+         * @param {string} target
+         * @returns {Promise<void>}
+         */
+        unregister(target: string): Promise<void>;
+    };
+}>;
+export function prepareBridgeTargetModule(zone: import("@agoric/base-zone").Zone): {
+    makeBridgeTargetKit: (manager: import("./types").ScopedBridgeManager<import("@agoric/internal").BridgeIdValue>, inboundEventType: string, appTransformer?: AppTransformer | undefined) => import("@endo/exo").GuardedKit<{
+        bridgeHandler: {
+            fromBridge(obj: any): Promise<any>;
+        };
+        targetHost: {
+            sendDowncall(obj: any): Promise<any>;
+        };
+        targetRegistry: {
+            /**
+             * Register an app to handle messages for a target.
+             *
+             * @param {string} target
+             * @param {TargetApp} app
+             * @param {unknown[]} [args]
+             * @returns {Promise<TargetRegistration>} power to set or delete the
+             *   registration
+             */
+            register(target: string, app: TargetApp, args?: unknown[] | undefined): Promise<TargetRegistration>;
+            /**
+             * Update the app that handles messages for a target.
+             *
+             * @param {string} target
+             * @param {TargetApp} app
+             * @param {unknown[]} [args]
+             * @returns {Promise<void>}
+             */
+            reregister(target: string, app: TargetApp, args?: unknown[] | undefined): Promise<void>;
+            /**
+             * Unregister the target, bypassing the attenuated `TargetRegistration`
+             * API.
+             *
+             * @param {string} target
+             * @returns {Promise<void>}
+             */
+            unregister(target: string): Promise<void>;
+        };
+    }>;
+};
+/**
+ * ideally should be PureData, but that type is
+ *   too restrictive to work out-of-the-box.
+ */
+export type MostlyPureData = any;
+/**
+ * an object representing the app that receives
+ *   upcalls from the low-level TargetHost on the other side of a bridge
+ */
+export type TargetApp = {
+    /**
+     *   receive data from the TargetHost, and return a data result
+     */
+    receiveUpcall: (obj: MostlyPureData) => Promise<MostlyPureData>;
+};
+/**
+ * an object representing the host that receives
+ *   downcalls from the high-level TargetApp over a bridge
+ */
+export type TargetHost = {
+    /**
+     *   send data to the TargetHost, which returns a data result
+     */
+    sendDowncall: (obj: MostlyPureData) => Promise<MostlyPureData>;
+};
+/**
+ * an object for replacing a TargetApp,
+ *   generally with a wrapper that intercepts its inputs and/or results to
+ *   ensure conformance with a protocol and/or interface (e.g., an active tap
+ *   can encode results of the wrapped TargetApp into an acknowledgement
+ *   message)
+ */
+export type AppTransformer = {
+    wrapApp: (app: ERef<TargetApp>, targetHost: ERef<TargetHost>, ...args: unknown[]) => ERef<TargetApp>;
+};
+/**
+ * is an ExoClass of its own, and each
+ *   instance is an attenuation of a BridgeTargetKit `targetRegistry` facet that
+ *   has access to internal state thereof but has been scoped down to a single
+ *   target.
+ */
+export type TargetRegistration = {
+    /**
+     * performs unregistration (and sends the
+     * corresponding "BRIDGE_TARGET_UNREGISTER" message to the targetHost).
+     */
+    revoke: () => Promise<void>;
+    /**
+     *   replaces the app associated with the target (but with no corresponding
+     *   message).
+     */
+    updateTargetApp: (targetApp: ERef<TargetApp>) => Promise<void>;
+};
+export type TargetRegistry = {
+    register: (target: string, targetApp: ERef<TargetApp>, args?: unknown[]) => Promise<TargetRegistration>;
+    reregister: (target: string, targetApp: ERef<TargetApp>, args?: unknown[]) => Promise<void>;
+    unregister: (target: string) => Promise<void>;
+};
+//# sourceMappingURL=bridge-target.d.ts.map

package/src/bridge-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bridge-target.d.ts","sourceRoot":"","sources":["bridge-target.js"],"names":[],"mappings":"AAYA;;;;;GAKG;AAEH;;GAEG;AAEH;;;;;GAKG;AAEH;;GAEG;AAEH;;;;;;;;;;;GAWG;AAEH;;GAOG;AAEH;;;;;;;;;;GAUG;AAEH;;;GAGG;AA4BI,gDADK,OAAO,mBAAmB,EAAE,IAAI;IAiBtC;;;;OAIG;yBADQ,SAAS;IAapB,0CAA0C;;GAW7C;AAyBI,6CAHI,OAAO,mBAAmB,EAAE,IAAI,0BAChC,UAAU,CAAC,OAAO,yBAAyB,CAAC;;;;;;;;QA6C/C;;;;;;;;WAQG;yBALQ,MAAM,OACN,SAAS,iCAEP,OAAO,CAAC,kBAAkB,CAAC;QAoCxC;;;;;;;WAOG;2BAJQ,MAAM,OACN,SAAS,iCAEP,OAAO,CAAC,IAAI,CAAC;QAyB1B;;;;;;WAMG;2BAFQ,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC;;GAc/B;AAII,gDADK,OAAO,mBAAmB,EAAE,IAAI;;;;;;;;;YA/FpC;;;;;;;;eAQG;6BALQ,MAAM,OACN,SAAS,iCAEP,OAAO,CAAC,kBAAkB,CAAC;YAoCxC;;;;;;;eAOG;+BAJQ,MAAM,OACN,SAAS,iCAEP,OAAO,CAAC,IAAI,CAAC;YAyB1B;;;;;;eAMG;+BAFQ,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC;;;EA0BjC;;;;;6BApTY,GAAG;;;;;;;;;mBASF,CAAC,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,cAAc,CAAC;;;;;;;;;;kBAWhD,CAAC,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,cAAc,CAAC;;;;;;;;;;aAchD,CACb,GAAO,EAAE,IAAI,CAAC,SAAS,CAAC,EACxB,UAAc,EAAE,IAAI,CAAC,UAAU,CAAC,EAChC,GAAO,IAAI,EAAE,OAAO,EAAE,KACf,IAAI,CAAC,SAAS,CAAC;;;;;;;;;;;;;YAiBT,MAAM,OAAO,CAAC,IAAI,CAAC;;;;;qBAEnB,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC;;;cAY7C,CACb,MAAU,EAAE,MAAM,EAClB,SAAa,EAAE,IAAI,CAAC,SAAS,CAAC,EAC9B,IAAQ,CAAC,EAAE,OAAO,EAAE,KACb,OAAO,CAAC,kBAAkB,CAAC;gBACrB,CACb,MAAU,EAAE,MAAM,EAClB,SAAa,EAAE,IAAI,CAAC,SAAS,CAAC,EAC9B,IAAQ,CAAC,EAAE,OAAO,EAAE,KACb,OAAO,CAAC,IAAI,CAAC;gBACP,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC"}

package/src/bridge-target.js

@@ -0,0 +1,316 @@
+import { E } from '@endo/far';
+import { M } from '@endo/patterns';
+
+import { BridgeHandlerI } from './bridge.js';
+
+/**
+ * @typedef {any} MostlyPureData ideally should be PureData, but that type is
+ *   too restrictive to work out-of-the-box.
+ */
+
+const { details: X, Fail } = assert;
+
+/**
+ * @typedef {object} TargetApp an object representing the app that receives
+ *   upcalls from the low-level TargetHost on the other side of a bridge
+ * @property {(obj: MostlyPureData) => Promise<MostlyPureData>} receiveUpcall
+ *   receive data from the TargetHost, and return a data result
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+export const TargetAppI = M.interface('TargetApp', {
+  receiveUpcall: M.callWhen(M.any()).returns(M.any()),
+});
+
+/**
+ * @typedef {object} TargetHost an object representing the host that receives
+ *   downcalls from the high-level TargetApp over a bridge
+ * @property {(obj: MostlyPureData) => Promise<MostlyPureData>} sendDowncall
+ *   send data to the TargetHost, which returns a data result
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+export const TargetHostI = M.interface('TargetHost', {
+  sendDowncall: M.callWhen(M.any()).returns(M.any()),
+});
+
+/**
+ * @typedef {object} AppTransformer an object for replacing a TargetApp,
+ *   generally with a wrapper that intercepts its inputs and/or results to
+ *   ensure conformance with a protocol and/or interface (e.g., an active tap
+ *   can encode results of the wrapped TargetApp into an acknowledgement
+ *   message)
+ * @property {(
+ *   app: ERef<TargetApp>,
+ *   targetHost: ERef<TargetHost>,
+ *   ...args: unknown[]
+ * ) => ERef<TargetApp>} wrapApp
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+export const AppTransformerI = M.interface('AppTransformer', {
+  wrapApp: M.callWhen(
+    M.await(M.remotable('TargetAppI')),
+    M.await(M.remotable('TargetHostI')),
+  )
+    .rest(M.any())
+    .returns(M.remotable('TargetAppI')),
+});
+
+/**
+ * @typedef {object} TargetRegistration is an ExoClass of its own, and each
+ *   instance is an attenuation of a BridgeTargetKit `targetRegistry` facet that
+ *   has access to internal state thereof but has been scoped down to a single
+ *   target.
+ * @property {() => Promise<void>} revoke performs unregistration (and sends the
+ *   corresponding "BRIDGE_TARGET_UNREGISTER" message to the targetHost).
+ * @property {(targetApp: ERef<TargetApp>) => Promise<void>} updateTargetApp
+ *   replaces the app associated with the target (but with no corresponding
+ *   message).
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+export const TargetRegistrationI = M.interface('TargetRegistration', {
+  updateTargetApp: M.callWhen(M.await(M.remotable('TargetAppI'))).returns(),
+  revoke: M.callWhen().returns(),
+});
+
+/**
+ * @typedef {object} TargetRegistry
+ * @property {(
+ *   target: string,
+ *   targetApp: ERef<TargetApp>,
+ *   args?: unknown[],
+ * ) => Promise<TargetRegistration>} register
+ * @property {(
+ *   target: string,
+ *   targetApp: ERef<TargetApp>,
+ *   args?: unknown[],
+ * ) => Promise<void>} reregister
+ * @property {(target: string) => Promise<void>} unregister
+ */
+// TODO unwrap type https://github.com/Agoric/agoric-sdk/issues/9163
+const TargetRegistryI = M.interface('TargetRegistry', {
+  register: M.callWhen(M.string(), M.await(M.remotable('TargetAppI')))
+    .optional(M.array())
+    .returns(M.remotable('TargetRegistration')),
+  reregister: M.callWhen(M.string(), M.await(M.remotable('TargetAppI')))
+    .optional(M.array())
+    .returns(),
+  unregister: M.callWhen(M.string()).returns(),
+});
+
+/** @param {import('@agoric/base-zone').Zone} zone */
+export const prepareTargetRegistration = zone =>
+  zone.exoClass(
+    'TargetRegistration',
+    TargetRegistrationI,
+    /**
+     * @param {string} target
+     * @param {TargetRegistry} registry
+     * @param {unknown[] | null} args
+     */
+    (target, registry, args) => ({
+      target,
+      /** @type {TargetRegistry | null} */
+      registry,
+      args,
+    }),
+    {
+      /**
+       * Atomically point the registration at a different app.
+       *
+       * @param {TargetApp} app new app to handle messages for the target
+       */
+      async updateTargetApp(app) {
+        const { target, registry, args } = this.state;
+        if (!registry) {
+          throw Fail`Registration for ${target} is already revoked`;
+        }
+        return E(registry).reregister(
+          target,
+          app,
+          /** @type {unknown[]} */ (args),
+        );
+      },
+      /** Atomically delete the registration. */
+      async revoke() {
+        const { target, registry } = this.state;
+        if (!registry) {
+          throw Fail`Registration for ${target} is already revoked`;
+        }
+        this.state.registry = null;
+        this.state.args = null;
+        return E(registry).unregister(target);
+      },
+    },
+  );
+
+/**
+ * A BridgeTargetKit is associated with a ScopedBridgeManager (essentially a
+ * specific named channel on a bridge, cf. {@link ./bridge.js}) and a particular
+ * inbound event type and an optional app transformer. It consists of three
+ * facets:
+ *
+ * - `targetHost` has a `downcall` method for sending outbound messages via the
+ *   bridge to the VM host.
+ * - `targetRegistry` has `register`, `reregister` and `unregister` methods to
+ *   register/reregister/unregister an "app" (or rather its transformation) with
+ *   a "target" corresponding to an address on the targetHost. Each target may
+ *   be associated with at most one app at any given time, and registration and
+ *   unregistration each send a message to the targetHost of the state change
+ *   (of type "BRIDGE_TARGET_REGISTER" and "BRIDGE_TARGET_UNREGISTER",
+ *   respectively). `reregister` is a method that atomically redirects the
+ *   target to a new (transformed) app.
+ * - `bridgeHandler` has a `fromBridge` method for receiving from the
+ *   ScopedBridgeManager inbound messages of the associated event type and
+ *   dispatching them to the app registered for their target.
+ *
+ * @param {import('@agoric/base-zone').Zone} zone
+ * @param {ReturnType<typeof prepareTargetRegistration>} makeTargetRegistration
+ */
+export const prepareBridgeTargetKit = (zone, makeTargetRegistration) =>
+  zone.exoClassKit(
+    'BridgeTargetKit',
+    {
+      bridgeHandler: BridgeHandlerI,
+      targetHost: TargetHostI,
+      targetRegistry: TargetRegistryI,
+    },
+    /**
+     * @template {import('@agoric/internal').BridgeIdValue} T
+     * @param {import('./types').ScopedBridgeManager<T>} manager
+     * @param {string} inboundEventType
+     * @param {AppTransformer} [appTransformer]
+     */
+    (manager, inboundEventType, appTransformer = undefined) => ({
+      manager,
+      inboundEventType,
+      appTransformer,
+      /** @type {MapStore<string, ERef<TargetApp>>} */
+      targetToApp: zone.detached().mapStore('targetToApp'),
+    }),
+    {
+      bridgeHandler: {
+        fromBridge(obj) {
+          const { inboundEventType, targetToApp } = this.state;
+          const { type, target } = obj;
+
+          type === inboundEventType ||
+            Fail`Invalid inbound event type ${type}; expected ${inboundEventType}`;
+
+          target || Fail`Missing target property in ${obj}`;
+
+          const app = targetToApp.get(target);
+          return E(app).receiveUpcall(obj);
+        },
+      },
+      targetHost: {
+        async sendDowncall(obj) {
+          const { manager } = this.state;
+          return E(manager).toBridge(obj);
+        },
+      },
+      targetRegistry: {
+        /**
+         * Register an app to handle messages for a target.
+         *
+         * @param {string} target
+         * @param {TargetApp} app
+         * @param {unknown[]} [args]
+         * @returns {Promise<TargetRegistration>} power to set or delete the
+         *   registration
+         */
+        async register(target, app, args = []) {
+          const { targetHost } = this.facets;
+          const { appTransformer, targetToApp } = this.state;
+
+          // Because wrapping an app is async, we verify absence of an existing
+          // registration twice (once to avoid the unnecessary invocation and
+          // once inside `init`), but attempt to throw similar errors in both
+          // cases.
+          !targetToApp.has(target) || Fail`Target ${target} already registered`;
+          const wrappedApp = await (appTransformer
+            ? E(appTransformer).wrapApp(app, targetHost, ...args)
+            : app);
+          try {
+            targetToApp.init(target, wrappedApp);
+          } catch (cause) {
+            throw assert.error(
+              X`Target ${target} already registered`,
+              undefined,
+              { cause },
+            );
+          }
+
+          await E(targetHost).sendDowncall({
+            type: 'BRIDGE_TARGET_REGISTER',
+            target,
+          });
+
+          return makeTargetRegistration(
+            target,
+            this.facets.targetRegistry,
+            args,
+          );
+        },
+        /**
+         * Update the app that handles messages for a target.
+         *
+         * @param {string} target
+         * @param {TargetApp} app
+         * @param {unknown[]} [args]
+         * @returns {Promise<void>}
+         */
+        async reregister(target, app, args = []) {
+          const { targetHost } = this.facets;
+          const { appTransformer, targetToApp } = this.state;
+
+          // Because wrapping an app is async, we verify absence of an existing
+          // registration twice (once to avoid the unnecessary invocation and
+          // once inside `set`), but attempt to throw similar errors in both
+          // cases.
+          targetToApp.has(target) ||
+            Fail`Target ${target} is already unregistered`;
+          const wrappedApp = await (appTransformer
+            ? E(appTransformer).wrapApp(app, targetHost, ...args)
+            : app);
+          try {
+            targetToApp.set(target, wrappedApp);
+          } catch (cause) {
+            throw assert.error(
+              X`Target ${target} is already unregistered`,
+              undefined,
+              { cause },
+            );
+          }
+        },
+        /**
+         * Unregister the target, bypassing the attenuated `TargetRegistration`
+         * API.
+         *
+         * @param {string} target
+         * @returns {Promise<void>}
+         */
+        async unregister(target) {
+          const { targetHost } = this.facets;
+          const { targetToApp } = this.state;
+          targetToApp.has(target) || Fail`Target ${target} is already deleted`;
+          targetToApp.delete(target);
+          await E(targetHost).sendDowncall({
+            type: 'BRIDGE_TARGET_UNREGISTER',
+            target,
+          });
+        },
+      },
+    },
+  );
+harden(prepareBridgeTargetKit);
+
+/** @param {import('@agoric/base-zone').Zone} zone */
+export const prepareBridgeTargetModule = zone => {
+  const makeTargetRegistration = prepareTargetRegistration(zone);
+  const makeBridgeTargetKit = prepareBridgeTargetKit(
+    zone,
+    makeTargetRegistration,
+  );
+
+  return harden({ makeBridgeTargetKit });
+};
+harden(prepareBridgeTargetModule);

package/src/core/types-ambient.d.ts

@@ -381,14 +381,15 @@ type ChainBootstrapSpaceT = {
   storageBridgeManager:
     | import('../types.js').ScopedBridgeManager<'storage'>
     | undefined;
+  transferMiddleware: import('../transfer.js').TransferMiddleware;
   /**
-   * Convienence function for starting a contract (ungoverned) and saving its
+   * Convenience function for starting a contract (ungoverned) and saving its
    * facets (including adminFacet)
    */
   startUpgradable: StartUpgradable;
   /** kits stored by startUpgradable */
   contractKits: MapStore<Instance, StartedInstanceKitWithLabel>;
-  /** Convience function for starting contracts governed by the Econ Committee */
+  /** Convenience function for starting contracts governed by the Econ Committee */
   startGovernedUpgradable: StartGovernedUpgradable;
   /** kits stored by startGovernedUpgradable */
   governedContractKits: MapStore<

package/src/ibc.d.ts

@@ -1,37 +1,14 @@
 export function prepareIBCConnectionHandler(zone: Zone): any;
 export function prepareIBCProtocol(zone: Zone, powers: {
     when: <T, TResult1 = import("@agoric/vow").Unwrap<T>, TResult2 = never>(specimenP: T, onFulfilled?: ((value: import("@agoric/vow").Unwrap<T>) => TResult1 | PromiseLike<TResult1>) | undefined, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined) => Promise<TResult1 | TResult2>;
-    watch: <T_1 = unknown, TResult1_1 = T_1, TResult2_1 = T_1, C = unknown>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<TResult1_1 | TResult2_1>;
+    watch: <T_1 = any, TResult1_1 = T_1, TResult2_1 = never, C = any>(specimenP: import("@agoric/vow").ERef<T_1 | import("@agoric/vow").Vow<T_1>>, watcher?: import("@agoric/vow").Watcher<T_1, TResult1_1, TResult2_1> | undefined, watcherContext?: C | undefined) => import("@agoric/vow").Vow<Exclude<TResult1_1, void> | Exclude<TResult2_1, void> extends never ? TResult1_1 : Exclude<TResult1_1, void> | Exclude<TResult2_1, void>>;
     makeVowKit: <T_2>() => VowKit<T_2>;
-    allVows: (vows: any) => import("@agoric/vow").Vow<any>;
+    allVows: (vows: unknown[]) => import("@agoric/vow").Vow<any[]>;
 }): (ibcdev: {
     downcall: (method: string, args: object) => Promise<any>;
 }) => {
     protocolHandler: ProtocolHandler;
     bridgeHandler: BridgeHandler;
-} | {
-    protocolHandler: import("@endo/exo").Guarded<{
-        /** @type {Required<ProtocolHandler>['onCreate']} */
-        onCreate(protocol: Remote<ProtocolImpl>, p: Remote<ProtocolHandler>): PromiseVow<void>;
-        /** @type {Required<ProtocolHandler>['onInstantiate']} */
-        onInstantiate(port: Remote<import("@agoric/network").Port>, localAddr: Endpoint, remote: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<string>;
-        /** @type {Required<ProtocolHandler>['generatePortID']} */
-        generatePortID(localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<string>;
-        /** @type {Required<ProtocolHandler>['onBind']} */
-        onBind(port: Remote<import("@agoric/network").Port>, localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<void>;
-        /** @type {Required<ProtocolHandler>['onConnect']} */
-        onConnect(port: Remote<import("@agoric/network").Port>, localAddr: Endpoint, remote: Endpoint, c: Remote<ConnectionHandler>, p: Remote<ProtocolHandler>): PromiseVow<AttemptDescription>;
-        /** @type {Required<ProtocolHandler>['onListen']} */
-        onListen(port: Remote<import("@agoric/network").Port>, localAddr: Endpoint, listenHandler: Remote<import("@agoric/network").ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
-        /** @type {Required<ProtocolHandler>['onListenRemove']} */
-        onListenRemove(port: Remote<import("@agoric/network").Port>, localAddr: Endpoint, listenHandler: Remote<import("@agoric/network").ListenHandler>, p: Remote<ProtocolHandler>): PromiseVow<void>;
-        /** @type {Required<ProtocolHandler>['onRevoke']} */
-        onRevoke(port: Remote<import("@agoric/network").Port>, localAddr: Endpoint, p: Remote<ProtocolHandler>): PromiseVow<void>;
-    }>;
-    bridgeHandler: import("@endo/exo").Guarded<{
-        /** @param {IBCEvent<IBCBridgeEvent>} obj */
-        fromBridge(obj: IBCEvent<IBCBridgeEvent>): Promise<import("@agoric/vow").Vow<any> | undefined>;
-    }>;
 };
 export function prepareCallbacks(zone: Zone): (dibcBridgeManager: ScopedBridgeManager<"dibc">) => import("@endo/exo").Guarded<{
     /**
@@ -55,15 +32,8 @@ import type { Zone } from '@agoric/base-zone';
 import type { VowKit } from '@agoric/vow';
 import type { ProtocolHandler } from '@agoric/network';
 import type { BridgeHandler } from './types.js';
-import type { ProtocolImpl } from '@agoric/network';
-import type { Remote } from '@agoric/vow';
-import type { PromiseVow } from '@agoric/vow';
-import type { Endpoint } from '@agoric/network';
-import type { ConnectionHandler } from '@agoric/network';
-import type { AttemptDescription } from '@agoric/network';
-import type { IBCBridgeEvent } from './types.js';
-import type { IBCEvent } from './types.js';
 import type { ScopedBridgeManager } from './types.js';
+import type { AttemptDescription } from '@agoric/network';
 import type { VowResolver } from '@agoric/vow';
 import type { ConnectingInfo } from './types.js';
 //# sourceMappingURL=ibc.d.ts.map

package/src/ibc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AAmDO,yDAFM,GAAG,CAmHf;AAMM;uFA1JW,CAAC;;;;;cAiKH,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;;;;;;QA2DtD,oDAAoD;;QAKpD,yDAAyD;+EAhE9D,QAAM,UAAc,QAAS;QAqExB,0DAA0D;kCArG1C,QAAS;QA0GzB,kDAAkD;wEApG9C,QAAS;QAiHb,qDAAqD;2EA/E9B,QAC9B,UACK,QACH;QA6HK,oDAAoD;0EA7JlD,QAAI;QAiKN,0DAA0D;gFArJjD,QAAS;QAyJlB,oDAAoD;0EA9HW,QACtE;;;QA6IO,4CAA4C;;;EAudnD;AAIM;IAOD;;;OAGG;qBAFQ,MAAM,OACN,GAAG;GAYnB;;;;;;;gBAxxBgB,UAAU;kBACR;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;;0BAbf,mBAAmB;4BAC0B,aAAa;qCAH+B,iBAAiB;mCACyE,YAAY;kCADtG,iBAAiB;4BAG7D,aAAa;gCAAb,aAAa;8BAH+B,iBAAiB;uCAAjB,iBAAiB;wCAX5F,iBAAiB;oCAYoJ,YAAY;8BAAZ,YAAY;yCAAZ,YAAY;iCAElJ,aAAa;oCAFyH,YAAY"}
+{"version":3,"file":"ibc.d.ts","sourceRoot":"","sources":["ibc.js"],"names":[],"mappings":"AAmDO,yDAFM,GAAG,CAmHf;AAMM;uFA1JK,CAAC;;;oBAW4C,SAAS;;cAsJlD,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,CAAC;;;;EAunB7D;AAIM;IAOD;;;OAGG;qBAFQ,MAAM,OACN,GAAG;GAYnB;;;;;;;gBAxxBgB,UAAU;kBACR;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;;0BAbf,mBAAmB;4BAC0B,aAAa;qCAH+B,iBAAiB;mCACyE,YAAY;yCAAZ,YAAY;wCAZjL,iBAAiB;iCAcc,aAAa;oCAFyH,YAAY"}