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

package/src/kernel/slogger.js

@@ -1,127 +1,120 @@
 import { q } from '@endo/errors';
-import { makeLimitedConsole } from '@agoric/internal/src/ses-utils.js';
-
-/** @import {LimitedConsole} from '@agoric/internal/src/js-utils.js'; */
 
 const IDLE = 'idle';
 const STARTUP = 'startup';
 const DELIVERY = 'delivery';
 
-const noopFinisher = harden(() => {});
-
-/** @typedef {(...finishArgs: unknown[]) => unknown} AnyFinisher */
-/** @typedef {Partial<Record<Exclude<keyof KernelSlog, 'write'>, (methodName: string, args: unknown[], finisher: AnyFinisher) => unknown>>} SlogWrappers */
-
-/**
- * Support composition of asynchronous callbacks that are invoked at the start
- * of an operation and return either a non-function result or a "finisher"
- * function to be invoked upon operation completion.
- * This maker accepts a collection of wrapper functions that receive the same
- * arguments as the method they wrap, along with the result of that method
- * (e.g., its finisher), and are expected to return a finisher of their own that
- * will invoke that wrapped finisher.
- *
- * @param {SlogWrappers} wrappers
- */
-function makeFinishersKit(wrappers) {
-  const unused = new Set(Object.keys(wrappers));
+function makeCallbackRegistry(callbacks) {
+  const todo = new Set(Object.keys(callbacks));
   return harden({
     /**
-     * Robustly wrap a method if a wrapper is defined.
+     * Robustly wrap a method with a callbacks[method] function, if defined.  We
+     * incur no runtime overhead if the given callback method isn't defined.
      *
-     * @template {(...args: unknown[]) => (Finisher | unknown)} F
-     * @template {AnyFinisher} [Finisher=AnyFinisher]
-     * @param {string} method name
-     * @param {F} impl the original implementation
-     * @returns {F} the wrapped method
+     * @param {string} method wrap with callbacks[method]
+     * @param {(...args: Array<unknown>) => unknown} impl the original
+     * implementation of the method
+     * @returns {(...args: Array<unknown>) => unknown} the wrapped method if the
+     * callback is defined, or original method if not
      */
-    wrap(method, impl) {
-      unused.delete(method);
-      const wrapper = wrappers[method];
-
-      // If there is no registered wrapper, return the implementation directly.
-      if (!wrapper) return impl;
+    registerCallback(method, impl) {
+      todo.delete(method);
+      const cb = callbacks[method];
+      if (!cb) {
+        // No registered callback, just use the implementation directly.
+        // console.error('no registered callback for', method);
+        return impl;
+      }
 
-      const wrapped = (...args) => {
-        const maybeFinisher = /** @type {Finisher} */ (impl(...args));
+      return (...args) => {
+        // Invoke the implementation first.
+        const ret = impl(...args);
         try {
-          // Allow the callback to observe the call synchronously, and replace
-          // the implementation's finisher function, but not to throw an exception.
-          const wrapperFinisher = wrapper(method, args, maybeFinisher);
-          if (typeof maybeFinisher !== 'function') return wrapperFinisher;
-
-          // We wrap the finisher in the callback's return value.
-          return (...finishArgs) => {
-            try {
-              return /** @type {Finisher} */ (wrapperFinisher)(...finishArgs);
-            } catch (e) {
-              console.error(`${method} wrapper finisher failed:`, e);
-              return maybeFinisher(...finishArgs);
-            }
-          };
+          // Allow the callback to observe the call synchronously, and affect
+          // the finisher function, but not to throw an exception.
+          const cbRet = cb(method, args, ret);
+          if (typeof ret === 'function') {
+            // We wrap the finisher in the callback's return value.
+            return (...finishArgs) => {
+              try {
+                return cbRet(...finishArgs);
+              } catch (e) {
+                console.error(
+                  `failed to call registered ${method}.finish function:`,
+                  e,
+                );
+              }
+              return ret(...args);
+            };
+          }
+          // We just return the callback's return value.
+          return cbRet;
         } catch (e) {
-          console.error(`${method} wrapper failed:`, e);
-          return maybeFinisher;
+          console.error('failed to call registered', method, 'callback:', e);
         }
+        return ret;
       };
-      return /** @type {F} */ (wrapped);
     },
     /**
-     * Declare that all wrapping is done.
+     * Declare that all the methods have been registered.
      *
-     * @param {string} msg message to display if there are unused wrappers
+     * @param {string} errorUnusedMsg message to display if there are callback
+     * names that don't correspond to a registration
      */
-    done(msg = 'Unused wrappers') {
-      if (!unused.size) return;
-      console.warn(msg, ...[...unused.keys()].sort().map(q));
+    doneRegistering(errorUnusedMsg = `Unrecognized callback names:`) {
+      const cbNames = [...todo.keys()];
+      if (!cbNames.length) {
+        return;
+      }
+      console.warn(errorUnusedMsg, cbNames.map(q).sort().join(', '));
     },
   });
 }
 
-export const badConsole = makeLimitedConsole(level => () => {
-  throw Error(`unexpected use of badConsole.${level}`);
-});
-export const noopConsole = makeLimitedConsole(_level => () => {});
-
 /**
- * @param {SlogWrappers} slogCallbacks
- * @param {LimitedConsole} [dummyConsole]
+ * @param {*} slogCallbacks
+ * @param {Pick<Console, 'debug'|'log'|'info'|'warn'|'error'>} dummyConsole
  * @returns {KernelSlog}
  */
-export function makeDummySlogger(slogCallbacks, dummyConsole = badConsole) {
-  const { wrap, done } = makeFinishersKit(slogCallbacks);
+export function makeDummySlogger(slogCallbacks, dummyConsole) {
+  const { registerCallback: reg, doneRegistering } =
+    makeCallbackRegistry(slogCallbacks);
   const dummySlogger = harden({
-    provideVatSlogger: wrap('provideVatSlogger', () => {
-      return harden({ vatSlog: { delivery: () => noopFinisher } });
-    }),
-    vatConsole: wrap('vatConsole', () => dummyConsole),
-    startup: wrap('startup', () => noopFinisher),
-    replayVatTranscript: wrap('replayVatTranscript', () => noopFinisher),
-    delivery: wrap('delivery', () => noopFinisher),
-    syscall: wrap('syscall', () => noopFinisher),
-    changeCList: wrap('changeCList', () => noopFinisher),
-    terminateVat: wrap('terminateVat', () => noopFinisher),
-    write: noopFinisher,
+    provideVatSlogger: reg('provideVatSlogger', () =>
+      harden({
+        vatSlog: {
+          delivery: () => () => 0,
+        },
+      }),
+    ),
+    vatConsole: reg('vatConsole', () => dummyConsole),
+    startup: reg('startup', () => () => 0), // returns nop finish() function
+    replayVatTranscript: reg('replayVatTranscript', () => () => 0),
+    delivery: reg('delivery', () => () => 0),
+    syscall: reg('syscall', () => () => 0),
+    changeCList: reg('changeCList', () => () => 0),
+    terminateVat: reg('terminateVat', () => () => 0),
+    write: () => 0,
   });
-  done('Unused makeDummySlogger slogCallbacks method names');
+  doneRegistering(`Unrecognized makeDummySlogger slogCallbacks names:`);
+  // @ts-expect-error xxx
   return dummySlogger;
 }
 
 /**
- * @param {SlogWrappers} slogCallbacks
- * @param {(obj: object) => void} [writeObj]
+ * @param {*} slogCallbacks
+ * @param {*} writeObj
  * @returns {KernelSlog}
  */
 export function makeSlogger(slogCallbacks, writeObj) {
-  const safeWrite = writeObj
-    ? obj => {
-        try {
-          writeObj(obj);
-        } catch (err) {
-          console.error('WARNING: slogger write error', err);
-        }
-      }
-    : () => {};
+  const safeWrite = e => {
+    try {
+      writeObj(e);
+    } catch (err) {
+      console.error('WARNING: slogger write error', err);
+    }
+  };
+  const write = writeObj ? safeWrite : () => 0;
 
   const vatSlogs = new Map(); // vatID -> vatSlog
 
@@ -137,33 +130,36 @@ export function makeSlogger(slogCallbacks, writeObj) {
         console.error(
           `WARNING: slogger state confused: vat ${vatID} in ${state}, not ${exp}: ${msg}`,
         );
-        safeWrite({ type: 'slogger-confused', vatID, state, exp, msg });
+        write({ type: 'slogger-confused', vatID, state, exp, msg });
       }
     }
 
     function vatConsole(sourcedConsole) {
-      return makeLimitedConsole(level => (source, ...args) => {
-        // Don't duplicate stale output.
-        if (replay) return;
-
-        // Write to the console, then to the slog.
-        sourcedConsole[level](source, ...args);
-        // TODO: Just use "liveslots" rather than "ls"?
-        if (source === 'ls') source = 'liveslots';
-        const when = { state, crankNum, vatID, deliveryNum };
-        safeWrite({ type: 'console', source, ...when, level, args });
-      });
+      const vc = {};
+      for (const level of ['debug', 'log', 'info', 'warn', 'error']) {
+        vc[level] = (sourceTag, ...args) => {
+          if (replay) {
+            // Don't duplicate stale console output.
+            return;
+          }
+          sourcedConsole[level](sourceTag, ...args);
+          const when = { state, crankNum, vatID, deliveryNum };
+          const source = sourceTag === 'ls' ? 'liveslots' : sourceTag;
+          write({ type: 'console', source, ...when, level, args });
+        };
+      }
+      return harden(vc);
     }
 
     function startup() {
       // provide a context for console calls during startup
       checkOldState(IDLE, 'did startup get called twice?');
       state = STARTUP;
-      safeWrite({ type: 'vat-startup-start', vatID });
+      write({ type: 'vat-startup-start', vatID });
       function finish() {
         checkOldState(STARTUP, 'startup-finish called twice?');
         state = IDLE;
-        safeWrite({ type: 'vat-startup-finish', vatID });
+        write({ type: 'vat-startup-finish', vatID });
       }
       return harden(finish);
     }
@@ -176,13 +172,13 @@ export function makeSlogger(slogCallbacks, writeObj) {
       deliveryNum = newDeliveryNum;
       replay = inReplay;
       const when = { crankNum, vatID, deliveryNum, replay };
-      safeWrite({ type: 'deliver', ...when, kd, vd });
+      write({ type: 'deliver', ...when, kd, vd });
       syscallNum = 0;
 
       // dr: deliveryResult
       function finish(dr) {
         checkOldState(DELIVERY, 'delivery-finish called twice?');
-        safeWrite({ type: 'deliver-result', ...when, dr });
+        write({ type: 'deliver-result', ...when, dr });
         state = IDLE;
       }
       return harden(finish);
@@ -192,24 +188,24 @@ export function makeSlogger(slogCallbacks, writeObj) {
     function syscall(ksc, vsc) {
       checkOldState(DELIVERY, 'syscall invoked outside of delivery');
       const when = { crankNum, vatID, deliveryNum, syscallNum, replay };
-      safeWrite({ type: 'syscall', ...when, ksc, vsc });
+      write({ type: 'syscall', ...when, ksc, vsc });
       syscallNum += 1;
 
       // ksr: kernelSyscallResult, vsr: vatSyscallResult
       function finish(ksr, vsr) {
         checkOldState(DELIVERY, 'syscall finished after delivery?');
-        safeWrite({ type: 'syscall-result', ...when, ksr, vsr });
+        write({ type: 'syscall-result', ...when, ksr, vsr });
       }
       return harden(finish);
     }
 
     // mode: 'import' | 'export' | 'drop'
     function changeCList(crank, mode, kobj, vobj) {
-      safeWrite({ type: 'clist', crankNum: crank, mode, vatID, kobj, vobj });
+      write({ type: 'clist', crankNum: crank, mode, vatID, kobj, vobj });
     }
 
     function terminateVat(shouldReject, info) {
-      safeWrite({ type: 'terminate', vatID, shouldReject, info });
+      write({ type: 'terminate', vatID, shouldReject, info });
     }
 
     return harden({
@@ -237,7 +233,7 @@ export function makeSlogger(slogCallbacks, writeObj) {
     }
     const vatSlog = makeVatSlog(vatID);
     vatSlogs.set(vatID, vatSlog);
-    safeWrite({
+    write({
       type: 'create-vat',
       vatID,
       dynamic,
@@ -251,42 +247,43 @@ export function makeSlogger(slogCallbacks, writeObj) {
   }
 
   function replayVatTranscript(vatID) {
-    safeWrite({ type: 'replay-transcript-start', vatID });
+    write({ type: 'replay-transcript-start', vatID });
     function finish() {
-      safeWrite({ type: 'replay-transcript-finish', vatID });
+      write({ type: 'replay-transcript-finish', vatID });
     }
     return harden(finish);
   }
 
   // function annotateVat(vatID, data) {
-  //   safeWrite({ type: 'annotate-vat', vatID, data });
+  //   write({ type: 'annotate-vat', vatID, data });
   // }
 
-  const { wrap, done } = makeFinishersKit(slogCallbacks);
+  const { registerCallback: reg, doneRegistering } =
+    makeCallbackRegistry(slogCallbacks);
   const slogger = harden({
-    provideVatSlogger: wrap('provideVatSlogger', provideVatSlogger),
-    vatConsole: wrap('vatConsole', (vatID, ...args) =>
+    provideVatSlogger: reg('provideVatSlogger', provideVatSlogger),
+    vatConsole: reg('vatConsole', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.vatConsole(...args),
     ),
-    startup: wrap('startup', (vatID, ...args) =>
+    startup: reg('startup', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.startup(...args),
     ),
-    // TODO: Remove this seemingly dead code.
     replayVatTranscript,
-    delivery: wrap('delivery', (vatID, ...args) =>
+    delivery: reg('delivery', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.delivery(...args),
     ),
-    syscall: wrap('syscall', (vatID, ...args) =>
+    syscall: reg('syscall', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.syscall(...args),
     ),
-    changeCList: wrap('changeCList', (vatID, ...args) =>
+    changeCList: reg('changeCList', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.changeCList(...args),
     ),
-    terminateVat: wrap('terminateVat', (vatID, ...args) =>
+    terminateVat: reg('terminateVat', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.terminateVat(...args),
     ),
-    write: safeWrite,
+    write,
   });
-  done('Unused makeSlogger slogCallbacks method names');
+  doneRegistering(`Unrecognized makeSlogger slogCallbacks names:`);
+  // @ts-expect-error xxx
   return slogger;
 }

package/src/kernel/state/kernelKeeper.js

@@ -1,7 +1,5 @@
 import { Nat, isNat } from '@endo/nat';
 import { assert, Fail } from '@endo/errors';
-import { naturalCompare } from '@agoric/internal/src/natural-sort.js';
-import { makeDummySlogger, noopConsole } from '../slogger.js';
 import {
   initializeVatState,
   makeVatKeeper,
@@ -331,7 +329,7 @@ export const DEFAULT_GC_KREFS_PER_BOYD = 20;
 /**
  * @param {SwingStoreKernelStorage} kernelStorage
  * @param {number | 'uninitialized'} expectedVersion
- * @param {KernelSlog} [kernelSlog] optional only for expectedVersion 'uninitialized'
+ * @param {KernelSlog} [kernelSlog]
  */
 export default function makeKernelKeeper(
   kernelStorage,
@@ -357,13 +355,10 @@ export default function makeKernelKeeper(
     if (versionString) {
       throw Error(`kernel DB already initialized (v${versionString})`);
     }
-    kernelSlog ||= makeDummySlogger({}, noopConsole);
   } else if (expectedVersion !== version) {
     throw Error(
       `kernel DB is too old: has version v${version}, but expected v${expectedVersion}`,
     );
-  } else if (!kernelSlog) {
-    throw Error('kernelSlog is required for an already-initialized kernel DB');
   } else {
     // DB is up-to-date, so populate any caches we use
     terminatedVats = JSON.parse(getRequired('vats.terminated'));
@@ -1891,12 +1886,39 @@ export default function makeKernelKeeper(
       }
     }
 
-    // Perform an element-by-element natural sort.
+    function compareNumbers(a, b) {
+      return Number(a - b);
+    }
+
+    function compareStrings(a, b) {
+      // natural-sort strings having a shared prefix followed by digits
+      // (e.g., 'ko42' and 'ko100')
+      const [_a, aPrefix, aDigits] = /^(\D+)(\d+)$/.exec(a) || [];
+      if (aPrefix) {
+        const [_b, bPrefix, bDigits] = /^(\D+)(\d+)$/.exec(b) || [];
+        if (bPrefix === aPrefix) {
+          return compareNumbers(aDigits, bDigits);
+        }
+      }
+
+      // otherwise use the default string ordering
+      if (a > b) {
+        return 1;
+      }
+      if (a < b) {
+        return -1;
+      }
+      return 0;
+    }
+
     kernelTable.sort(
       (a, b) =>
-        naturalCompare(a[0], b[0]) ||
-        naturalCompare(a[1], b[1]) ||
-        naturalCompare(a[2], b[2]) ||
+        compareStrings(a[0], b[0]) ||
+        compareStrings(a[1], b[1]) ||
+        compareNumbers(a[2], b[2]) ||
+        compareStrings(a[3], b[3]) ||
+        compareNumbers(a[4], b[4]) ||
+        compareNumbers(a[5], b[5]) ||
         0,
     );
 
@@ -1909,7 +1931,7 @@ export default function makeKernelKeeper(
         promises.push({ id: kpid, ...getKernelPromise(kpid) });
       }
     }
-    promises.sort((a, b) => naturalCompare(a.id, b.id));
+    promises.sort((a, b) => compareStrings(a.id, b.id));
 
     const objects = [];
     const nextObjectID = Nat(BigInt(getRequired('ko.nextID')));

package/src/kernel/state/vatKeeper.js

@@ -86,7 +86,7 @@ export function initializeVatState(
 /**
  * @typedef {object} VatKeeperPowers
  * @property {TranscriptStore} transcriptStore  Accompanying transcript store, for the transcripts
- * @property {KernelSlog} kernelSlog
+ * @property {*} kernelSlog
  * @property {*} addKernelObject  Kernel function to add a new object to the kernel's mapping tables.
  * @property {*} addKernelPromiseForVat  Kernel function to add a new promise to the kernel's mapping tables.
  * @property {(kernelSlot: string) => boolean} kernelObjectExists
@@ -411,13 +411,15 @@ export function makeVatKeeper(
         // update any necessary refcounts consistently
         kvStore.set(kernelKey, buildReachableAndVatSlot(false, vatSlot));
         kvStore.set(vatKey, kernelSlot);
-        kernelSlog.changeCList(
-          vatID,
-          getCrankNumber(),
-          'export',
-          kernelSlot,
-          vatSlot,
-        );
+        if (kernelSlog) {
+          kernelSlog.changeCList(
+            vatID,
+            getCrankNumber(),
+            'export',
+            kernelSlot,
+            vatSlot,
+          );
+        }
         kdebug(`Add mapping v->k ${kernelKey}<=>${vatKey}`);
       } else {
         // the vat didn't allocate it, and the kernel didn't allocate it
@@ -484,13 +486,15 @@ export function makeVatKeeper(
       incStat('clistEntries');
       kvStore.set(vatKey, kernelSlot);
       kvStore.set(kernelKey, buildReachableAndVatSlot(false, vatSlot));
-      kernelSlog.changeCList(
-        vatID,
-        getCrankNumber(),
-        'import',
-        kernelSlot,
-        vatSlot,
-      );
+      if (kernelSlog) {
+        kernelSlog.changeCList(
+          vatID,
+          getCrankNumber(),
+          'import',
+          kernelSlot,
+          vatSlot,
+        );
+      }
       kdebug(`Add mapping k->v ${kernelKey}<=>${vatKey}`);
     }
 
@@ -533,13 +537,15 @@ export function makeVatKeeper(
     const vatKey = `${vatID}.c.${vatSlot}`;
     assert(kvStore.has(kernelKey));
     kdebug(`Delete mapping ${kernelKey}<=>${vatKey}`);
-    kernelSlog.changeCList(
-      vatID,
-      getCrankNumber(),
-      'drop',
-      kernelSlot,
-      vatSlot,
-    );
+    if (kernelSlog) {
+      kernelSlog.changeCList(
+        vatID,
+        getCrankNumber(),
+        'drop',
+        kernelSlot,
+        vatSlot,
+      );
+    }
     const isExport = allocatedByVat;
     // We tolerate the object kref not being present in the kernel object
     // table, either because we're being called during the translation of
@@ -671,7 +677,13 @@ export function makeVatKeeper(
       restartWorker,
     );
 
-    const { hash: snapshotID } = info;
+    const {
+      hash: snapshotID,
+      uncompressedSize,
+      dbSaveSeconds,
+      compressedSize,
+      compressSeconds,
+    } = info;
 
     // push a save-snapshot transcript entry
     addToTranscript(makeSaveSnapshotItem(snapshotID));
@@ -683,6 +695,18 @@ export function makeVatKeeper(
     // always starts with an initialize-worker or load-snapshot
     // pseudo-delivery
     addToTranscript(makeLoadSnapshotItem(snapshotID));
+
+    kernelSlog.write({
+      type: 'heap-snapshot-save',
+      vatID,
+      snapshotID,
+      uncompressedSize,
+      dbSaveSeconds,
+      compressedSize,
+      compressSeconds,
+      endPosition,
+      restartWorker,
+    });
   }
 
   /**

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