@agoric/swingset-vat 0.32.3-upgrade-18-dev-6ddbef0.0 → 0.32.3-upgrade-19-dev-c605745.0

package/src/controller/upgradeSwingset.js

@@ -10,13 +10,38 @@ import {
 import { enumeratePrefixedKeys } from '../kernel/state/storageHelper.js';
 
 /**
- * @import {RunQueueEvent} from '../types-internal.js';
+ * @import {ReapDirtThreshold, RunQueueEvent} from '../types-internal.js';
  */
 
-const upgradeVatV0toV1 = (kvStore, defaultReapDirtThreshold, vatID) => {
-  // This is called, once per vat, when upgradeSwingset migrates from
-  // v0 to v1
+/**
+ * Parse a string of decimal digits into a number.
+ *
+ * @param {string} digits
+ * @param {string} label
+ * @returns {number}
+ */
+const mustParseInt = (digits, label) => {
+  assert(
+    digits.match(/^\d+$/),
+    `expected ${label}=${digits} to be a decimal integer`,
+  );
+  return Number(digits);
+};
 
+/**
+ * Called for each vat when upgradeSwingset migrates from v0 to v1.
+ *
+ * @param {KVStore} kvStore
+ * @param {(key: string) => string} getRequired
+ * @param {ReapDirtThreshold} defaultReapDirtThreshold
+ * @param {string} vatID
+ */
+const upgradeVatV0toV1 = (
+  kvStore,
+  getRequired,
+  defaultReapDirtThreshold,
+  vatID,
+) => {
   // schema v0:
   // Each vat has a `vNN.reapInterval` and `vNN.reapCountdown`.
   // vNN.options has a `.reapInterval` property (however it was not
@@ -33,15 +58,10 @@ const upgradeVatV0toV1 = (kvStore, defaultReapDirtThreshold, vatID) => {
   // `defaultReapDirtThreshold`)
 
   const reapDirtKey = `${vatID}.reapDirt`;
-
-  assert(kvStore.has(oldReapIntervalKey), oldReapIntervalKey);
-  assert(kvStore.has(oldReapCountdownKey), oldReapCountdownKey);
   assert(!kvStore.has(reapDirtKey), reapDirtKey);
 
-  const reapIntervalString = kvStore.get(oldReapIntervalKey);
-  const reapCountdownString = kvStore.get(oldReapCountdownKey);
-  assert(reapIntervalString !== undefined);
-  assert(reapCountdownString !== undefined);
+  const reapIntervalString = getRequired(oldReapIntervalKey);
+  const reapCountdownString = getRequired(oldReapCountdownKey);
 
   const intervalIsNever = reapIntervalString === 'never';
   const countdownIsNever = reapCountdownString === 'never';
@@ -62,8 +82,11 @@ const upgradeVatV0toV1 = (kvStore, defaultReapDirtThreshold, vatID) => {
     threshold.never = true;
   } else {
     // deduce delivery count from old countdown values
-    const reapInterval = Number.parseInt(reapIntervalString, 10);
-    const reapCountdown = Number.parseInt(reapCountdownString, 10);
+    const reapInterval = mustParseInt(reapIntervalString, oldReapIntervalKey);
+    const reapCountdown = mustParseInt(
+      reapCountdownString,
+      oldReapCountdownKey,
+    );
     const deliveries = reapInterval - reapCountdown;
     reapDirt.deliveries = Math.max(deliveries, 0); // just in case
     if (reapInterval !== defaultReapDirtThreshold.deliveries) {
@@ -76,7 +99,7 @@ const upgradeVatV0toV1 = (kvStore, defaultReapDirtThreshold, vatID) => {
   kvStore.set(reapDirtKey, JSON.stringify(reapDirt));
 
   // Update options to use the new schema.
-  const options = JSON.parse(kvStore.get(vatOptionsKey));
+  const options = JSON.parse(getRequired(vatOptionsKey));
   delete options.reapInterval;
   options.reapDirtThreshold = threshold;
   kvStore.set(vatOptionsKey, JSON.stringify(options));
@@ -104,14 +127,11 @@ const upgradeVatV0toV1 = (kvStore, defaultReapDirtThreshold, vatID) => {
  */
 export const upgradeSwingset = kernelStorage => {
   const { kvStore } = kernelStorage;
-  let modified = false;
   /** @type {RunQueueEvent[]} */
   const upgradeEvents = [];
-  let vstring = kvStore.get('version');
-  if (vstring === undefined) {
-    vstring = '0';
-  }
-  let version = Number(vstring);
+  const vstring = kvStore.get('version');
+  const version = Number(vstring) || 0;
+  let newVersion;
 
   /**
    * @param {string} key
@@ -166,11 +186,7 @@ export const upgradeSwingset = kernelStorage => {
     assert(kvStore.has(oldDefaultReapIntervalKey));
     assert(!kvStore.has(DEFAULT_REAP_DIRT_THRESHOLD_KEY));
 
-    /**
-     * @typedef { import('../types-internal.js').ReapDirtThreshold } ReapDirtThreshold
-     */
-
-    /** @type ReapDirtThreshold */
+    /** @type {ReapDirtThreshold} */
     const threshold = {
       deliveries: 'never',
       gcKrefs: 'never',
@@ -179,9 +195,7 @@ export const upgradeSwingset = kernelStorage => {
 
     const oldValue = getRequired(oldDefaultReapIntervalKey);
     if (oldValue !== 'never') {
-      const value = Number.parseInt(oldValue, 10);
-      assert.typeof(value, 'number');
-      threshold.deliveries = value;
+      threshold.deliveries = mustParseInt(oldValue, oldDefaultReapIntervalKey);
       // if BOYD wasn't turned off entirely (eg
       // defaultReapInterval='never', which only happens in unit
       // tests), then pretend we wanted a gcKrefs= threshold all
@@ -196,22 +210,20 @@ export const upgradeSwingset = kernelStorage => {
 
     // now upgrade all vats
     for (const [_name, vatID] of getAllStaticVats(kvStore)) {
-      upgradeVatV0toV1(kvStore, threshold, vatID);
+      upgradeVatV0toV1(kvStore, getRequired, threshold, vatID);
     }
     for (const vatID of getAllDynamicVats(getRequired)) {
-      upgradeVatV0toV1(kvStore, threshold, vatID);
+      upgradeVatV0toV1(kvStore, getRequired, threshold, vatID);
     }
 
-    modified = true;
-    version = 1;
+    newVersion = 1;
   }
 
   if (version < 2) {
     // schema v2: add vats.terminated = []
     assert(!kvStore.has('vats.terminated'));
     kvStore.set('vats.terminated', JSON.stringify([]));
-    modified = true;
-    version = 2;
+    newVersion = 2;
   }
 
   if (version < 3) {
@@ -322,10 +334,11 @@ export const upgradeSwingset = kernelStorage => {
     }
 
     console.log(` - #9039 remediation complete, ${count} notifies to inject`);
-    modified = true;
-    version = 3;
+    newVersion = 3;
   }
 
+  const modified = newVersion !== undefined;
+
   if (upgradeEvents.length) {
     assert(modified);
     // stash until host calls controller.injectQueuedUpgradeEvents()
@@ -335,7 +348,7 @@ export const upgradeSwingset = kernelStorage => {
   }
 
   if (modified) {
-    kvStore.set('version', `${version}`);
+    kvStore.set('version', `${newVersion}`);
   }
   return harden({ modified });
 };

package/src/devices/bridge/device-bridge.js

@@ -1,5 +1,6 @@
 import { Fail } from '@endo/errors';
 import { Far } from '@endo/far';
+import { deepCopyJsonable } from '@agoric/internal/src/js-utils.js';
 
 function sanitize(data) {
   if (data === undefined) {
@@ -8,7 +9,7 @@ function sanitize(data) {
   if (data instanceof Error) {
     data = data.stack;
   }
-  return JSON.parse(JSON.stringify(data));
+  return deepCopyJsonable(data);
 }
 
 /**
@@ -32,7 +33,7 @@ export function buildRootDeviceNode(tools) {
 
   function inboundCallback(...args) {
     inboundHandler || Fail`inboundHandler not yet registered`;
-    const safeArgs = JSON.parse(JSON.stringify(args));
+    const safeArgs = deepCopyJsonable(args);
     try {
       SO(inboundHandler).inbound(...harden(safeArgs));
     } catch (e) {

package/src/devices/lib/deviceTools.js

@@ -24,7 +24,6 @@ export function buildSerializationTools(syscall, deviceName) {
       send(method, args) {
         assert.typeof(method, 'string');
         assert(Array.isArray(args), args);
-        // eslint-disable-next-line no-use-before-define
         const capdata = serialize([method, args]);
         syscall.sendOnly(slot, capdata);
       },

package/src/index.js

@@ -8,6 +8,7 @@ export {
   buildKernelBundles,
   loadBasedir,
   loadSwingsetConfigFile,
+  normalizeConfig,
 } from './controller/initializeSwingset.js';
 export { upgradeSwingset } from './controller/upgradeSwingset.js';
 export {

package/src/kernel/kernel.js

@@ -9,7 +9,7 @@ import { makeUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
 import { kser, kslot, makeError } from '@agoric/kmarshal';
 import { assertKnownOptions } from '../lib/assertOptions.js';
 import { foreverPolicy } from '../lib/runPolicies.js';
-import { makeVatManagerFactory } from './vat-loader/manager-factory.js';
+import { makeVatManagerMaker } from './vat-loader/manager-factory.js';
 import { makeVatWarehouse } from './vat-warehouse.js';
 import makeDeviceManager from './deviceManager.js';
 import makeKernelKeeper, {
@@ -110,11 +110,10 @@ export default function buildKernel(
     warehousePolicy,
     overrideVatManagerOptions = {},
   } = kernelRuntimeOptions;
-  const logStartup = verbose ? console.debug : () => 0;
+  const logStartup = verbose ? console.debug : () => {};
 
   const vatAdminRootKref = kernelStorage.kvStore.get('vatAdminRootKref');
 
-  /** @type { KernelSlog } */
   const kernelSlog = writeSlogObject
     ? makeSlogger(slogCallbacks, writeSlogObject)
     : makeDummySlogger(slogCallbacks, makeConsole('disabled slogger'));
@@ -167,10 +166,9 @@ export default function buildKernel(
   harden(testLog);
 
   function makeSourcedConsole(vatID) {
-    const origConsole = makeConsole(args => {
-      const source = args.shift();
-      return `${debugPrefix}SwingSet:${source}:${vatID}`;
-    });
+    const origConsole = makeConsole(
+      source => `${debugPrefix}SwingSet:${source}:${vatID}`,
+    );
     return kernelSlog.vatConsole(vatID, origConsole);
   }
 
@@ -1128,7 +1126,6 @@ export default function buildKernel(
     } else if (message.type === 'changeVatOptions') {
       // prettier-ignore
       return `changeVatOptions ${message.vatID} options: ${JSON.stringify(message.options)}`;
-      // eslint-disable-next-line no-use-before-define
     } else if (gcMessages.includes(message.type)) {
       // prettier-ignore
       return `${message.type} ${message.vatID} ${message.krefs.map(e=>`@${e}`).join(' ')}`;
@@ -1558,7 +1555,7 @@ export default function buildKernel(
     gcAndFinalize,
     meterControl: makeDummyMeterControl(),
   });
-  const vatManagerFactory = makeVatManagerFactory({
+  const makeVatManager = makeVatManagerMaker({
     allVatPowers,
     kernelKeeper,
     vatEndowments,
@@ -1653,7 +1650,7 @@ export default function buildKernel(
   }
 
   const vatLoader = makeVatLoader({
-    vatManagerFactory,
+    makeVatManager,
     kernelSlog,
     makeSourcedConsole,
     kernelKeeper,

package/src/kernel/slogger.js

@@ -1,120 +1,127 @@
 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';
 
-function makeCallbackRegistry(callbacks) {
-  const todo = new Set(Object.keys(callbacks));
+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));
   return harden({
     /**
-     * Robustly wrap a method with a callbacks[method] function, if defined.  We
-     * incur no runtime overhead if the given callback method isn't defined.
+     * Robustly wrap a method if a wrapper is defined.
      *
-     * @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
+     * @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
      */
-    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;
-      }
+    wrap(method, impl) {
+      unused.delete(method);
+      const wrapper = wrappers[method];
+
+      // If there is no registered wrapper, return the implementation directly.
+      if (!wrapper) return impl;
 
-      return (...args) => {
-        // Invoke the implementation first.
-        const ret = impl(...args);
+      const wrapped = (...args) => {
+        const maybeFinisher = /** @type {Finisher} */ (impl(...args));
         try {
-          // 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;
+          // 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);
+            }
+          };
         } catch (e) {
-          console.error('failed to call registered', method, 'callback:', e);
+          console.error(`${method} wrapper failed:`, e);
+          return maybeFinisher;
         }
-        return ret;
       };
+      return /** @type {F} */ (wrapped);
     },
     /**
-     * Declare that all the methods have been registered.
+     * Declare that all wrapping is done.
      *
-     * @param {string} errorUnusedMsg message to display if there are callback
-     * names that don't correspond to a registration
+     * @param {string} msg message to display if there are unused wrappers
      */
-    doneRegistering(errorUnusedMsg = `Unrecognized callback names:`) {
-      const cbNames = [...todo.keys()];
-      if (!cbNames.length) {
-        return;
-      }
-      console.warn(errorUnusedMsg, cbNames.map(q).sort().join(', '));
+    done(msg = 'Unused wrappers') {
+      if (!unused.size) return;
+      console.warn(msg, ...[...unused.keys()].sort().map(q));
     },
   });
 }
 
+export const badConsole = makeLimitedConsole(level => () => {
+  throw Error(`unexpected use of badConsole.${level}`);
+});
+export const noopConsole = makeLimitedConsole(_level => () => {});
+
 /**
- * @param {*} slogCallbacks
- * @param {Pick<Console, 'debug'|'log'|'info'|'warn'|'error'>} dummyConsole
+ * @param {SlogWrappers} slogCallbacks
+ * @param {LimitedConsole} [dummyConsole]
  * @returns {KernelSlog}
  */
-export function makeDummySlogger(slogCallbacks, dummyConsole) {
-  const { registerCallback: reg, doneRegistering } =
-    makeCallbackRegistry(slogCallbacks);
+export function makeDummySlogger(slogCallbacks, dummyConsole = badConsole) {
+  const { wrap, done } = makeFinishersKit(slogCallbacks);
   const dummySlogger = harden({
-    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,
+    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,
   });
-  doneRegistering(`Unrecognized makeDummySlogger slogCallbacks names:`);
-  // @ts-expect-error xxx
+  done('Unused makeDummySlogger slogCallbacks method names');
   return dummySlogger;
 }
 
 /**
- * @param {*} slogCallbacks
- * @param {*} writeObj
+ * @param {SlogWrappers} slogCallbacks
+ * @param {(obj: object) => void} [writeObj]
  * @returns {KernelSlog}
  */
 export function makeSlogger(slogCallbacks, writeObj) {
-  const safeWrite = e => {
-    try {
-      writeObj(e);
-    } catch (err) {
-      console.error('WARNING: slogger write error', err);
-    }
-  };
-  const write = writeObj ? safeWrite : () => 0;
+  const safeWrite = writeObj
+    ? obj => {
+        try {
+          writeObj(obj);
+        } catch (err) {
+          console.error('WARNING: slogger write error', err);
+        }
+      }
+    : () => {};
 
   const vatSlogs = new Map(); // vatID -> vatSlog
 
@@ -130,36 +137,33 @@ export function makeSlogger(slogCallbacks, writeObj) {
         console.error(
           `WARNING: slogger state confused: vat ${vatID} in ${state}, not ${exp}: ${msg}`,
         );
-        write({ type: 'slogger-confused', vatID, state, exp, msg });
+        safeWrite({ type: 'slogger-confused', vatID, state, exp, msg });
       }
     }
 
     function vatConsole(sourcedConsole) {
-      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);
+      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 });
+      });
     }
 
     function startup() {
       // provide a context for console calls during startup
       checkOldState(IDLE, 'did startup get called twice?');
       state = STARTUP;
-      write({ type: 'vat-startup-start', vatID });
+      safeWrite({ type: 'vat-startup-start', vatID });
       function finish() {
         checkOldState(STARTUP, 'startup-finish called twice?');
         state = IDLE;
-        write({ type: 'vat-startup-finish', vatID });
+        safeWrite({ type: 'vat-startup-finish', vatID });
       }
       return harden(finish);
     }
@@ -172,13 +176,13 @@ export function makeSlogger(slogCallbacks, writeObj) {
       deliveryNum = newDeliveryNum;
       replay = inReplay;
       const when = { crankNum, vatID, deliveryNum, replay };
-      write({ type: 'deliver', ...when, kd, vd });
+      safeWrite({ type: 'deliver', ...when, kd, vd });
       syscallNum = 0;
 
       // dr: deliveryResult
       function finish(dr) {
         checkOldState(DELIVERY, 'delivery-finish called twice?');
-        write({ type: 'deliver-result', ...when, dr });
+        safeWrite({ type: 'deliver-result', ...when, dr });
         state = IDLE;
       }
       return harden(finish);
@@ -188,24 +192,24 @@ export function makeSlogger(slogCallbacks, writeObj) {
     function syscall(ksc, vsc) {
       checkOldState(DELIVERY, 'syscall invoked outside of delivery');
       const when = { crankNum, vatID, deliveryNum, syscallNum, replay };
-      write({ type: 'syscall', ...when, ksc, vsc });
+      safeWrite({ type: 'syscall', ...when, ksc, vsc });
       syscallNum += 1;
 
       // ksr: kernelSyscallResult, vsr: vatSyscallResult
       function finish(ksr, vsr) {
         checkOldState(DELIVERY, 'syscall finished after delivery?');
-        write({ type: 'syscall-result', ...when, ksr, vsr });
+        safeWrite({ type: 'syscall-result', ...when, ksr, vsr });
       }
       return harden(finish);
     }
 
     // mode: 'import' | 'export' | 'drop'
     function changeCList(crank, mode, kobj, vobj) {
-      write({ type: 'clist', crankNum: crank, mode, vatID, kobj, vobj });
+      safeWrite({ type: 'clist', crankNum: crank, mode, vatID, kobj, vobj });
     }
 
     function terminateVat(shouldReject, info) {
-      write({ type: 'terminate', vatID, shouldReject, info });
+      safeWrite({ type: 'terminate', vatID, shouldReject, info });
     }
 
     return harden({
@@ -233,7 +237,7 @@ export function makeSlogger(slogCallbacks, writeObj) {
     }
     const vatSlog = makeVatSlog(vatID);
     vatSlogs.set(vatID, vatSlog);
-    write({
+    safeWrite({
       type: 'create-vat',
       vatID,
       dynamic,
@@ -247,43 +251,42 @@ export function makeSlogger(slogCallbacks, writeObj) {
   }
 
   function replayVatTranscript(vatID) {
-    write({ type: 'replay-transcript-start', vatID });
+    safeWrite({ type: 'replay-transcript-start', vatID });
     function finish() {
-      write({ type: 'replay-transcript-finish', vatID });
+      safeWrite({ type: 'replay-transcript-finish', vatID });
     }
     return harden(finish);
   }
 
   // function annotateVat(vatID, data) {
-  //   write({ type: 'annotate-vat', vatID, data });
+  //   safeWrite({ type: 'annotate-vat', vatID, data });
   // }
 
-  const { registerCallback: reg, doneRegistering } =
-    makeCallbackRegistry(slogCallbacks);
+  const { wrap, done } = makeFinishersKit(slogCallbacks);
   const slogger = harden({
-    provideVatSlogger: reg('provideVatSlogger', provideVatSlogger),
-    vatConsole: reg('vatConsole', (vatID, ...args) =>
+    provideVatSlogger: wrap('provideVatSlogger', provideVatSlogger),
+    vatConsole: wrap('vatConsole', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.vatConsole(...args),
     ),
-    startup: reg('startup', (vatID, ...args) =>
+    startup: wrap('startup', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.startup(...args),
     ),
+    // TODO: Remove this seemingly dead code.
     replayVatTranscript,
-    delivery: reg('delivery', (vatID, ...args) =>
+    delivery: wrap('delivery', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.delivery(...args),
     ),
-    syscall: reg('syscall', (vatID, ...args) =>
+    syscall: wrap('syscall', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.syscall(...args),
     ),
-    changeCList: reg('changeCList', (vatID, ...args) =>
+    changeCList: wrap('changeCList', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.changeCList(...args),
     ),
-    terminateVat: reg('terminateVat', (vatID, ...args) =>
+    terminateVat: wrap('terminateVat', (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.terminateVat(...args),
     ),
-    write,
+    write: safeWrite,
   });
-  doneRegistering(`Unrecognized makeSlogger slogCallbacks names:`);
-  // @ts-expect-error xxx
+  done('Unused makeSlogger slogCallbacks method names');
   return slogger;
 }