@agoric/swingset-vat 0.33.0-u18a.0 → 0.33.0-u19.0

package/src/kernel/vat-loader/manager-factory.js

@@ -4,7 +4,7 @@ import { makeLocalVatManagerFactory } from './manager-local.js';
 import { makeNodeSubprocessFactory } from './manager-subprocess-node.js';
 import { makeXsSubprocessFactory } from './manager-subprocess-xsnap.js';
 
-export function makeVatManagerFactory({
+export function makeVatManagerMaker({
   allVatPowers,
   kernelKeeper,
   vatEndowments,
@@ -18,14 +18,12 @@ export function makeVatManagerFactory({
     vatEndowments,
     gcTools,
   });
-
   const nodeSubprocessFactory = makeNodeSubprocessFactory({
     startSubprocessWorker: startSubprocessWorkerNode,
     kernelKeeper,
     kernelSlog,
     testLog: allVatPowers.testLog,
   });
-
   const xsWorkerFactory = makeXsSubprocessFactory({
     startXSnap,
     kernelKeeper,
@@ -69,58 +67,41 @@ export function makeVatManagerFactory({
    * @param {import('@agoric/swingset-liveslots').LiveSlotsOptions} options.liveSlotsOptions
    * @returns { Promise<import('../../types-internal.js').VatManager> }
    */
-  async function vatManagerFactory(
-    vatID,
-    { managerOptions, liveSlotsOptions },
-  ) {
+  async function makeVatManager(vatID, options) {
+    const { managerOptions, liveSlotsOptions } = options;
     validateManagerOptions(managerOptions);
     const { workerOptions, enableSetup } = managerOptions;
     const { type } = workerOptions;
 
-    if (type !== 'local' && 'setup' in managerOptions) {
-      console.warn(`TODO: stop using setup() with ${type}`);
-    }
-    if (enableSetup) {
-      if (managerOptions.setup) {
-        return localFactory.createFromSetup(vatID, managerOptions);
-      } else {
-        return localFactory.createFromBundle(
-          vatID,
-          managerOptions.bundle,
-          managerOptions,
-          liveSlotsOptions,
-        );
-      }
-    } else if (type === 'local') {
-      return localFactory.createFromBundle(
-        vatID,
-        managerOptions.bundle,
-        managerOptions,
-        liveSlotsOptions,
-      );
+    if (type !== 'local' && (enableSetup || 'setup' in managerOptions)) {
+      console.warn(`TODO: stop using enableSetup and setup() with ${type}`);
     }
 
-    if (type === 'node-subprocess') {
-      return nodeSubprocessFactory.createFromBundle(
-        vatID,
-        managerOptions.bundle,
-        managerOptions,
-        liveSlotsOptions,
-      );
+    if (enableSetup && managerOptions.setup) {
+      return localFactory.createFromSetup(vatID, managerOptions);
     }
 
-    if (type === 'xsnap') {
-      assert(managerOptions.bundle, 'xsnap requires Bundle');
-      return xsWorkerFactory.createFromBundle(
-        vatID,
-        managerOptions.bundle,
-        managerOptions,
-        liveSlotsOptions,
-      );
+    /** @type {Pick<typeof xsWorkerFactory, 'createFromBundle'>} */
+    let factory;
+    if (enableSetup || type === 'local') {
+      factory = localFactory;
+    } else if (type === 'node-subprocess') {
+      factory = nodeSubprocessFactory;
+    } else if (type === 'xsnap') {
+      assert(managerOptions.bundle, 'worker type xsnap requires a bundle');
+      factory = xsWorkerFactory;
+    } else {
+      throw Error(`unknown vat worker type ${type}`);
     }
 
-    throw Error(`unknown type ${type}, not 'local' or 'xsnap'`);
+    return factory.createFromBundle(
+      vatID,
+      // @ts-expect-error managerOptions.bundle might be undefined
+      managerOptions.bundle,
+      managerOptions,
+      liveSlotsOptions,
+    );
   }
 
-  return harden(vatManagerFactory);
+  return harden(makeVatManager);
 }

package/src/kernel/vat-loader/manager-subprocess-xsnap.js

@@ -128,8 +128,10 @@ export function makeXsSubprocessFactory({
 
     const vatKeeper = kernelKeeper.provideVatKeeper(vatID);
     const snapshotInfo = vatKeeper.getSnapshotInfo();
+    let uncompressedSizeLoaded = null;
     if (snapshotInfo) {
       kernelSlog.write({ type: 'heap-snapshot-load', vatID, ...snapshotInfo });
+      uncompressedSizeLoaded = snapshotInfo.uncompressedSize;
     }
 
     // `startXSnap` adds `nameDisplayArg` as a dummy argument so that 'ps'
@@ -240,9 +242,31 @@ export function makeXsSubprocessFactory({
     async function makeSnapshot(snapPos, snapStore, restartWorker) {
       const snapshotDescription = `${vatID}-${snapPos}`;
       const snapshotStream = worker.makeSnapshotStream(snapshotDescription);
+      const saveSnapshot = async saveStream => {
+        const results = await snapStore.saveSnapshot(
+          vatID,
+          snapPos,
+          saveStream,
+        );
+        const { hash: snapshotID, ...metrics } = results;
+        const uncompressedSizeDelta =
+          uncompressedSizeLoaded &&
+          metrics.uncompressedSize - uncompressedSizeLoaded;
+        uncompressedSizeLoaded = results.uncompressedSize;
+        kernelSlog.write({
+          type: 'heap-snapshot-save',
+          vatID,
+          snapshotID,
+          endPosition: snapPos,
+          ...metrics,
+          uncompressedSizeDelta,
+          restartWorker,
+        });
+        return results;
+      };
 
       if (!restartWorker) {
-        return snapStore.saveSnapshot(vatID, snapPos, snapshotStream);
+        return saveSnapshot(snapshotStream);
       }
 
       /** @type {AsyncGenerator<Uint8Array, void, void>[]} */
@@ -268,7 +292,7 @@ export function makeXsSubprocessFactory({
             snapshotDescription,
           },
         }),
-        snapStore.saveSnapshot(vatID, snapPos, snapStoreSaveStream),
+        saveSnapshot(snapStoreSaveStream),
       ]);
       await closeP;
 

package/src/kernel/vat-loader/vat-loader.js

@@ -9,7 +9,7 @@ export function makeVatRootObjectSlot() {
 export function makeVatLoader(stuff) {
   const {
     overrideVatManagerOptions = {},
-    vatManagerFactory,
+    makeVatManager,
     kernelSlog,
     makeSourcedConsole,
     kernelKeeper,
@@ -127,7 +127,7 @@ export function makeVatLoader(stuff) {
     };
 
     const finish = starting && kernelSlog.startup(vatID);
-    const manager = await vatManagerFactory(vatID, {
+    const manager = await makeVatManager(vatID, {
       managerOptions,
       liveSlotsOptions,
     });
@@ -150,7 +150,7 @@ export function makeVatLoader(stuff) {
       ...overrideVatManagerOptions,
     };
     const liveSlotsOptions = {};
-    const manager = await vatManagerFactory(vatID, {
+    const manager = await makeVatManager(vatID, {
       managerOptions,
       liveSlotsOptions,
     });

package/src/supervisors/supervisor-helper.js

@@ -32,16 +32,15 @@ function makeSupervisorDispatch(dispatch) {
   async function dispatchToVat(delivery) {
     // the (low-level) vat is responsible for giving up agency, but we still
     // protect against exceptions
-    return Promise.resolve(delivery)
-      .then(dispatch)
-      .then(
-        res => harden(['ok', res, null]),
-        err => {
-          // TODO react more thoughtfully, maybe terminate the vat
-          console.warn(`error during vat dispatch() of ${delivery}`, err);
-          return harden(['error', `${err}`, null]);
-        },
-      );
+    await null;
+    try {
+      const res = await dispatch(delivery);
+      return harden(['ok', res, null]);
+    } catch (err) {
+      // TODO react more thoughtfully, maybe terminate the vat
+      console.warn(`error during vat dispatch() of ${delivery}`, err);
+      return harden(['error', `${err}`, null]);
+    }
   }
 
   return harden(dispatchToVat);

package/src/typeGuards.js

@@ -10,38 +10,40 @@ export const ManagerType = M.or(
 
 const Bundle = M.splitRecord({ moduleType: M.string() });
 
-const SwingsetConfigOptions = {
+const VatConfigOptions = harden({
   creationOptions: M.splitRecord({}, { critical: M.boolean() }),
   parameters: M.recordOf(M.string(), M.any()),
-};
-harden(SwingsetConfigOptions);
+});
 
-const SwingSetConfigProperties = M.or(
-  M.splitRecord({ sourceSpec: M.string() }, SwingsetConfigOptions),
-  M.splitRecord({ bundleSpec: M.string() }, SwingsetConfigOptions),
-  M.splitRecord({ bundle: Bundle }, SwingsetConfigOptions),
-);
-const SwingSetConfigDescriptor = M.recordOf(
-  M.string(),
-  SwingSetConfigProperties,
-);
+const makeSwingSetConfigProperties = (required = {}, optional = {}, rest) =>
+  M.or(
+    M.splitRecord({ sourceSpec: M.string(), ...required }, optional, rest),
+    M.splitRecord({ bundleSpec: M.string(), ...required }, optional, rest),
+    M.splitRecord({ bundle: Bundle, ...required }, optional, rest),
+  );
+const makeSwingSetConfigDescriptor = (required, optional, rest) =>
+  M.recordOf(
+    M.string(),
+    makeSwingSetConfigProperties(required, optional, rest),
+  );
 
 /**
  * NOTE: this pattern suffices for PSM bootstrap,
  * but does not cover the whole SwingSet config syntax.
  *
  * {@link ./docs/configuration.md}
- * TODO: move this to swingset?
  *
  * @see SwingSetConfig
  * in ./types-external.js
  */
-export const SwingSetConfig = M.and(
-  M.splitRecord({}, { defaultManagerType: ManagerType }),
-  M.splitRecord({}, { includeDevDependencies: M.boolean() }),
-  M.splitRecord({}, { defaultReapInterval: M.number() }), // not in type decl
-  M.splitRecord({}, { snapshotInterval: M.number() }),
-  M.splitRecord({}, { vats: SwingSetConfigDescriptor }),
-  M.splitRecord({}, { bootstrap: M.string() }),
-  M.splitRecord({}, { bundles: SwingSetConfigDescriptor }),
+export const SwingSetConfig = M.splitRecord(
+  { vats: makeSwingSetConfigDescriptor(undefined, VatConfigOptions) },
+  {
+    defaultManagerType: ManagerType,
+    includeDevDependencies: M.boolean(),
+    defaultReapInterval: M.number(),
+    snapshotInterval: M.number(),
+    bootstrap: M.string(),
+    bundles: makeSwingSetConfigDescriptor(undefined, undefined, {}),
+  },
 );

package/src/types-external.js

@@ -1,10 +1,10 @@
-/** @import { ERef } from '@endo/far'; */
-
 export {};
 
 /**
  * @import {Guarded} from '@endo/exo';
+ * @import {ERef} from '@endo/far';
  * @import {Passable, RemotableObject} from '@endo/pass-style';
+ * @import {LimitedConsole} from '@agoric/internal/src/js-utils.js';
  */
 
 /* This file defines types that part of the external API of swingset. That
@@ -129,14 +129,6 @@ export {};
  * @typedef { (dr: VatDeliveryResult) => void } SlogFinishDelivery
  * @typedef { (ksr: KernelSyscallResult, vsr: VatSyscallResult) => void } SlogFinishSyscall
  * @typedef { { write: ({}) => void,
- *              vatConsole: (vatID: string, origConsole: {}) => {},
- *              delivery: (vatID: string,
- *                         newCrankNum: BigInt, newDeliveryNum: BigInt,
- *                         kd: KernelDeliveryObject, vd: VatDeliveryObject,
- *                         replay?: boolean) => SlogFinishDelivery,
- *              syscall: (vatID: string,
- *                        ksc: KernelSyscallObject | undefined,
- *                        vsc: VatSyscallObject) => SlogFinishSyscall,
  *              provideVatSlogger: (vatID: string,
  *                                  dynamic?: boolean,
  *                                  description?: string,
@@ -144,6 +136,20 @@ export {};
  *                                  vatSourceBundle?: unknown,
  *                                  managerType?: string,
  *                                  vatParameters?: unknown) => { vatSlog: VatSlog },
+ *              vatConsole: (vatID: string, origConsole: LimitedConsole) => LimitedConsole,
+ *              startup: (vatID: string) => () => void,
+ *              delivery: (vatID: string,
+ *                         newCrankNum: BigInt, newDeliveryNum: BigInt,
+ *                         kd: KernelDeliveryObject, vd: VatDeliveryObject,
+ *                         replay?: boolean) => SlogFinishDelivery,
+ *              syscall: (vatID: string,
+ *                        ksc: KernelSyscallObject | undefined,
+ *                        vsc: VatSyscallObject) => SlogFinishSyscall,
+ *              changeCList: (vatID: string,
+ *                            crankNum: BigInt,
+ *                            mode: 'import' | 'export' | 'drop',
+ *                            kernelSlot: string,
+ *                            vatSlot: string) => void,
  *              terminateVat: (vatID: string, shouldReject: boolean, info: SwingSetCapData) => void,
  *             } } KernelSlog
  * @typedef {{
@@ -154,27 +160,25 @@ export {};
  */
 
 /**
+ * @typedef {{ bundle: Bundle }} BundleRef a bundle object
+ * @typedef {{ bundleName: string }} BundleName a name identifying a property in the `bundles` of a SwingSetOptions object
+ * @typedef {{ bundleSpec: string }} BundleSpec a path to a bundle file
+ * @typedef {{ sourceSpec: string }} SourceSpec a package specifier such as "@agoric/swingset-vat/tools/vat-puppet.js"
+ *
  * @typedef {{
- *   sourceSpec: string // path to pre-bundled root
- * }} SourceSpec
- * @typedef {{
- *   bundleSpec: string // path to bundled code
- * }} BundleSpec
- * @typedef {{
- *   bundle: Bundle
- * }} BundleRef
- * @typedef {{
- *   bundleName: string
- * }} BundleName
- * @typedef {(SourceSpec | BundleSpec | BundleRef | BundleName ) & {
  *   bundleID?: BundleID,
- *   creationOptions?: Record<string, any>,
+ *   creationOptions?: StaticVatOptions,
  *   parameters?: Record<string, any>,
- * }} SwingSetConfigProperties
+ * }} VatConfigOptions
+ */
+/**
+ * @template [Fields=object]
+ * @typedef {(SourceSpec | BundleSpec | BundleName | BundleRef) & Fields} SwingSetConfigProperties
  */
 
 /**
- * @typedef {Record<string, SwingSetConfigProperties>} SwingSetConfigDescriptor
+ * @template [Fields=object]
+ * @typedef {Record<string, SwingSetConfigProperties<Fields>>} SwingSetConfigDescriptor
  * Where the property name is the name of the vat.  Note that
  * the `bootstrap` property names the vat that should be used as the bootstrap vat.  Although a swingset
  * configuration can designate any vat as its bootstrap vat, `loadBasedir` will always look for a file named
@@ -188,7 +192,7 @@ export {};
  * `devDependencies` of the surrounding `package.json` should be accessible to
  * bundles.
  * @property {string} [bundleCachePath] if present, SwingSet will use a bundle cache at this path
- * @property {SwingSetConfigDescriptor} vats
+ * @property {SwingSetConfigDescriptor<VatConfigOptions>} vats
  * @property {SwingSetConfigDescriptor} [bundles]
  * @property {BundleFormat} [bundleFormat] the bundle source / import bundle
  * format.
@@ -206,7 +210,7 @@ export {};
  */
 
 /**
- * @typedef {{ bundleName: string} | { bundle: Bundle } | { bundleID: BundleID } } SourceOfBundle
+ * @typedef {BundleName | BundleRef | {bundleID: BundleID}} SourceOfBundle
  */
 /**
  * @typedef { import('@agoric/swing-store').KVStore } KVStore
@@ -295,12 +299,8 @@ export {};
  * Vat Creation and Management
  *
  * @typedef { string } BundleID
- * @typedef {any} BundleCap
+ * @typedef { any } BundleCap
  * @typedef { { moduleFormat: 'endoZipBase64', endoZipBase64: string, endoZipBase64Sha512: string } } EndoZipBase64Bundle
- *
- * @typedef { unknown } Meter
- *
- * E(vatAdminService).createVat(bundle, options: DynamicVatOptions)
  */
 
 /**
@@ -326,8 +326,6 @@ export {};
  * types are then defined as amendments to this base type.
  *
  * @typedef { object } BaseVatOptions
- * @property { string } name
- * @property { * } [vatParameters]
  * @property { boolean } [enableSetup]
  *           If true, permits the vat to construct itself using the
  *           `setup()` API, which bypasses the imposition of LiveSlots but
@@ -346,6 +344,10 @@ export {};
  *            outbound syscalls so that the vat's internal state can be
  *            reconstructed via replay.  If false, no such record is kept.
  *            Defaults to true.
+ * @property { ManagerType } [managerType]
+ * @property { boolean } [neverReap]
+ *            If true, disables automatic bringOutYourDead deliveries to a vat.
+ *            Defaults to false.
  * @property { number | 'never' } [reapInterval]
  *            Trigger a bringOutYourDead after the vat has received
  *            this many deliveries. If the value is 'never',
@@ -360,7 +362,7 @@ export {};
  */
 
 /**
- * @typedef { { meter?: Meter } } OptMeter
+ * @typedef { { meter?: unknown } } OptMeter
  *        If a meter is provided, the new dynamic vat is limited to a fixed
  *        amount of computation and allocation that can occur during any
  *        given crank. Peak stack frames are limited as well. In addition,
@@ -370,14 +372,13 @@ export {};
  *        terminated. If undefined, the vat is unmetered. Static vats
  *        cannot be metered.
  *
- * @typedef { { managerType?: ManagerType } } OptManagerType
- * @typedef { BaseVatOptions & OptMeter & OptManagerType } DynamicVatOptions
+ * @typedef { BaseVatOptions & { name: string, vatParameters?: object } & OptMeter } DynamicVatOptions
  *
  * config.vats[name].creationOptions: StaticVatOptions
  *
  * @typedef { { enableDisavow?: boolean } } OptEnableDisavow
  * @typedef { { nodeOptions?: string[] } } OptNodeOptions
- * @typedef { BaseVatOptions & OptManagerType & OptEnableDisavow & OptNodeOptions } StaticVatOptions
+ * @typedef { BaseVatOptions & OptEnableDisavow & OptNodeOptions } StaticVatOptions
  *
  * @typedef { { vatParameters?: object, upgradeMessage?: string } } VatUpgradeOptions
  * @typedef { { incarnationNumber: number } } VatUpgradeResults

package/src/types-internal.js

@@ -29,7 +29,6 @@ export {};
  * @typedef { string } MeterID
  * @typedef { { meterID?: MeterID } } OptMeterID
  * @typedef { import('./types-external.js').BaseVatOptions } BaseVatOptions
- * @typedef { import('./types-external.js').OptManagerType } OptManagerType
  * @typedef { import('@agoric/swingset-liveslots').VatDeliveryObject } VatDeliveryObject
  * @typedef { import('@agoric/swingset-liveslots').VatDeliveryResult } VatDeliveryResult
  * @typedef { import('@agoric/swingset-liveslots').VatSyscallObject } VatSyscallObject
@@ -38,7 +37,7 @@ export {};
  *
  * // used by vatKeeper.setSourceAndOptions(source, RecordedVatOptions)
  *
- * @typedef { BaseVatOptions & OptMeterID & OptManagerType } InternalDynamicVatOptions
+ * @typedef { BaseVatOptions & OptMeterID } InternalDynamicVatOptions
  *
  * RecordedVatOptions is fully-specified, no optional fields
  *
@@ -112,7 +111,7 @@ export {};
  *   enableDisavow: boolean,
  *   useTranscript: boolean,
  *   name: string,
- *   sourcedConsole: Pick<Console, 'debug' | 'log' | 'info' | 'warn' | 'error'>,
+ *   sourcedConsole: import('@agoric/internal/src/js-utils.js').LimitedConsole,
  *   enableSetup: boolean,
  *   setup?: unknown,
  *   retainSyscall?: boolean

package/src/vats/timer/vat-timer.js

@@ -14,6 +14,8 @@ import { makeScalarWeakMapStore } from '@agoric/store';
 import { TimeMath } from '@agoric/time';
 
 /**
+ * @import {LegacyWeakMap, WeakMapStore} from '@agoric/store';
+ * @import {MapStore} from '@agoric/swingset-liveslots';
  * @import {Passable, RemotableObject} from '@endo/pass-style';
  * @import {Key} from '@endo/patterns';
  */

package/tools/bundleTool.js

@@ -1,6 +1,10 @@
 import { makeNodeBundleCache as wrappedMaker } from '@endo/bundle-source/cache.js';
 import styles from 'ansi-styles'; // less authority than 'chalk'
 
+/**
+ * @import {EReturn} from '@endo/far';
+ */
+
 /** @type {typeof wrappedMaker} */
 export const makeNodeBundleCache = async (dest, options, loadModule, pid) => {
   const log = (...args) => {
@@ -17,7 +21,7 @@ export const makeNodeBundleCache = async (dest, options, loadModule, pid) => {
   };
   return wrappedMaker(dest, { log, ...options }, loadModule, pid);
 };
-/** @typedef {Awaited<ReturnType<typeof makeNodeBundleCache>>} BundleCache */
+/** @typedef {EReturn<typeof makeNodeBundleCache>} BundleCache */
 
 /** @type {Map<string, Promise<BundleCache>>} */
 const providedCaches = new Map();

package/tools/run-utils.js

@@ -53,10 +53,25 @@ export const makeRunUtils = (controller, harness) => {
   };
 
   /**
-   * @typedef {import('@endo/eventual-send').EProxy & {
-   *  sendOnly: (presence: unknown) => Record<string, (...args: any) => void>;
-   *  vat: (name: string) => Record<string, (...args: any) => Promise<any>>;
-   * }} EVProxy
+   * @typedef EVProxyMethods
+   * @property {(presence: unknown) => Record<string, (...args: any) => Promise<void>>} sendOnly
+   *   Returns a "methods proxy" for the presence that ignores the results of
+   *   each method invocation.
+   * @property {(name: string) => Record<string, (...args: any) => Promise<any>>} vat
+   *   Returns a "methods proxy" for the root object of the specified vat.
+   *   So e.g. `EV.vat('foo').m(0)` becomes
+   *   `controller.queueToVatRoot('foo', 'm', [0])`.
+   * @property {(presence: unknown) => Record<string, Promise<any>>} get
+   *   Returns a "values proxy" for the presence for which each requested
+   *   property manifests as a promise.
+   */
+  /**
+   * @typedef {import('@endo/eventual-send').EProxy & EVProxyMethods} EVProxy
+   *   Given a presence, return a "methods proxy" for which each requested
+   *   property manifests as a method that forwards its invocation through the
+   *   controller to the presence as an invocation of an identically-named method
+   *   with identical arguments (modulo passable translation).
+   *   So e.g. `EV(x).m(0)` becomes `controller.queueToVatObject(x, 'm', [0])`.
    */
 
   // IMPORTANT WARNING TO USERS OF `EV`
@@ -103,52 +118,39 @@ export const makeRunUtils = (controller, harness) => {
   // promise that can remain pending indefinitely, possibly to be settled by a
   // future message delivery.
 
-  /** @type {EVProxy} */
-  // @ts-expect-error cast, approximate
-  const EV = Object.assign(
-    presence =>
-      new Proxy(harden({}), {
-        get: (_t, method, _rx) => {
-          const boundMethod = (...args) =>
-            queueAndRun(() =>
-              controller.queueToVatObject(presence, method, args),
-            );
-          return harden(boundMethod);
-        },
-      }),
-    {
-      vat: vatName =>
-        new Proxy(harden({}), {
-          get: (_t, method, _rx) => {
-            const boundMethod = (...args) =>
-              queueAndRun(() =>
-                controller.queueToVatRoot(vatName, method, args),
-              );
-            return harden(boundMethod);
-          },
-        }),
-      sendOnly: presence =>
-        new Proxy(harden({}), {
-          get: (_t, method, _rx) => {
-            const boundMethod = (...args) =>
-              queueAndRun(
-                () => controller.queueToVatObject(presence, method, args),
-                true,
-              );
-            return harden(boundMethod);
-          },
-        }),
-      get: presence =>
-        new Proxy(harden({}), {
-          get: (_t, pathElement, _rx) =>
-            queueAndRun(() =>
-              controller.queueToVatRoot('bootstrap', 'awaitVatObject', [
-                presence,
-                [pathElement],
-              ]),
-            ),
-        }),
-    },
+  /**
+   * @template {(typeof controller.queueToVatObject) | (typeof controller.queueToVatRoot)} T
+   * @param {T} invoker
+   * @param {Parameters<T>[0]} target
+   * @param {boolean} [voidResult]
+   */
+  const makeMethodsProxy = (invoker, target, voidResult = false) =>
+    new Proxy(harden({}), {
+      get: (_t, method, _rx) => {
+        const resultPolicy = voidResult ? 'none' : undefined;
+        const boundMethod = (...args) =>
+          queueAndRun(
+            () => invoker(target, method, args, resultPolicy),
+            voidResult,
+          );
+        return harden(boundMethod);
+      },
+    });
+
+  const EV = /** @type {EVProxy} */ (
+    Object.assign(
+      presence => makeMethodsProxy(controller.queueToVatObject, presence),
+      {
+        vat: vatName => makeMethodsProxy(controller.queueToVatRoot, vatName),
+        sendOnly: presence =>
+          makeMethodsProxy(controller.queueToVatObject, presence, true),
+        get: presence =>
+          new Proxy(harden({}), {
+            get: (_t, key, _rx) =>
+              EV.vat('bootstrap').awaitVatObject(presence, [key]),
+          }),
+      },
+    )
   );
   return harden({ queueAndRun, EV });
 };