@agoric/swingset-vat 0.32.3-dev-dc77e16.0 → 0.32.3-dev-c605745.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/swingset-vat",
-  "version": "0.32.3-dev-dc77e16.0+dc77e16",
+  "version": "0.32.3-dev-c605745.0+c605745",
   "description": "Vat/Container Launcher",
   "type": "module",
   "main": "src/index.js",
@@ -27,15 +27,15 @@
     "@types/yargs-parser": "^21.0.0"
   },
   "dependencies": {
-    "@agoric/internal": "0.3.3-dev-dc77e16.0+dc77e16",
-    "@agoric/kmarshal": "0.1.1-dev-dc77e16.0+dc77e16",
-    "@agoric/store": "0.9.3-dev-dc77e16.0+dc77e16",
-    "@agoric/swing-store": "0.9.2-dev-dc77e16.0+dc77e16",
-    "@agoric/swingset-liveslots": "0.10.3-dev-dc77e16.0+dc77e16",
-    "@agoric/swingset-xsnap-supervisor": "0.10.3-dev-dc77e16.0+dc77e16",
-    "@agoric/time": "0.3.3-dev-dc77e16.0+dc77e16",
-    "@agoric/vat-data": "0.5.3-dev-dc77e16.0+dc77e16",
-    "@agoric/xsnap-lockdown": "0.14.1-dev-dc77e16.0+dc77e16",
+    "@agoric/internal": "0.3.3-dev-c605745.0+c605745",
+    "@agoric/kmarshal": "0.1.1-dev-c605745.0+c605745",
+    "@agoric/store": "0.9.3-dev-c605745.0+c605745",
+    "@agoric/swing-store": "0.9.2-dev-c605745.0+c605745",
+    "@agoric/swingset-liveslots": "0.10.3-dev-c605745.0+c605745",
+    "@agoric/swingset-xsnap-supervisor": "0.10.3-dev-c605745.0+c605745",
+    "@agoric/time": "0.3.3-dev-c605745.0+c605745",
+    "@agoric/vat-data": "0.5.3-dev-c605745.0+c605745",
+    "@agoric/xsnap-lockdown": "0.14.1-dev-c605745.0+c605745",
     "@endo/base64": "^1.0.9",
     "@endo/bundle-source": "^3.5.1",
     "@endo/captp": "^4.4.4",
@@ -102,5 +102,5 @@
   "typeCoverage": {
     "atLeast": 76.28
   },
-  "gitHead": "dc77e169321b8c2cf4d6c81699dbe7cc4cba0177"
+  "gitHead": "c605745ee6619292b51cec5fc0db0a25ff1b203c"
 }

package/src/controller/controller.js

@@ -16,6 +16,7 @@ import { initSwingStore } from '@agoric/swing-store';
 import { mustMatch, M } from '@endo/patterns';
 import { checkBundle } from '@endo/check-bundle/lite.js';
 import { deepCopyJsonable } from '@agoric/internal/src/js-utils.js';
+import { makeLimitedConsole } from '@agoric/internal/src/ses-utils.js';
 import engineGC from '@agoric/internal/src/lib-nodejs/engine-gc.js';
 import { startSubprocessWorker } from '@agoric/internal/src/lib-nodejs/spawnSubprocessWorker.js';
 import { waitUntilQuiescent } from '@agoric/internal/src/lib-nodejs/waitUntilQuiescent.js';
@@ -56,34 +57,32 @@ export function computeSha512(bytes) {
   return hash.digest().toString('hex');
 }
 
-/** @param {string | ((args: unknown[]) => string)} tagOrTagCreator */
-function makeConsole(tagOrTagCreator) {
-  /** @type {(level: string) => (args: unknown[]) => void} */
-  let makeLoggerForLevel;
-  if (typeof tagOrTagCreator === 'function') {
-    const tagToLogger = new Map();
-    makeLoggerForLevel =
-      level =>
-      (...args) => {
-        // Retrieve the logger from cache.
-        const tag = tagOrTagCreator(args);
-        let logger = tagToLogger.get(tag);
-        if (!logger) {
-          logger = anylogger(tag);
-          tagToLogger.set(tag, logger);
-        }
-        // Actually log the message.
-        return logger[level](...args);
-      };
-  } else {
-    const logger = anylogger(tagOrTagCreator);
-    makeLoggerForLevel = level => logger[level];
-  }
-  const cons = {};
-  for (const level of ['debug', 'log', 'info', 'warn', 'error']) {
-    cons[level] = makeLoggerForLevel(level);
+/**
+ * Make logger functions from either a prefix string or a function that receives
+ * the first argument of a log-method invocation and returns a replacement that
+ * provides more detail for source identification.
+ *
+ * @param {string | ((originalSource: unknown) => string)} prefixer
+ */
+function makeConsole(prefixer) {
+  if (typeof prefixer !== 'function') {
+    const logger = anylogger(prefixer);
+    return makeLimitedConsole(level => logger[level]);
   }
-  return harden(cons);
+
+  const prefixToLogger = new Map();
+  return makeLimitedConsole(level => {
+    return (source, ...args) => {
+      const prefix = prefixer(source);
+      let logger = prefixToLogger.get(prefix);
+      if (!logger) {
+        logger = anylogger(prefix);
+        prefixToLogger.set(prefix, logger);
+      }
+
+      return logger[level](...args);
+    };
+  });
 }
 
 /**
@@ -213,17 +212,23 @@ export async function makeSwingsetController(
     process.on('unhandledRejection', unhandledRejectionHandler);
   }
 
-  function kernelRequire(what) {
-    Fail`kernelRequire unprepared to satisfy require(${what})`;
-  }
+  const kernelConsole = makeConsole(`${debugPrefix}SwingSet:kernel`);
+  const sloggingKernelConsole = makeLimitedConsole(level => {
+    return (...args) => {
+      kernelConsole[level](...args);
+      writeSlogObject({ type: 'console', source: 'kernel', args });
+    };
+  });
   writeSlogObject({ type: 'import-kernel-start' });
   const kernelNS = await importBundle(kernelBundle, {
     filePrefix: 'kernel/...',
     endowments: {
-      console: makeConsole(`${debugPrefix}SwingSet:kernel`),
+      console: sloggingKernelConsole,
       // See https://github.com/Agoric/agoric-sdk/issues/9515
       assert: globalThis.assert,
-      require: kernelRequire,
+      require: harden(
+        what => Fail`kernelRequire unprepared to satisfy require(${what})`,
+      ),
       URL: globalThis.Base64, // Unavailable only on XSnap
       Base64: globalThis.Base64, // Available only on XSnap
     },

package/src/kernel/kernel.js

@@ -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);
   }
 

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;
 }

package/src/kernel/state/kernelKeeper.js

@@ -1,6 +1,7 @@
 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,
@@ -330,7 +331,7 @@ export const DEFAULT_GC_KREFS_PER_BOYD = 20;
 /**
  * @param {SwingStoreKernelStorage} kernelStorage
  * @param {number | 'uninitialized'} expectedVersion
- * @param {KernelSlog} [kernelSlog]
+ * @param {KernelSlog} [kernelSlog] optional only for expectedVersion 'uninitialized'
  */
 export default function makeKernelKeeper(
   kernelStorage,
@@ -356,10 +357,13 @@ 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'));

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
+ * @property {KernelSlog} 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,15 +411,13 @@ export function makeVatKeeper(
         // update any necessary refcounts consistently
         kvStore.set(kernelKey, buildReachableAndVatSlot(false, vatSlot));
         kvStore.set(vatKey, kernelSlot);
-        if (kernelSlog) {
-          kernelSlog.changeCList(
-            vatID,
-            getCrankNumber(),
-            'export',
-            kernelSlot,
-            vatSlot,
-          );
-        }
+        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
@@ -486,15 +484,13 @@ export function makeVatKeeper(
       incStat('clistEntries');
       kvStore.set(vatKey, kernelSlot);
       kvStore.set(kernelKey, buildReachableAndVatSlot(false, vatSlot));
-      if (kernelSlog) {
-        kernelSlog.changeCList(
-          vatID,
-          getCrankNumber(),
-          'import',
-          kernelSlot,
-          vatSlot,
-        );
-      }
+      kernelSlog.changeCList(
+        vatID,
+        getCrankNumber(),
+        'import',
+        kernelSlot,
+        vatSlot,
+      );
       kdebug(`Add mapping k->v ${kernelKey}<=>${vatKey}`);
     }
 
@@ -537,15 +533,13 @@ export function makeVatKeeper(
     const vatKey = `${vatID}.c.${vatSlot}`;
     assert(kvStore.has(kernelKey));
     kdebug(`Delete mapping ${kernelKey}<=>${vatKey}`);
-    if (kernelSlog) {
-      kernelSlog.changeCList(
-        vatID,
-        getCrankNumber(),
-        'drop',
-        kernelSlot,
-        vatSlot,
-      );
-    }
+    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

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 {{

package/src/types-internal.js

@@ -111,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