@agoric/swingset-vat 0.33.0-u17.1 → 0.33.0-u18.1

package/src/kernel/state/vatKeeper.js

@@ -7,6 +7,7 @@ import { isObject } from '@endo/marshal';
 import { parseKernelSlot } from '../parseKernelSlots.js';
 import { makeVatSlot, parseVatSlot } from '../../lib/parseVatSlots.js';
 import { insistVatID } from '../../lib/id.js';
+import { insistCapData } from '../../lib/capdata.js';
 import { kdebug } from '../../lib/kdebug.js';
 import {
   parseReachableAndVatSlot,
@@ -83,49 +84,53 @@ export function initializeVatState(
 }
 
 /**
- * Produce a vat keeper for a vat.
+ * @typedef {object} VatKeeperPowers
+ * @property {TranscriptStore} transcriptStore  Accompanying transcript store, for the transcripts
+ * @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
+ * @property {*} incrementRefCount
+ * @property {*} decrementRefCount
+ * @property {(kernelSlot: string) => {reachable: number, recognizable: number}} getObjectRefCount
+ * @property {(kernelSlot: string, o: { reachable: number, recognizable: number }) => void} setObjectRefCount
+ * @property {(vatID: string, kernelSlot: string) => {isReachable: boolean, vatSlot: string}} getReachableAndVatSlot
+ * @property {(kernelSlot: string) => void} addMaybeFreeKref
+ * @property {*} incStat
+ * @property {*} decStat
+ * @property {*} getCrankNumber
+ * @property {*} scheduleReap
+ * @property {SnapStore} snapStore
+ */
+
+/**
+ * Produce a "vat keeper" for the kernel state of a vat.
  *
- * @param {KVStore} kvStore  The keyValue store in which the persistent state will be kept
- * @param {TranscriptStore} transcriptStore  Accompanying transcript store, for the transcripts
- * @param {*} kernelSlog
  * @param {string} vatID  The vat ID string of the vat in question
- * @param {*} addKernelObject  Kernel function to add a new object to the kernel's
- * mapping tables.
- * @param {*} addKernelPromiseForVat  Kernel function to add a new promise to the
- * kernel's mapping tables.
- * @param {(kernelSlot: string) => boolean} kernelObjectExists
- * @param {*} incrementRefCount
- * @param {*} decrementRefCount
- * @param {(kernelSlot: string) => {reachable: number, recognizable: number}} getObjectRefCount
- * @param {(kernelSlot: string, o: { reachable: number, recognizable: number }) => void} setObjectRefCount
- * @param {(vatID: string, kernelSlot: string) => {isReachable: boolean, vatSlot: string}} getReachableAndVatSlot
- * @param {(kernelSlot: string) => void} addMaybeFreeKref
- * @param {*} incStat
- * @param {*} decStat
- * @param {*} getCrankNumber
- * @param {*} scheduleReap
- * @param {SnapStore} [snapStore]
- * returns an object to hold and access the kernel's state for the given vat
+ * @param {KVStore} kvStore  The keyValue store in which the persistent state will be kept
+ * @param {VatKeeperPowers} powers
  */
 export function makeVatKeeper(
-  kvStore,
-  transcriptStore,
-  kernelSlog,
   vatID,
-  addKernelObject,
-  addKernelPromiseForVat,
-  kernelObjectExists,
-  incrementRefCount,
-  decrementRefCount,
-  getObjectRefCount,
-  setObjectRefCount,
-  getReachableAndVatSlot,
-  addMaybeFreeKref,
-  incStat,
-  decStat,
-  getCrankNumber,
-  scheduleReap,
-  snapStore = undefined,
+  kvStore,
+  {
+    transcriptStore,
+    kernelSlog,
+    addKernelObject,
+    addKernelPromiseForVat,
+    kernelObjectExists,
+    incrementRefCount,
+    decrementRefCount,
+    getObjectRefCount,
+    setObjectRefCount,
+    getReachableAndVatSlot,
+    addMaybeFreeKref,
+    incStat,
+    decStat,
+    getCrankNumber,
+    scheduleReap,
+    snapStore,
+  },
 ) {
   insistVatID(vatID);
 
@@ -173,6 +178,35 @@ export function makeVatKeeper(
     return harden(options);
   }
 
+  /**
+   * @param {SwingSetCapData} newVPCD
+   */
+  function setVatParameters(newVPCD) {
+    insistCapData(newVPCD);
+    const key = `${vatID}.vatParameters`;
+    // increment-before-decrement to minimize spurious rc=0 checks
+    for (const kref of newVPCD.slots) {
+      incrementRefCount(kref, `${vatID}.vatParameters`);
+    }
+    const old = kvStore.get(key) || '{"slots":[]}';
+    for (const kref of JSON.parse(old).slots) {
+      decrementRefCount(kref, `${vatID}.vatParameters`);
+    }
+    kvStore.set(key, JSON.stringify(newVPCD));
+  }
+
+  /**
+   * @returns {SwingSetCapData | undefined} vpcd
+   */
+  function getVatParameters() {
+    const key = `${vatID}.vatParameters`;
+    const old = kvStore.get(key);
+    if (old) {
+      return JSON.parse(old);
+    }
+    return undefined;
+  }
+
   // This is named "addDirt" because it should increment all dirt
   // counters (both for reap/BOYD and for heap snapshotting). We don't
   // have `heapSnapshotDirt` yet, but when we do, it should get
@@ -768,6 +802,8 @@ export function makeVatKeeper(
     setSourceAndOptions,
     getSourceAndOptions,
     getOptions,
+    setVatParameters,
+    getVatParameters,
     addDirt,
     getReapDirt,
     clearReapDirt,

package/src/kernel/vat-warehouse.js

@@ -97,6 +97,7 @@ export function makeSyscallSimulator(
   deliveryNum,
   transcriptEntry,
 ) {
+  const context = `anachrophobia in ${vatID} delivery d${deliveryNum}`;
   const syscallsExpected = [...transcriptEntry.sc]; // copy
   const syscallsMade = [];
   // syscallStatus's length will be max(syscallsExpected,
@@ -107,31 +108,36 @@ export function makeSyscallSimulator(
   let replayError; // sticky
 
   const explain = () => {
-    console.log(`anachrophobia strikes ${vatID} on delivery ${deliveryNum}`);
+    console.log(
+      `anachrophobia strikes ${vatID} delivery d${deliveryNum} syscalls`,
+    );
     for (const [idx, status] of syscallStatus.entries()) {
       const expected = syscallsExpected[idx];
       const got = syscallsMade[idx];
       switch (status) {
         case 'ok': {
-          console.log(`sc[${idx}]: ok: ${djson.stringify(got)}`);
+          console.log(`sc${idx}: ok: ${djson.stringify(got)}`);
           break;
         }
         case 'wrong': {
-          console.log(`sc[${idx}]: wrong`);
-          console.log(`  expected: ${djson.stringify(expected.s)}`);
-          console.log(`  got     : ${djson.stringify(got)}`);
+          console.log(
+            `
+sc${idx}: WRONG
+  expected: ${djson.stringify(expected.s)}
+  got     : ${djson.stringify(got)}`.trimStart(),
+          );
           break;
         }
         case 'extra': {
-          console.log(`sc[${idx}]: extra: ${djson.stringify(got)}`);
+          console.log(`sc${idx}: EXTRA: ${djson.stringify(got)}`);
           break;
         }
         case 'missing': {
-          console.log(`sc[${idx}]: missing: ${djson.stringify(expected.s)}`);
+          console.log(`sc${idx}: MISSING: ${djson.stringify(expected.s)}`);
           break;
         }
         default:
-          Fail`bad ${status}`;
+          Fail`sc${idx}: bad status ${status}`;
       }
     }
   };
@@ -140,16 +146,16 @@ export function makeSyscallSimulator(
     // slog entries have no kernel-translated kso/ksr
     const finish = kernelSlog.syscall(vatID, undefined, vso);
     const expected = syscallsExpected[syscallsMade.length];
-    syscallsMade.push(vso);
+    const idx = syscallsMade.push(vso) - 1;
     if (!expected) {
       syscallStatus.push('extra');
-      const error = Error(`anachrophobia in ${vatID}: extra syscall`);
+      const error = Error(`${context}: extra syscall at index sc${idx}`);
       replayError ||= error;
       throw error;
     }
     if (!syscallsAreIdentical(expected.s, vso)) {
       syscallStatus.push('wrong');
-      const error = Error(`anachrophobia in ${vatID}: wrong syscall`);
+      const error = Error(`${context}: wrong syscall at index sc${idx}`);
       replayError ||= error;
       throw error;
     }
@@ -159,12 +165,14 @@ export function makeSyscallSimulator(
   };
 
   const finishSimulation = () => {
-    if (syscallsMade.length < syscallsExpected.length) {
-      const missing = syscallsExpected.length - syscallsMade.length;
+    const missing = syscallsExpected.length - syscallsMade.length;
+    if (missing > 0) {
       for (let i = 0; i < missing; i += 1) {
         syscallStatus.push('missing');
       }
-      const error = Error(`anachrophobia in ${vatID}: missing syscalls`);
+      const error = Error(
+        `${context}: missing ${missing} syscall(s) at index sc${syscallsMade.length}`,
+      );
       replayError ||= error;
     }
 
@@ -389,7 +397,6 @@ export function makeVatWarehouse({
     //   entriesReplayed, // retval of replayTranscript() above
     // );
     ephemeral.vats.set(vatID, result);
-    // eslint-disable-next-line no-use-before-define
     await applyAvailabilityPolicy(vatID);
     return result;
   }
@@ -596,7 +603,6 @@ export function makeVatWarehouse({
     //
     /** @type { KernelDeliveryObject } */
     const kd = harden(['bringOutYourDead']);
-    // eslint-disable-next-line no-use-before-define
     const vd = kernelDeliveryToVatDelivery(vatID, kd);
     const vs = kernelSlog.provideVatSlogger(vatID).vatSlog;
     await deliverToVat(vatID, kd, vd, vs);

package/src/kernel/vatTranslator.js

@@ -50,6 +50,7 @@ function makeTranslateKernelDeliveryToVatDelivery(vatID, kernelKeeper) {
       parseVatSlot(targetSlot).allocatedByVat || Fail`deliver() to wrong vat`;
     } else if (type === 'promise') {
       const p = kernelKeeper.getKernelPromise(target);
+      assert(p.state === 'unresolved');
       p.decider === vatID || Fail`wrong decider`;
     }
     const inputSlots = msg.methargs.slots.map(slot =>
@@ -59,7 +60,9 @@ function makeTranslateKernelDeliveryToVatDelivery(vatID, kernelKeeper) {
     if (msg.result) {
       insistKernelType('promise', msg.result);
       const p = kernelKeeper.getKernelPromise(msg.result);
-      p.state === 'unresolved' || Fail`result ${msg.result} already resolved`;
+      if (p.state !== 'unresolved') {
+        throw Fail`result ${msg.result} already resolved`;
+      }
       !p.decider || Fail`result ${msg.result} already has decider ${p.decider}`;
       resultSlot = vatKeeper.mapKernelSlotToVatSlot(msg.result);
       insistVatType('promise', resultSlot);
@@ -318,8 +321,9 @@ function makeTranslateVatSyscallToKernelSyscall(vatID, kernelKeeper) {
       // In the case of non-pipelining vats these checks are redundant since
       // we're guaranteed to have a promise newly allocated by the vat.
       const p = kernelKeeper.getKernelPromise(result);
-      p.state === 'unresolved' ||
-        Fail`send() result ${result} is already resolved`;
+      if (p.state !== 'unresolved') {
+        throw Fail`send() result ${result} is already resolved`;
+      }
       p.decider === vatID ||
         Fail`send() result ${result} is decided by ${p.decider} not ${vatID}`;
       kernelKeeper.clearDecider(result);

package/src/supervisors/subprocess-node/supervisor-subprocess-node.js

@@ -36,6 +36,7 @@ workerLog(`supervisor started`);
 
 function makeNetstringReader({ fd, encoding }) {
   const input = Buffer.alloc(32 * 1024);
+  /** @type {Buffer<ArrayBufferLike>} */
   let buffered = Buffer.alloc(0);
   let decoded = [];
 

package/src/typeGuards.js

@@ -10,10 +10,11 @@ export const ManagerType = M.or(
 
 const Bundle = M.splitRecord({ moduleType: M.string() });
 
-const SwingsetConfigOptions = harden({
+const SwingsetConfigOptions = {
   creationOptions: M.splitRecord({}, { critical: M.boolean() }),
   parameters: M.recordOf(M.string(), M.any()),
-});
+};
+harden(SwingsetConfigOptions);
 
 const SwingSetConfigProperties = M.or(
   M.splitRecord({ sourceSpec: M.string() }, SwingsetConfigOptions),

package/src/types-external.js

@@ -124,7 +124,7 @@ export {};
  *
  * @typedef { { transcriptCount: number } } VatStats
  * @typedef { ReturnType<typeof import('./kernel/state/vatKeeper.js').makeVatKeeper> } VatKeeper
- * @typedef { ReturnType<typeof import('./kernel/state/kernelKeeper.js').default> } KernelKeeper
+ * @typedef { import('./kernel/state/kernelKeeper.js').KernelKeeper } KernelKeeper
  * @typedef { Awaited<ReturnType<typeof import('@agoric/xsnap').xsnap>> } XSnap
  * @typedef { (dr: VatDeliveryResult) => void } SlogFinishDelivery
  * @typedef { (ksr: KernelSyscallResult, vsr: VatSyscallResult) => void } SlogFinishSyscall
@@ -227,6 +227,7 @@ export {};
  *
  * @typedef { { exports: number,
  *              imports: number,
+ *              promises: number,
  *              kv: number,
  *              snapshots: number,
  *              transcripts: number,
@@ -283,6 +284,13 @@ export {};
  * @property { boolean } [restartWorkerOnSnapshot]     Reload worker immediately upon snapshot creation
  */
 
+/**
+ * @typedef { import('./devices/mailbox/mailbox.js').Mailbox } Mailbox
+ */
+/**
+ * @typedef { import('./devices/mailbox/mailbox.js').MailboxExport } MailboxExport
+ */
+
 /**
  * Vat Creation and Management
  *

package/src/types-internal.js

@@ -92,6 +92,17 @@ export {};
  * @property {number} [computrons]
  */
 
+/**
+ * @typedef {{ state: 'unresolved', refCount: number,
+ *             decider: string | undefined, policy: string,
+ *             subscribers: string[], queue: string[],
+ *          }} UnresolvedPromiseRecord
+ * @typedef {{ state: 'fulfilled' | 'rejected', refCount: number,
+ *             data: SwingSetCapData,
+ *          }} SettledPromiseRecord
+ * @typedef {UnresolvedPromiseRecord | SettledPromiseRecord} PromiseRecord
+ */
+
 /**
  * @typedef {{
  *   enablePipelining: boolean,

package/src/vats/comms/delivery.js

@@ -1,5 +1,3 @@
-/* eslint-disable no-use-before-define */
-
 import { assert, Fail } from '@endo/errors';
 import { kser } from '@agoric/kmarshal';
 import { parseLocalSlot, insistLocalType } from './parseLocalSlots.js';

package/src/vats/comms/state.js

@@ -150,7 +150,6 @@ export function makeState(syscall) {
       store.set('r.nextID', '1');
       store.set('initialized', 'true');
       if (controller) {
-        // eslint-disable-next-line no-use-before-define
         addMetaObject(controller);
         cdebug(`comms controller is ${controller}`);
       }
@@ -393,7 +392,6 @@ export function makeState(syscall) {
             // the object is unreachable
 
             const { owner, isReachable, isRecognizable } =
-              // eslint-disable-next-line no-use-before-define
               getOwnerAndStatus(lref);
             if (isReachable) {
               // but the exporter doesn't realize it yet, so schedule a
@@ -558,7 +556,6 @@ export function makeState(syscall) {
       isReachable = isReachableByKernel(lref);
       isRecognizable = !!mapToKernel(lref);
     } else {
-      // eslint-disable-next-line no-use-before-define
       const remote = getRemote(owner);
       isReachable = remote.isReachable(lref);
       isRecognizable = !!remote.mapToRemote(lref);
@@ -794,7 +791,6 @@ export function makeState(syscall) {
     insistPromiseIsUnresolved,
     markPromiseAsResolved,
 
-    // eslint-disable-next-line no-use-before-define
     getRemote,
     addRemote,
     getRemoteIDForName,

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

@@ -1,5 +1,3 @@
-/* eslint-disable no-use-before-define */
-
 import { assert } from '@endo/errors';
 import { Far, E, passStyleOf } from '@endo/far';
 import { makePromiseKit } from '@endo/promise-kit';

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

@@ -100,7 +100,6 @@ export function buildRootObject(vatPowers, _vatParameters, baggage) {
       // getNotifier: ({ state }) => state.notifier, // XXX RESTORE
       getNotifier: ({ _self }) => Fail`not implemented, see #7234`, // XXX TEMP
     },
-    // eslint-disable-next-line no-use-before-define
     { finish: finishMeter },
   );
 
@@ -120,18 +119,15 @@ export function buildRootObject(vatPowers, _vatParameters, baggage) {
       // getNotifier: ({ state }) => state.notifier, // will never fire // XXX RESTORE
       getNotifier: ({ _self }) => Fail`not implemented, see #7234`, // XXX TEMP
     },
-    // eslint-disable-next-line no-use-before-define
     { finish: finishMeter },
   );
 
   function finishMeter({ state, self }) {
-    // eslint-disable-next-line no-use-before-define
     meterByID.init(
       state.meterID,
       // harden({ meter: self, updater: state.updater }), // XXX RESTORE
       harden({ meter: self }), // XXX TEMP
     );
-    // eslint-disable-next-line no-use-before-define
     meterIDByMeter.set(self, state.meterID);
   }
 

package/tools/baggage-check.js

@@ -1,8 +1,6 @@
 import { makeMarshal } from '@endo/marshal';
 import { Far } from '@endo/far';
 
-/* eslint-disable no-use-before-define */
-
 function fakeSTV(slot, iface = 'Remotable') {
   return Far(iface, {
     getSlot: () => slot,

package/tools/bootstrap-dvo-test.js

@@ -11,7 +11,6 @@ export function buildRootObject() {
   async function runTests(phase) {
     testLog = [];
     doneP = makePromiseKit();
-    // eslint-disable-next-line no-use-before-define
     await E(testVatRoot).runTests(self, phase);
     await doneP.promise;
     return testLog;

package/tools/bootstrap-relay.js

@@ -1,3 +1,12 @@
+/**
+ * @file Source code for a bootstrap vat that runs blockchain behaviors (such as
+ *   bridge vat integration) and exposes reflective methods for use in testing.
+ *
+ * TODO: Build from ./vat-puppet.js makeReflectionMethods
+ * and share code with packages/vats/tools/vat-reflective-chain-bootstrap.js
+ * (which basically extends this for better [mock] blockchain integration).
+ */
+
 import { Fail, q } from '@endo/errors';
 import { objectMap } from '@agoric/internal';
 import { Far, E } from '@endo/far';

package/tools/prepare-strict-test-env-ava.js

@@ -0,0 +1,19 @@
+/**
+ * Like prepare-strict-test-env but also sets up ses-ava and provides
+ * the ses-ava `test` function to be used as if it is the ava
+ * `test` function.
+ */
+
+import '@agoric/swingset-liveslots/tools/prepare-strict-test-env.js';
+
+import { wrapTest } from '@endo/ses-ava';
+import rawTest from 'ava';
+
+export * from '@agoric/swingset-liveslots/tools/prepare-strict-test-env.js';
+
+export const test = wrapTest(rawTest);
+
+// Does not import from a module because we're testing the global env
+/* global globalThis */
+export const VatData = globalThis.VatData;
+assert(VatData);

package/tools/run-utils.js

@@ -2,12 +2,18 @@ import { Fail, q } from '@endo/errors';
 import { kunser } from '@agoric/kmarshal';
 import { makeQueue } from '@endo/stream';
 
-/** @import { ERef } from '@endo/far' */
+/**
+ * @import { ERef } from '@endo/far'
+ * @import { RunPolicy } from '../src/types-external.js'
+ */
+
+/** @typedef {{ provideRunPolicy: () => RunPolicy | undefined }} RunHarness */
 
 /**
  * @param {import('../src/controller/controller.js').SwingsetController} controller
+ * @param {RunHarness} [harness]
  */
-export const makeRunUtils = controller => {
+export const makeRunUtils = (controller, harness) => {
   const mutex = makeQueue();
   const logRunFailure = reason =>
     console.log('controller.run() failure', reason);
@@ -17,7 +23,7 @@ export const makeRunUtils = controller => {
    * Wait for exclusive access to the controller, then before relinquishing that access,
    * enqueue and process a delivery and return the result.
    *
-   * @param {() => ERef<void | ReturnType<controller['queueToVatObject']>>} deliveryThunk
+   * @param {() => ERef<void | ReturnType<typeof controller['queueToVatObject']>>} deliveryThunk
    * function for enqueueing a delivery and returning the result kpid (if any)
    * @param {boolean} [voidResult] whether to ignore the result
    * @returns {Promise<any>}
@@ -25,7 +31,8 @@ export const makeRunUtils = controller => {
   const queueAndRun = async (deliveryThunk, voidResult = false) => {
     await mutex.get();
     const kpid = await deliveryThunk();
-    const runResultP = controller.run();
+    const runPolicy = harness && harness.provideRunPolicy();
+    const runResultP = controller.run(runPolicy);
     mutex.put(runResultP.catch(logRunFailure));
     await runResultP;
 

package/tools/vat-puppet.js

@@ -0,0 +1,111 @@
+/**
+ * @file Source code for a vat that exposes reflective methods for use in
+ *   testing.
+ */
+
+import { Fail, q } from '@endo/errors';
+import { Far, E } from '@endo/far';
+import { makePromiseKit } from '@endo/promise-kit';
+import { objectMap } from '@agoric/internal';
+
+/**
+ * @callback Die
+ * @param {unknown} completion
+ * @param {[target: unknown, method: string, ...args: unknown[]]} [finalSend]
+ */
+
+/**
+ * @typedef {Array<[name: string, ...args: unknown[]]>} CallLog
+ */
+
+/**
+ * @param {import('@agoric/swingset-vat').VatPowers} vatPowers
+ * @param {import('@agoric/vat-data').Baggage} baggage
+ */
+export const makeReflectionMethods = (vatPowers, baggage) => {
+  let baggageHoldCount = 0;
+  /** @type {Map<object, CallLog>} */
+  const callLogsByRemotable = new Map();
+  const heldInHeap = [];
+  const send = (target, method, ...args) => E(target)[method](...args);
+  const makeSpy = (value, name, callLog) => {
+    const spyName = `get ${name}`;
+    const spy = {
+      [spyName](...args) {
+        callLog.push([name, ...args]);
+        return value;
+      },
+    }[spyName];
+    return spy;
+  };
+
+  return {
+    /** @type {Die} */
+    dieHappy: (completion, finalSend) => {
+      vatPowers.exitVat(completion);
+      if (finalSend) send(...finalSend);
+    },
+
+    /** @type {Die} */
+    dieSad: (reason, finalSend) => {
+      vatPowers.exitVatWithFailure(/** @type {Error} */ (reason));
+      if (finalSend) send(...finalSend);
+    },
+
+    holdInBaggage: (...values) => {
+      for (const value of values) {
+        baggage.init(`held-${baggageHoldCount}`, value);
+        baggageHoldCount += 1;
+      }
+      return baggageHoldCount;
+    },
+
+    holdInHeap: (...values) => heldInHeap.push(...values),
+
+    makePromiseKit: () => {
+      const { promise, ...resolverMethods } = makePromiseKit();
+      void promise.catch(() => {});
+      const resolver = Far('resolver', resolverMethods);
+      return harden({ promise, resolver });
+    },
+
+    makeUnsettledPromise() {
+      const { promise } = makePromiseKit();
+      void promise.catch(() => {});
+      return promise;
+    },
+
+    /**
+     * Returns a remotable with methods that return provided values. Invocations
+     * of those methods and their arguments are captured for later retrieval by
+     * `getCallLogForRemotable`.
+     *
+     * @param {string} [label]
+     * @param {Record<string, any>} [fields]
+     */
+    makeRemotable: (label = 'Remotable', fields = {}) => {
+      /** @type {CallLog} */
+      const callLog = [];
+      const methods = objectMap(fields, (value, name) =>
+        makeSpy(value, name, callLog),
+      );
+      const remotable = Far(label, { ...methods });
+      callLogsByRemotable.set(remotable, callLog);
+      return remotable;
+    },
+
+    /**
+     * @param {object} remotable
+     * @returns {CallLog}
+     */
+    getCallLogForRemotable: remotable =>
+      callLogsByRemotable.get(remotable) ||
+      Fail`unknown remotable ${q(remotable)}`,
+  };
+};
+harden(makeReflectionMethods);
+
+export function buildRootObject(vatPowers, _vatParameters, baggage) {
+  const methods = makeReflectionMethods(vatPowers, baggage);
+  return Far('root', methods);
+}