@agoric/swingset-vat 0.33.0-upgrade-19-dev-0754752.0 → 0.33.0-upgrade-18a-dev-4ee0508.0

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

@@ -128,10 +128,8 @@ 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'
@@ -242,31 +240,9 @@ 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 saveSnapshot(snapshotStream);
+        return snapStore.saveSnapshot(vatID, snapPos, snapshotStream);
       }
 
       /** @type {AsyncGenerator<Uint8Array, void, void>[]} */
@@ -292,7 +268,7 @@ export function makeXsSubprocessFactory({
             snapshotDescription,
           },
         }),
-        saveSnapshot(snapStoreSaveStream),
+        snapStore.saveSnapshot(vatID, snapPos, snapStoreSaveStream),
       ]);
       await closeP;
 

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

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

package/src/supervisors/supervisor-helper.js

@@ -32,15 +32,16 @@ function makeSupervisorDispatch(dispatch) {
   async function dispatchToVat(delivery) {
     // the (low-level) vat is responsible for giving up agency, but we still
     // protect against exceptions
-    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 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]);
+        },
+      );
   }
 
   return harden(dispatchToVat);

package/src/typeGuards.js

@@ -10,40 +10,38 @@ export const ManagerType = M.or(
 
 const Bundle = M.splitRecord({ moduleType: M.string() });
 
-const VatConfigOptions = harden({
+const SwingsetConfigOptions = {
   creationOptions: M.splitRecord({}, { critical: M.boolean() }),
   parameters: M.recordOf(M.string(), M.any()),
-});
+};
+harden(SwingsetConfigOptions);
 
-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),
-  );
+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,
+);
 
 /**
  * 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.splitRecord(
-  { vats: makeSwingSetConfigDescriptor(undefined, VatConfigOptions) },
-  {
-    defaultManagerType: ManagerType,
-    includeDevDependencies: M.boolean(),
-    defaultReapInterval: M.number(),
-    snapshotInterval: M.number(),
-    bootstrap: M.string(),
-    bundles: makeSwingSetConfigDescriptor(undefined, undefined, {}),
-  },
+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 }),
 );

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,15 +129,7 @@ export {};
  * @typedef { (dr: VatDeliveryResult) => void } SlogFinishDelivery
  * @typedef { (ksr: KernelSyscallResult, vsr: VatSyscallResult) => void } SlogFinishSyscall
  * @typedef { { write: ({}) => void,
- *              provideVatSlogger: (vatID: string,
- *                                  dynamic?: boolean,
- *                                  description?: string,
- *                                  name?: string,
- *                                  vatSourceBundle?: unknown,
- *                                  managerType?: string,
- *                                  vatParameters?: unknown) => { vatSlog: VatSlog },
- *              vatConsole: (vatID: string, origConsole: LimitedConsole) => LimitedConsole,
- *              startup: (vatID: string) => () => void,
+ *              vatConsole: (vatID: string, origConsole: {}) => {},
  *              delivery: (vatID: string,
  *                         newCrankNum: BigInt, newDeliveryNum: BigInt,
  *                         kd: KernelDeliveryObject, vd: VatDeliveryObject,
@@ -145,11 +137,13 @@ export {};
  *              syscall: (vatID: string,
  *                        ksc: KernelSyscallObject | undefined,
  *                        vsc: VatSyscallObject) => SlogFinishSyscall,
- *              changeCList: (vatID: string,
- *                            crankNum: BigInt,
- *                            mode: 'import' | 'export' | 'drop',
- *                            kernelSlot: string,
- *                            vatSlot: string) => void,
+ *              provideVatSlogger: (vatID: string,
+ *                                  dynamic?: boolean,
+ *                                  description?: string,
+ *                                  name?: string,
+ *                                  vatSourceBundle?: unknown,
+ *                                  managerType?: string,
+ *                                  vatParameters?: unknown) => { vatSlog: VatSlog },
  *              terminateVat: (vatID: string, shouldReject: boolean, info: SwingSetCapData) => void,
  *             } } KernelSlog
  * @typedef {{
@@ -160,25 +154,27 @@ 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?: StaticVatOptions,
+ *   creationOptions?: Record<string, any>,
  *   parameters?: Record<string, any>,
- * }} VatConfigOptions
- */
-/**
- * @template [Fields=object]
- * @typedef {(SourceSpec | BundleSpec | BundleName | BundleRef) & Fields} SwingSetConfigProperties
+ * }} SwingSetConfigProperties
  */
 
 /**
- * @template [Fields=object]
- * @typedef {Record<string, SwingSetConfigProperties<Fields>>} SwingSetConfigDescriptor
+ * @typedef {Record<string, SwingSetConfigProperties>} 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
@@ -192,7 +188,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<VatConfigOptions>} vats
+ * @property {SwingSetConfigDescriptor} vats
  * @property {SwingSetConfigDescriptor} [bundles]
  * @property {BundleFormat} [bundleFormat] the bundle source / import bundle
  * format.
@@ -210,7 +206,7 @@ export {};
  */
 
 /**
- * @typedef {BundleName | BundleRef | {bundleID: BundleID}} SourceOfBundle
+ * @typedef {{ bundleName: string} | { bundle: Bundle } | { bundleID: BundleID } } SourceOfBundle
  */
 /**
  * @typedef { import('@agoric/swing-store').KVStore } KVStore
@@ -299,8 +295,12 @@ 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,6 +326,8 @@ 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
@@ -344,10 +346,6 @@ 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',
@@ -362,7 +360,7 @@ export {};
  */
 
 /**
- * @typedef { { meter?: unknown } } OptMeter
+ * @typedef { { meter?: Meter } } 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,
@@ -372,13 +370,14 @@ export {};
  *        terminated. If undefined, the vat is unmetered. Static vats
  *        cannot be metered.
  *
- * @typedef { BaseVatOptions & { name: string, vatParameters?: object } & OptMeter } DynamicVatOptions
+ * @typedef { { managerType?: ManagerType } } OptManagerType
+ * @typedef { BaseVatOptions & OptMeter & OptManagerType } DynamicVatOptions
  *
  * config.vats[name].creationOptions: StaticVatOptions
  *
  * @typedef { { enableDisavow?: boolean } } OptEnableDisavow
  * @typedef { { nodeOptions?: string[] } } OptNodeOptions
- * @typedef { BaseVatOptions & OptEnableDisavow & OptNodeOptions } StaticVatOptions
+ * @typedef { BaseVatOptions & OptManagerType & OptEnableDisavow & OptNodeOptions } StaticVatOptions
  *
  * @typedef { { vatParameters?: object, upgradeMessage?: string } } VatUpgradeOptions
  * @typedef { { incarnationNumber: number } } VatUpgradeResults

package/src/types-internal.js

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

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

@@ -14,8 +14,6 @@ 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,10 +1,6 @@
 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) => {
@@ -21,7 +17,7 @@ export const makeNodeBundleCache = async (dest, options, loadModule, pid) => {
   };
   return wrappedMaker(dest, { log, ...options }, loadModule, pid);
 };
-/** @typedef {EReturn<typeof makeNodeBundleCache>} BundleCache */
+/** @typedef {Awaited<ReturnType<typeof makeNodeBundleCache>>} BundleCache */
 
 /** @type {Map<string, Promise<BundleCache>>} */
 const providedCaches = new Map();

package/tools/run-utils.js

@@ -53,25 +53,10 @@ export const makeRunUtils = (controller, harness) => {
   };
 
   /**
-   * @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])`.
+   * @typedef {import('@endo/eventual-send').EProxy & {
+   *  sendOnly: (presence: unknown) => Record<string, (...args: any) => void>;
+   *  vat: (name: string) => Record<string, (...args: any) => Promise<any>>;
+   * }} EVProxy
    */
 
   // IMPORTANT WARNING TO USERS OF `EV`
@@ -118,39 +103,52 @@ export const makeRunUtils = (controller, harness) => {
   // promise that can remain pending indefinitely, possibly to be settled by a
   // future message delivery.
 
-  /**
-   * @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]),
-          }),
-      },
-    )
+  /** @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],
+              ]),
+            ),
+        }),
+    },
   );
   return harden({ queueAndRun, EV });
 };