@agoric/swingset-liveslots 0.10.3-dev-5dc325b.0 → 0.10.3-getting-started-dev-d127d1d.0

package/src/liveslots.js

@@ -1,4 +1,3 @@
-/* eslint @typescript-eslint/no-floating-promises: "warn" */
 import {
   Remotable,
   passStyleOf,
@@ -252,10 +251,13 @@ function build(
     const importsToRetire = new Set();
     const exportsToRetire = new Set();
     let doMore;
-    await null;
     do {
       doMore = false;
 
+      // Yes, we know this is an await inside a loop.  Too bad.  (Also, it's a
+      // `do {} while` loop, which means there's no conditional bypass of the
+      // await.)
+      // eslint-disable-next-line no-await-in-loop, @jessie.js/no-nested-await
       await gcTools.gcAndFinalize();
 
       // possiblyDeadSet contains a baseref for everything (Presences,
@@ -498,6 +500,54 @@ function build(
     return Remotable(iface);
   }
 
+  /**
+   * Counters to track the next number for various categories of allocation.
+   * `exportID` starts at 1 because 'o+0' is always automatically
+   * pre-assigned to the root object.
+   * `promiseID` starts at 5 as a very minor aid to debugging: when puzzling
+   * over trace logs and the like, it helps for the numbers in various species
+   * of IDs that are jumbled together to be a little out of sync and thus a
+   * little less similar to each other.
+   */
+  const initialIDCounters = { exportID: 1, collectionID: 1, promiseID: 5 };
+  /** @type {Record<string, number>} */
+  let idCounters;
+  let idCountersAreDirty = false;
+
+  function initializeIDCounters() {
+    if (!idCounters) {
+      // the saved value might be missing, or from an older liveslots
+      // (with fewer counters), so merge it with our initial values
+      const saved = JSON.parse(syscall.vatstoreGet('idCounters') || '{}');
+      idCounters = { ...initialIDCounters, ...saved };
+      idCountersAreDirty = true;
+    }
+  }
+
+  function allocateNextID(name) {
+    if (!idCounters) {
+      // Normally `initializeIDCounters` would be called from startVat, but some
+      // tests bypass that so this is a backstop.  Note that the invocation from
+      // startVat is there to make vatStore access patterns a bit more
+      // consistent from one vat to another, principally as a confusion
+      // reduction measure in service of debugging; it is not a correctness
+      // issue.
+      initializeIDCounters();
+    }
+    const result = idCounters[name];
+    result !== undefined || Fail`unknown idCounters[${name}]`;
+    idCounters[name] += 1;
+    idCountersAreDirty = true;
+    return result;
+  }
+
+  function flushIDCounters() {
+    if (idCountersAreDirty) {
+      syscall.vatstoreSet('idCounters', JSON.stringify(idCounters));
+      idCountersAreDirty = false;
+    }
+  }
+
   // TODO: fix awkward non-orthogonality: allocateExportID() returns a number,
   // allocatePromiseID() returns a slot, registerPromise() uses the slot from
   // allocatePromiseID(), exportPassByPresence() generates a slot itself using
@@ -506,18 +556,15 @@ function build(
   // use a slot from the corresponding allocateX
 
   function allocateExportID() {
-    // eslint-disable-next-line no-use-before-define
-    return vrm.allocateNextID('exportID');
+    return allocateNextID('exportID');
   }
 
   function allocateCollectionID() {
-    // eslint-disable-next-line no-use-before-define
-    return vrm.allocateNextID('collectionID');
+    return allocateNextID('collectionID');
   }
 
   function allocatePromiseID() {
-    // eslint-disable-next-line no-use-before-define
-    const promiseID = vrm.allocateNextID('promiseID');
+    const promiseID = allocateNextID('promiseID');
     return makeVatSlot('promise', true, promiseID);
   }
 
@@ -712,9 +759,9 @@ function build(
       Fail`registerValue(${baseRef} should not receive individual facets`;
     slotToVal.set(baseRef, new WeakRef(val));
     if (valIsCohort) {
-      for (const [index, name] of vrm.getFacetNames(id).entries()) {
+      vrm.getFacetNames(id).forEach((name, index) => {
         valToSlot.set(val[name], `${baseRef}:${index}`);
-      }
+      });
     } else {
       valToSlot.set(val, baseRef);
     }
@@ -936,20 +983,12 @@ function build(
         return null;
       }
       syscall.resolve(resolutions);
-      for (const resolution of resolutions) {
-        const [_xvpid, _isReject, resolutionCD] = resolution;
-        for (const vref of resolutionCD.slots) {
-          maybeNewVPIDs.add(vref);
-        }
-      }
-      for (const resolution of resolutions) {
-        const [xvpid] = resolution;
-        maybeNewVPIDs.delete(xvpid);
-      }
-    }
-    for (const newVPID of Array.from(maybeNewVPIDs).sort()) {
-      maybeExportPromise(newVPID);
+      resolutions.forEach(([_xvpid, _isReject, resolutionCD]) => {
+        resolutionCD.slots.forEach(vref => maybeNewVPIDs.add(vref));
+      });
+      resolutions.forEach(([xvpid]) => maybeNewVPIDs.delete(xvpid));
     }
+    Array.from(maybeNewVPIDs).sort().forEach(maybeExportPromise);
 
     // ideally we'd wait until .then is called on p before subscribing, but
     // the current Promise API doesn't give us a way to discover this, so we
@@ -1151,21 +1190,13 @@ function build(
 
       const maybeNewVPIDs = new Set();
       // if we mention a vpid, we might need to track it
-      for (const resolution of resolutions) {
-        const [_xvpid, _isReject, resolutionCD] = resolution;
-        for (const vref of resolutionCD.slots) {
-          maybeNewVPIDs.add(vref);
-        }
-      }
+      resolutions.forEach(([_xvpid, _isReject, resolutionCD]) => {
+        resolutionCD.slots.forEach(vref => maybeNewVPIDs.add(vref));
+      });
       // but not if we just resolved it (including the primary)
-      for (const resolution of resolutions) {
-        const [xvpid] = resolution;
-        maybeNewVPIDs.delete(xvpid);
-      }
+      resolutions.forEach(([xvpid]) => maybeNewVPIDs.delete(xvpid));
       // track everything that's left
-      for (const newVPID of Array.from(maybeNewVPIDs).sort()) {
-        maybeExportPromise(newVPID);
-      }
+      Array.from(maybeNewVPIDs).sort().forEach(maybeExportPromise);
 
       // only the primary can possibly be newly resolved
       unregisterUnreferencedVPID(vpid);
@@ -1223,11 +1254,11 @@ function build(
     // 'imports' is an exclusively-owned Set that holds all new
     // promise vpids, both resolved and unresolved
     const imports = finishCollectingPromiseImports();
-    for (const vpid of retiredVPIDs) {
+    retiredVPIDs.forEach(vpid => {
       unregisterUnreferencedVPID(vpid); // unregisters if not in vdata
       importedVPIDs.delete(vpid);
       imports.delete(vpid); // resolved, so don't subscribe()
-    }
+    });
     for (const vpid of Array.from(imports).sort()) {
       syscall.subscribe(vpid);
     }
@@ -1267,18 +1298,14 @@ function build(
 
   function retireExports(vrefs) {
     assert(Array.isArray(vrefs));
-    for (const vref of vrefs) {
-      retireOneExport(vref);
-    }
+    vrefs.forEach(retireOneExport);
   }
 
   function retireImports(vrefs) {
     assert(Array.isArray(vrefs));
     vrefs.map(vref => insistVatType('object', vref));
     vrefs.map(vref => assert(!parseVatSlot(vref).allocatedByVat));
-    for (const vref of vrefs) {
-      vrm.ceaseRecognition(vref);
-    }
+    vrefs.forEach(vrm.ceaseRecognition);
   }
 
   // TODO: when we add notifyForward, guard against cycles
@@ -1423,7 +1450,7 @@ function build(
     }
     harden(vpow);
 
-    vrm.initializeIDCounters();
+    initializeIDCounters();
     vom.initializeKindHandleKind();
     collectionManager.initializeStoreKindInfo();
 
@@ -1546,7 +1573,7 @@ function build(
    * dispatch has completed and user code has relinquished agency.
    */
   function afterDispatchActions() {
-    vrm.flushIDCounters();
+    flushIDCounters();
     collectionManager.flushSchemaCache();
     vom.flushStateCache();
   }
@@ -1602,7 +1629,7 @@ function build(
       // *not* directly wait for the userspace function to complete, nor for
       // any promise it returns to fire.
       const p = Promise.resolve(delivery).then(unmeteredDispatch);
-      void p.finally(() => (complete = true));
+      p.finally(() => (complete = true));
 
       // Instead, we wait for userspace to become idle by draining the
       // promise queue. We clean up and then examine/return 'p' so any

package/src/virtualObjectManager.js

@@ -16,19 +16,10 @@ import {
 
 /** @template T @typedef {import('@agoric/vat-data').DefineKindOptions<T>} DefineKindOptions */
 
-const { hasOwn, defineProperty, getOwnPropertyNames, entries } = Object;
+const { hasOwn, defineProperty, getOwnPropertyNames } = Object;
 const { ownKeys } = Reflect;
 const { quote: q } = assert;
 
-// See https://github.com/Agoric/agoric-sdk/issues/8005
-// Once agoric-sdk is upgraded to depend on endo post
-// https://github.com/endojs/endo/pull/1606 then remove this
-// definition of `b` and say instead
-// ```js
-//   const { quote: q, base: b } = assert;
-// ```
-const b = index => q(Number(index));
-
 // import { kdebug } from './kdebug.js';
 
 // TODO Use environment-options.js currently in ses/src after factoring it out
@@ -150,8 +141,9 @@ const makeContextCache = (makeState, makeContext) => {
  * @param {*} getSlotForVal
  * @returns {ContextProvider}
  */
-const makeContextProvider = (contextCache, getSlotForVal) =>
-  harden(rep => contextCache.get(getSlotForVal(rep)));
+const makeContextProvider = (contextCache, getSlotForVal) => {
+  return harden(rep => contextCache.get(getSlotForVal(rep)));
+};
 
 const makeContextProviderKit = (contextCache, getSlotForVal, facetNames) => {
   /** @type { Record<string, any> } */
@@ -268,15 +260,15 @@ const makeFacets = (
 };
 
 const insistDurableCapdata = (vrm, what, capdata, valueFor) => {
-  for (const [idx, vref] of entries(capdata.slots)) {
+  capdata.slots.forEach((vref, idx) => {
     if (!vrm.isDurable(vref)) {
       if (valueFor) {
-        Fail`value for ${what} is not durable: slot ${b(idx)} of ${capdata}`;
+        Fail`value for ${what} is not durable: slot ${q(idx)} of ${capdata}`;
       } else {
-        Fail`${what} is not durable: slot ${b(idx)} of ${capdata}`;
+        Fail`${what} is not durable: slot ${q(idx)} of ${capdata}`;
       }
     }
-  }
+  });
 };
 
 const insistSameCapData = (oldCD, newCD) => {
@@ -289,11 +281,11 @@ const insistSameCapData = (oldCD, newCD) => {
   if (oldCD.slots.length !== newCD.slots.length) {
     Fail`durable Kind stateShape mismatch (slots.length)`;
   }
-  for (const [idx, oldVref] of entries(oldCD.slots)) {
+  oldCD.slots.forEach((oldVref, idx) => {
     if (newCD.slots[idx] !== oldVref) {
       Fail`durable Kind stateShape mismatch (slot[${idx}])`;
     }
-  }
+  });
 };
 
 /**
@@ -322,7 +314,7 @@ const insistSameCapData = (oldCD, newCD) => {
  * recursion if our returned WeakMap/WeakSet wrappers are subsequently installed
  * on globalThis.
  *
- * @returns a new virtual object manager.
+ * @returns {object} a new virtual object manager.
  *
  * The virtual object manager allows the creation of persistent objects that do
  * not need to occupy memory when they are not in use.  It provides five
@@ -715,16 +707,10 @@ export const makeVirtualObjectManager = (
     durableKindDescriptor = undefined, // only for durables
   ) => {
     const {
-      finish = undefined,
+      finish,
       stateShape = undefined,
       thisfulMethods = false,
-    } = options;
-    let {
-      // These are "let" rather than "const" only to accommodate code
-      // below that tolerates an old version of the vat-data package.
-      // See there for more explanation.
       interfaceGuard = undefined,
-      interfaceGuardKit = undefined,
     } = options;
 
     const statePrototype = {}; // Not frozen yet
@@ -745,38 +731,11 @@ export const makeVirtualObjectManager = (
     switch (assessFacetiousness(behavior)) {
       case 'one': {
         assert(!multifaceted);
-        interfaceGuardKit === undefined ||
-          Fail`Use an interfaceGuard, not interfaceGuardKit, to protect class ${q(
-            tag,
-          )}`;
         proposedFacetNames = undefined;
         break;
       }
       case 'many': {
         assert(multifaceted);
-
-        if (interfaceGuard && interfaceGuardKit === undefined) {
-          // This if clause is for the purpose of tolerating versions
-          // of the vata-data package that precede
-          // https://github.com/Agoric/agoric-sdk/pull/8220 .
-          // Before that PR, the options name `interfaceGuard` would
-          // actually carry the InterfaceGuardKit.
-          //
-          // Tolerating the old vat-data with the new types.
-          // at-expect-error here causes inconsistent reports, so
-          // doing the at-ts-ignore-error ritual instead.
-          // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
-          // @ts-ignore
-          interfaceGuardKit = interfaceGuard;
-          interfaceGuard = undefined;
-          // The rest of the code from here makes no further compromise
-          // for that old version of the vat-data package.
-        }
-
-        interfaceGuard === undefined ||
-          Fail`Use an interfaceGuardKit, not an interfaceGuard, to protect class kit ${q(
-            tag,
-          )}`;
         proposedFacetNames = ownKeys(behavior).sort();
         break;
       }
@@ -987,7 +946,7 @@ export const makeVirtualObjectManager = (
         makeContextProviderKit(contextCache, getSlotForVal, facetNames),
         behavior,
         thisfulMethods,
-        interfaceGuardKit,
+        interfaceGuard,
       );
     } else {
       proto = defendPrototype(
@@ -1015,9 +974,9 @@ export const makeVirtualObjectManager = (
       let doMoreGC = false;
       const record = dataCache.get(baseRef);
       for (const valueCD of Object.values(record.capdatas)) {
-        for (const vref of valueCD.slots) {
+        valueCD.slots.forEach(vref => {
           doMoreGC = vrm.removeReachableVref(vref) || doMoreGC;
-        }
+        });
       }
       dataCache.delete(baseRef);
       return doMoreGC;
@@ -1056,7 +1015,6 @@ export const makeVirtualObjectManager = (
         if (isDurable) {
           insistDurableCapdata(vrm, prop, valueCD, true);
         }
-        // eslint-disable-next-line github/array-foreach
         valueCD.slots.forEach(vrm.addReachableVref);
         capdatas[prop] = valueCD;
         valueMap.set(prop, value);
@@ -1124,7 +1082,6 @@ export const makeVirtualObjectManager = (
     return id;
   };
 
-  /** @type {import('./vatDataTypes').VatData['defineKind']} */
   const defineKind = (tag, init, behavior, options) => {
     const kindID = `${allocateExportID()}`;
     saveVirtualKindDescriptor(kindID, { kindID, tag });
@@ -1140,7 +1097,6 @@ export const makeVirtualObjectManager = (
     );
   };
 
-  /** @type {import('./vatDataTypes').VatData['defineKindMulti']} */
   const defineKindMulti = (tag, init, behavior, options) => {
     const kindID = `${allocateExportID()}`;
     saveVirtualKindDescriptor(kindID, { kindID, tag });
@@ -1180,7 +1136,6 @@ export const makeVirtualObjectManager = (
     return kindHandle;
   };
 
-  /** @type {import('./vatDataTypes').VatData['defineDurableKind']} */
   const defineDurableKind = (kindHandle, init, behavior, options) => {
     kindHandleToID.has(kindHandle) || Fail`unknown handle ${kindHandle}`;
     const kindID = kindHandleToID.get(kindHandle);
@@ -1203,7 +1158,6 @@ export const makeVirtualObjectManager = (
     return maker;
   };
 
-  /** @type {import('./vatDataTypes').VatData['defineDurableKindMulti']} */
   const defineDurableKindMulti = (kindHandle, init, behavior, options) => {
     kindHandleToID.has(kindHandle) || Fail`unknown handle ${kindHandle}`;
     const kindID = kindHandleToID.get(kindHandle);

package/src/virtualReferences.js

@@ -682,54 +682,6 @@ export function makeVirtualReferenceManager(
     return size;
   }
 
-  /**
-   * Counters to track the next number for various categories of allocation.
-   * `exportID` starts at 1 because 'o+0' is always automatically
-   * pre-assigned to the root object.
-   * `promiseID` starts at 5 as a very minor aid to debugging: when puzzling
-   * over trace logs and the like, it helps for the numbers in various species
-   * of IDs that are jumbled together to be a little out of sync and thus a
-   * little less similar to each other.
-   */
-  const initialIDCounters = { exportID: 1, collectionID: 1, promiseID: 5 };
-  /** @type {Record<string, number>} */
-  let idCounters;
-  let idCountersAreDirty = false;
-
-  function initializeIDCounters() {
-    if (!idCounters) {
-      // the saved value might be missing, or from an older liveslots
-      // (with fewer counters), so merge it with our initial values
-      const saved = JSON.parse(syscall.vatstoreGet('idCounters') || '{}');
-      idCounters = { ...initialIDCounters, ...saved };
-      idCountersAreDirty = true;
-    }
-  }
-
-  function allocateNextID(name) {
-    if (!idCounters) {
-      // Normally `initializeIDCounters` would be called from startVat, but some
-      // tests bypass that so this is a backstop.  Note that the invocation from
-      // startVat is there to make vatStore access patterns a bit more
-      // consistent from one vat to another, principally as a confusion
-      // reduction measure in service of debugging; it is not a correctness
-      // issue.
-      initializeIDCounters();
-    }
-    const result = idCounters[name];
-    result !== undefined || Fail`unknown idCounters[${name}]`;
-    idCounters[name] += 1;
-    idCountersAreDirty = true;
-    return result;
-  }
-
-  function flushIDCounters() {
-    if (idCountersAreDirty) {
-      syscall.vatstoreSet('idCounters', JSON.stringify(idCounters));
-      idCountersAreDirty = false;
-    }
-  }
-
   const testHooks = {
     getReachableRefCount,
     countCollectionsForWeakKey,
@@ -774,9 +726,6 @@ export function makeVirtualReferenceManager(
     ceaseRecognition,
     setDeleteCollectionEntry,
     getRetentionStats,
-    initializeIDCounters,
-    allocateNextID,
-    flushIDCounters,
     testHooks,
   });
 }

package/src/watchedPromises.js

@@ -147,12 +147,6 @@ export function makeWatchedPromiseManager({
     }
   }
 
-  /**
-   *
-   * @param {Promise} p
-   * @param {{onFulfilled?: Function, onRejected?: Function}} watcher
-   * @param  {...any} args
-   */
   function watchPromise(p, watcher, ...args) {
     // The following wrapping defers setting up the promise watcher itself to a
     // later turn so that if the promise to be watched was the return value from

package/test/gc-helpers.js

@@ -2,7 +2,7 @@
 
 import { Far } from '@endo/marshal';
 import { M } from '@agoric/store';
-import { kslot, kser } from '@agoric/kmarshal';
+import { kslot, kser } from './kmarshal.js';
 import { parseVatSlot } from '../src/parseVatSlots.js';
 
 // These tests follow the model described in

package/test/kmarshal.js

@@ -0,0 +1,79 @@
+import { Far, makeMarshal, passStyleOf } from '@endo/marshal';
+import { assert } from '@agoric/assert';
+
+// Simple wrapper for serializing and unserializing marshalled values inside the
+// kernel, where we don't actually want to use clists nor actually allocate real
+// objects, but instead to stay entirely within the domain of krefs.  This is
+// used to enable syntactic manipulation of serialized values while remaining
+// agnostic about the internal details of the serialization encoding.
+
+const refMap = new WeakMap();
+
+export const kslot = (kref, iface) => {
+  assert.typeof(kref, 'string');
+  if (iface && iface.startsWith('Alleged: ')) {
+    // Encoder prepends "Alleged: " to iface string, but the decoder doesn't strip it
+    // Unclear whether it's the decoder or me who is wrong
+    iface = iface.slice(9);
+  }
+  if (
+    kref.startsWith('p') ||
+    kref.startsWith('kp') ||
+    kref.startsWith('lp') ||
+    kref.startsWith('rp')
+  ) {
+    // TODO: temporary hack because smallcaps encodes promise references
+    // differently from remotable object references, and the current version of
+    // the smallcaps decoder annoyingly insists that if the encoded body string
+    // says a slot is a promise, then convertSlotToVal had better by damn return
+    // an actual Promise, even if, as in the intended use case here, we neither
+    // want nor need a promise, nor the overhead of a map to keep track of it
+    // with.  This behavior is in service of defense against a hypothesized
+    // security issue whose exact nature has largely been forgotton in the
+    // months since it was first encountered.  MarkM is currently researching
+    // what the problem was thought to have been, to see if it is real and to
+    // understand it if so.  This will eventually result in either changes to
+    // the smallcaps encoding or to the marshal setup API to support the purely
+    // manipulative use case.  In the meantime, this ugliness...
+    const p = new Promise(() => undefined);
+    refMap.set(p, kref);
+    return harden(p);
+  } else {
+    const o = Far(iface, {
+      iface: () => iface,
+      getKref: () => `${kref}`,
+    });
+    return o;
+  }
+};
+
+export const krefOf = obj => {
+  const fromMap = refMap.get(obj);
+  if (fromMap) {
+    return fromMap;
+  }
+  // When krefOf() is called as part of kmarshal.serialize, marshal
+  // will only give it things that are 'remotable' (Promises and the
+  // Far objects created by kslot()).  When krefOf() is called by
+  // kernel code (as part of extractSingleSlot() or the vat-comms
+  // equivalent), it ought to throw if 'obj' is not one of the Far
+  // objects created by our kslot().
+  assert.equal(passStyleOf(obj), 'remotable', obj);
+  const getKref = obj.getKref;
+  assert.typeof(getKref, 'function');
+  return getKref();
+};
+
+const kmarshal = makeMarshal(krefOf, kslot, {
+  serializeBodyFormat: 'smallcaps',
+  errorTagging: 'off',
+});
+
+export const kser = value => kmarshal.serialize(harden(value));
+
+export const kunser = serializedValue => kmarshal.unserialize(serializedValue);
+
+export function makeError(message) {
+  assert.typeof(message, 'string');
+  return kser(Error(message));
+}

package/test/liveslots-helpers.js

@@ -1,7 +1,6 @@
 /* global WeakRef, FinalizationRegistry */
-import { kser } from '@agoric/kmarshal';
-
 import engineGC from './engine-gc.js';
+
 import { waitUntilQuiescent } from './waitUntilQuiescent.js';
 import { makeGcAndFinalize } from './gc-and-finalize.js';
 import { makeDummyMeterControl } from './dummyMeterControl.js';
@@ -13,11 +12,12 @@ import {
   makeRetireExports,
   makeBringOutYourDead,
 } from './util.js';
+import { kser } from './kmarshal.js';
 
 /**
  * @param {object} [options]
- * @param {boolean} [options.skipLogging]
- * @param {Map<string, string>} [options.kvStore]
+ * @param {boolean} [options.skipLogging = false]
+ * @param {Map<string, string>} [options.kvStore = new Map()]
  */
 export function buildSyscall(options = {}) {
   const { skipLogging = false, kvStore: fakestore = new Map() } = options;
@@ -168,9 +168,9 @@ function makeRPMaker(nextNumber = 1) {
  * @param {string} vatName
  * @param {object} [options]
  * @param {boolean} [options.forceGC]
- * @param {Map<string, string>} [options.kvStore]
+ * @param {Map<string, string>} [options.kvStore = new Map()]
  * @param {number} [options.nextPromiseImportNumber]
- * @param {boolean} [options.skipLogging]
+ * @param {boolean} [options.skipLogging = false]
  */
 export async function setupTestLiveslots(
   t,

package/test/mock-gc.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { waitUntilQuiescent } from './waitUntilQuiescent.js';
 import { makeDummyMeterControl } from './dummyMeterControl.js';
 

package/test/storeGC/test-lifecycle.js

@@ -1,12 +1,12 @@
-// @ts-nocheck
 import test from 'ava';
+import '@endo/init/debug.js';
 
-import { kslot, kunser } from '@agoric/kmarshal';
 import {
   setupTestLiveslots,
   findSyscallsByType,
 } from '../liveslots-helpers.js';
 import { buildRootObject, mainHeldIdx, mapRef } from '../gc-helpers.js';
+import { kslot, kunser } from '../kmarshal.js';
 import { parseVatSlot } from '../../src/parseVatSlots.js';
 
 // These tests follow the model described in

package/test/storeGC/test-refcount-management.js

@@ -1,6 +1,6 @@
 import test from 'ava';
+import '@endo/init/debug.js';
 
-import { kslot } from '@agoric/kmarshal';
 import {
   findSyscallsByType,
   setupTestLiveslots,
@@ -12,6 +12,7 @@ import {
   refValString,
   assertCollectionDeleted,
 } from '../gc-helpers.js';
+import { kslot } from '../kmarshal.js';
 import { vstr } from '../util.js';
 
 // These tests follow the model described in

package/test/storeGC/test-scalar-store-kind.js

@@ -1,4 +1,5 @@
 import test from 'ava';
+import '@endo/init/debug.js';
 
 import { setupTestLiveslots } from '../liveslots-helpers.js';
 import { buildRootObject, mapRef } from '../gc-helpers.js';

package/test/storeGC/test-weak-key.js

@@ -1,6 +1,6 @@
 import test from 'ava';
+import '@endo/init/debug.js';
 
-import { kslot } from '@agoric/kmarshal';
 import { setupTestLiveslots } from '../liveslots-helpers.js';
 import {
   buildRootObject,
@@ -8,6 +8,7 @@ import {
   assertCollectionDeleted,
   deduceCollectionID,
 } from '../gc-helpers.js';
+import { kslot } from '../kmarshal.js';
 import { vstr } from '../util.js';
 
 // These tests follow the model described in test-virtualObjectGC.js