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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/swingset-vat",
-  "version": "0.33.0-u19.0",
+  "version": "0.33.0-u19.1",
   "description": "Vat/Container Launcher",
   "type": "module",
   "main": "src/index.js",
@@ -27,14 +27,14 @@
     "@types/yargs-parser": "^21.0.0"
   },
   "dependencies": {
-    "@agoric/internal": "^0.4.0-u19.0",
+    "@agoric/internal": "^0.4.0-u19.1",
     "@agoric/kmarshal": "^0.1.1-u19.0",
     "@agoric/store": "^0.9.3-u19.0",
-    "@agoric/swing-store": "^0.10.0-u19.0",
-    "@agoric/swingset-liveslots": "^0.10.3-u19.0",
+    "@agoric/swing-store": "^0.10.0-u19.1",
+    "@agoric/swingset-liveslots": "^0.10.3-u19.1",
     "@agoric/swingset-xsnap-supervisor": "^0.10.3-u19.0",
     "@agoric/time": "^0.3.3-u19.0",
-    "@agoric/vat-data": "^0.5.3-u19.0",
+    "@agoric/vat-data": "^0.5.3-u19.1",
     "@agoric/xsnap-lockdown": "^0.14.1-u19.0",
     "@endo/base64": "^1.0.9",
     "@endo/bundle-source": "^3.5.1",
@@ -102,5 +102,5 @@
   "typeCoverage": {
     "atLeast": 76.28
   },
-  "gitHead": "29e9704c375a06bb617027093b30d2d25faa6471"
+  "gitHead": "a04d2bf43a9753d123954b52c6ba8d35083a3c8f"
 }

package/src/controller/controller.js

@@ -216,7 +216,7 @@ export async function makeSwingsetController(
   const sloggingKernelConsole = makeLimitedConsole(level => {
     return (...args) => {
       kernelConsole[level](...args);
-      writeSlogObject({ type: 'console', source: 'kernel', args });
+      writeSlogObject({ type: 'console', source: 'kernel', level, args });
     };
   });
   writeSlogObject({ type: 'import-kernel-start' });

package/src/kernel/slogger.js

@@ -1,6 +1,8 @@
 import { q } from '@endo/errors';
+import { objectMap } from '@agoric/internal';
 import { makeLimitedConsole } from '@agoric/internal/src/ses-utils.js';
 
+/** @import {Callable} from '@agoric/internal'; */
 /** @import {LimitedConsole} from '@agoric/internal/src/js-utils.js'; */
 
 const IDLE = 'idle';
@@ -13,7 +15,7 @@ const noopFinisher = harden(() => {});
 /** @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
+ * Support asynchronous slog 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
@@ -21,61 +23,54 @@ const noopFinisher = harden(() => {});
  * (e.g., its finisher), and are expected to return a finisher of their own that
  * will invoke that wrapped finisher.
  *
- * @param {SlogWrappers} wrappers
+ * @template {Record<string, Callable>} Methods
+ * @param {SlogWrappers} slogCallbacks
+ * @param {string} unusedMsgPrefix prefix for warn-level logging about unused callbacks
+ * @param {Methods} methods to wrap
+ * @returns {Methods}
  */
-function makeFinishersKit(wrappers) {
-  const unused = new Set(Object.keys(wrappers));
-  return harden({
-    /**
-     * Robustly wrap a method if a wrapper is 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
-     */
-    wrap(method, impl) {
-      unused.delete(method);
-      const wrapper = wrappers[method];
+function addSlogCallbacks(slogCallbacks, unusedMsgPrefix, methods) {
+  const unused = new Set(Object.keys(slogCallbacks));
+  const wrappedMethods = /** @type {Methods} */ (
+    objectMap(methods, (impl, methodKey) => {
+      const methodName = /** @type {keyof typeof slogCallbacks} */ (methodKey);
+      unused.delete(methodName);
+      const wrapper = slogCallbacks[methodName];
 
       // If there is no registered wrapper, return the implementation directly.
       if (!wrapper) return impl;
 
       const wrapped = (...args) => {
-        const maybeFinisher = /** @type {Finisher} */ (impl(...args));
+        const maybeFinisher = /** @type {AnyFinisher} */ (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);
+          const wrapperFinisher = wrapper(methodName, 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);
+              return /** @type {AnyFinisher} */ (wrapperFinisher)(
+                ...finishArgs,
+              );
             } catch (e) {
-              console.error(`${method} wrapper finisher failed:`, e);
+              console.error(`${methodName} wrapper finisher failed:`, e);
               return maybeFinisher(...finishArgs);
             }
           };
         } catch (e) {
-          console.error(`${method} wrapper failed:`, e);
+          console.error(`${methodName} wrapper failed:`, e);
           return maybeFinisher;
         }
       };
-      return /** @type {F} */ (wrapped);
-    },
-    /**
-     * Declare that all wrapping is done.
-     *
-     * @param {string} msg message to display if there are unused wrappers
-     */
-    done(msg = 'Unused wrappers') {
-      if (!unused.size) return;
-      console.warn(msg, ...[...unused.keys()].sort().map(q));
-    },
-  });
+      return /** @type {typeof impl} */ (/** @type {unknown} */ (wrapped));
+    })
+  );
+  if (unused.size) {
+    console.warn(unusedMsgPrefix, ...[...unused.keys()].sort().map(q));
+  }
+  return wrappedMethods;
 }
 
 export const badConsole = makeLimitedConsole(level => () => {
@@ -89,22 +84,19 @@ export const noopConsole = makeLimitedConsole(_level => () => {});
  * @returns {KernelSlog}
  */
 export function makeDummySlogger(slogCallbacks, dummyConsole = badConsole) {
-  const { wrap, done } = makeFinishersKit(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,
+  const unusedWrapperPrefix =
+    'Unused methods in makeDummySlogger slogCallbacks';
+  const wrappedMethods = addSlogCallbacks(slogCallbacks, unusedWrapperPrefix, {
+    provideVatSlogger: () =>
+      harden({ vatSlog: { delivery: () => noopFinisher } }),
+    vatConsole: () => dummyConsole,
+    startup: () => noopFinisher,
+    delivery: () => noopFinisher,
+    syscall: () => noopFinisher,
+    changeCList: () => noopFinisher,
+    terminateVat: () => noopFinisher,
   });
-  done('Unused makeDummySlogger slogCallbacks method names');
-  return dummySlogger;
+  return harden({ ...wrappedMethods, write: noopFinisher });
 }
 
 /**
@@ -250,43 +242,21 @@ export function makeSlogger(slogCallbacks, writeObj) {
     return { vatSlog, starting: true };
   }
 
-  function replayVatTranscript(vatID) {
-    safeWrite({ type: 'replay-transcript-start', vatID });
-    function finish() {
-      safeWrite({ type: 'replay-transcript-finish', vatID });
-    }
-    return harden(finish);
-  }
-
-  // function annotateVat(vatID, data) {
-  //   safeWrite({ type: 'annotate-vat', vatID, data });
-  // }
-
-  const { wrap, done } = makeFinishersKit(slogCallbacks);
-  const slogger = harden({
-    provideVatSlogger: wrap('provideVatSlogger', provideVatSlogger),
-    vatConsole: wrap('vatConsole', (vatID, ...args) =>
+  const unusedWrapperPrefix = 'Unused methods in makeSlogger slogCallbacks';
+  const wrappedMethods = addSlogCallbacks(slogCallbacks, unusedWrapperPrefix, {
+    provideVatSlogger,
+    vatConsole: (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.vatConsole(...args),
-    ),
-    startup: wrap('startup', (vatID, ...args) =>
+    startup: (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.startup(...args),
-    ),
-    // TODO: Remove this seemingly dead code.
-    replayVatTranscript,
-    delivery: wrap('delivery', (vatID, ...args) =>
+    delivery: (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.delivery(...args),
-    ),
-    syscall: wrap('syscall', (vatID, ...args) =>
+    syscall: (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.syscall(...args),
-    ),
-    changeCList: wrap('changeCList', (vatID, ...args) =>
+    changeCList: (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.changeCList(...args),
-    ),
-    terminateVat: wrap('terminateVat', (vatID, ...args) =>
+    terminateVat: (vatID, ...args) =>
       provideVatSlogger(vatID).vatSlog.terminateVat(...args),
-    ),
-    write: safeWrite,
   });
-  done('Unused makeSlogger slogCallbacks method names');
-  return slogger;
+  return harden({ ...wrappedMethods, write: safeWrite });
 }