@agoric/swingset-liveslots 0.10.3-u16.1 → 0.10.3-u17.0

package/test/handled-promises.test.js

@@ -1,7 +1,7 @@
 import test from 'ava';
 
+import { Fail } from '@endo/errors';
 import { Far } from '@endo/marshal';
-import { Fail } from '@agoric/assert';
 import { M, provideLazy as provide } from '@agoric/store';
 import { makePromiseKit } from '@endo/promise-kit';
 // Disabled to avoid circular dependencies.
@@ -84,7 +84,7 @@ const makeExoUtils = VatData => {
 };
 
 // cf. packages/SwingSet/test/vat-durable-promise-watcher.js
-const buildPromiseWatcherRootObject = (vatPowers, _vatParameters, baggage) => {
+const buildPromiseWatcherRootObject = (vatPowers, vatParameters, baggage) => {
   const { VatData } = vatPowers;
   const { watchPromise } = VatData;
   const { prepareExo } = makeExoUtils(VatData);
@@ -93,37 +93,62 @@ const buildPromiseWatcherRootObject = (vatPowers, _vatParameters, baggage) => {
     onFulfilled: M.call(M.any(), M.string()).returns(),
     onRejected: M.call(M.any(), M.string()).returns(),
   });
+  const watchResolutions = new Map();
   const watcher = prepareExo(
     baggage,
+    // No longer ignoring, but the name is set in stone in `kvStoreDataV1`
     'DurablePromiseIgnorer',
     PromiseWatcherI,
     {
-      onFulfilled(_value, _name) {},
-      onRejected(_reason, _name) {},
+      onFulfilled(value, name) {
+        watchResolutions.set(name, { status: 'fulfilled', value });
+      },
+      onRejected(reason, name) {
+        watchResolutions.set(name, { status: 'rejected', reason });
+      },
     },
   );
 
-  const localPromises = new Map();
+  const knownPromises = new Map();
 
-  return Far('root', {
-    exportPromise: () => [Promise.resolve()],
+  const root = Far('root', {
+    getPromise: name => {
+      const promise = knownPromises.get(name);
+      promise || Fail`promise doesn't exists: ${name}`;
+      return { promise };
+    },
+    importPromise: (name, promise) => {
+      !knownPromises.has(name) || Fail`promise already exists: ${name}`;
+      knownPromises.set(name, promise);
+      return `imported promise: ${name}`;
+    },
     createLocalPromise: (name, fulfillment, rejection) => {
-      !localPromises.has(name) || Fail`local promise already exists: ${name}`;
+      !knownPromises.has(name) || Fail`promise already exists: ${name}`;
       const { promise, resolve, reject } = makePromiseKit();
       if (fulfillment !== undefined) {
         resolve(fulfillment);
       } else if (rejection !== undefined) {
         reject(rejection);
       }
-      localPromises.set(name, promise);
+      knownPromises.set(name, promise);
       return `created local promise: ${name}`;
     },
-    watchLocalPromise: name => {
-      localPromises.has(name) || Fail`local promise not found: ${name}`;
-      watchPromise(localPromises.get(name), watcher, name);
-      return `watched local promise: ${name}`;
+    watchPromise: name => {
+      knownPromises.has(name) || Fail`promise not found: ${name}`;
+      watchPromise(knownPromises.get(name), watcher, name);
+      return `watched promise: ${name}`;
+    },
+    getWatchResolution: name => {
+      return watchResolutions.get(name);
     },
   });
+
+  const startOperations = vatParameters?.startOperations || [];
+  for (const [method, ...args] of startOperations) {
+    root[method](...args);
+  }
+
+  return root;
 };
 const kvStoreDataV1 = Object.entries({
   baggageID: 'o+d6/1',
@@ -176,23 +201,55 @@ const kvStoreDataV1VpidsToKeep = ['p-8'];
 const kvStoreDataV1KeysToKeep = ['vc.4.sp-8'];
 
 test('past-incarnation watched promises', async t => {
+  const S = 'settlement';
+  // Anchor promise counters upon which the other assertions depend.
+  const firstPImport = 9;
+  // cf. src/liveslots.js:initialIDCounters
+  const firstPExport = 5;
+
+  const startImportedP = firstPImport - 2;
+
+  const v1StartOperations = [
+    ['createLocalPromise', 'start orphaned'],
+    ['watchPromise', 'start orphaned'],
+    ['createLocalPromise', 'start fulfilled', S],
+    ['watchPromise', 'start fulfilled'],
+    ['importPromise', 'start imported', kslot(`p-${startImportedP}`)],
+    ['watchPromise', 'start imported'],
+  ];
   const kvStore = new Map();
-  let { v, dispatch, dispatchMessage } = await setupTestLiveslots(
+  let {
+    v,
+    dispatch,
+    dispatchMessage: rawDispatch,
+  } = await setupTestLiveslots(
     t,
     buildPromiseWatcherRootObject,
     'durable-promise-watcher',
-    { kvStore },
+    {
+      kvStore,
+      nextPromiseImportNumber: firstPImport,
+      vatParameters: { startOperations: v1StartOperations },
+    },
   );
   let vatLogs = v.log;
 
-  // Anchor promise counters upon which the other assertions depend.
-  const firstPImport = 1;
-  // cf. src/liveslots.js:initialIDCounters
-  const firstPExport = 5;
   let lastPImport = firstPImport - 1;
   let lastPExport = firstPExport - 1;
+  let dispatches = 0;
+  const exportedPromises = new Set();
+  const v1OrphanedPExports = [];
   const nextPImport = () => (lastPImport += 1);
   const nextPExport = () => (lastPExport += 1);
+  /** @type {typeof rawDispatch} */
+  const dispatchMessage = (...args) => {
+    dispatches += 1;
+    return rawDispatch(...args);
+  };
+  const recordExportedPromise = name => {
+    exportedPromises.add(name);
+    return name;
+  };
   // Ignore vatstore syscalls.
   const getDispatchLogs = () =>
     vatLogs.splice(0).filter(m => !m.type.startsWith('vatstore'));
@@ -208,18 +265,55 @@ test('past-incarnation watched promises', async t => {
     type: 'subscribe',
     target: vpid,
   });
-  vatLogs.length = 0;
-  await dispatchMessage('exportPromise');
+
+  // startVat logs
+  v1OrphanedPExports.push(nextPExport());
+  recordExportedPromise('start orphaned');
+  v1OrphanedPExports.push(nextPExport());
+  recordExportedPromise('start fulfilled');
   t.deepEqual(getDispatchLogs(), [
-    fulfillmentMessage(`p-${nextPImport()}`, [kslot(`p+${nextPExport()}`)]),
-    fulfillmentMessage(`p+${lastPExport}`, undefined),
+    subscribeMessage(`p-${startImportedP}`),
+    subscribeMessage(`p+${lastPExport - 1}`),
+    subscribeMessage(`p+${lastPExport}`),
+    fulfillmentMessage(`p+${lastPExport}`, S),
+  ]);
+  await dispatchMessage('createLocalPromise', 'exported', S);
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: exported'),
+  ]);
+  await dispatchMessage('getPromise', recordExportedPromise('exported'));
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      promise: kslot(`p+${nextPExport()}`),
+    }),
+    fulfillmentMessage(`p+${lastPExport}`, S),
+  ]);
+  const importedP = firstPImport - 1;
+  await dispatchMessage('importPromise', 'imported', kslot(`p-${importedP}`));
+  t.deepEqual(getDispatchLogs(), [
+    subscribeMessage(`p-${importedP}`),
+    fulfillmentMessage(`p-${nextPImport()}`, 'imported promise: imported'),
   ]);
-
-  const S = 'settlement';
   await dispatchMessage('createLocalPromise', 'orphaned');
   t.deepEqual(getDispatchLogs(), [
     fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: orphaned'),
   ]);
+  await dispatchMessage('createLocalPromise', 'orphaned exported');
+  await dispatchMessage(
+    'getPromise',
+    recordExportedPromise('orphaned exported'),
+  );
+  const orphanedExportedP = nextPExport();
+  v1OrphanedPExports.push(orphanedExportedP);
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(
+      `p-${nextPImport()}`,
+      'created local promise: orphaned exported',
+    ),
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      promise: kslot(`p+${orphanedExportedP}`),
+    }),
+  ]);
   await dispatchMessage('createLocalPromise', 'fulfilled', S);
   t.deepEqual(getDispatchLogs(), [
     fulfillmentMessage(
@@ -233,68 +327,185 @@ test('past-incarnation watched promises', async t => {
   ]);
   t.is(
     lastPImport - firstPImport + 1,
-    4,
-    'imported 4 promises (1 per dispatch)',
+    dispatches,
+    `imported ${dispatches} promises (1 per dispatch)`,
+  );
+  t.is(
+    lastPExport - firstPExport + 1,
+    exportedPromises.size,
+    `exported ${exportedPromises.size} promises: ${[...exportedPromises].join(', ')}`,
   );
-  t.is(lastPExport - firstPExport + 1, 1, 'exported 1 promise: first');
 
-  await dispatchMessage('watchLocalPromise', 'orphaned');
+  await dispatchMessage('watchPromise', recordExportedPromise('orphaned'));
+  v1OrphanedPExports.push(nextPExport());
   t.deepEqual(getDispatchLogs(), [
-    subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched local promise: orphaned'),
+    subscribeMessage(`p+${lastPExport}`),
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: orphaned'),
   ]);
-  await dispatchMessage('watchLocalPromise', 'fulfilled');
+  await dispatchMessage('watchPromise', recordExportedPromise('fulfilled'));
   t.deepEqual(getDispatchLogs(), [
     subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(
-      `p-${nextPImport()}`,
-      'watched local promise: fulfilled',
-    ),
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: fulfilled'),
     fulfillmentMessage(`p+${lastPExport}`, S),
   ]);
-  await dispatchMessage('watchLocalPromise', 'rejected');
+  await dispatchMessage('watchPromise', recordExportedPromise('rejected'));
   t.deepEqual(getDispatchLogs(), [
     subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched local promise: rejected'),
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: rejected'),
     rejectionMessage(`p+${lastPExport}`, S),
   ]);
+  await dispatchMessage('watchPromise', 'imported');
+  t.deepEqual(getDispatchLogs(), [
+    // no subscribe, we already did at import
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: imported'),
+  ]);
+  await dispatchMessage('getWatchResolution', 'fulfilled');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: S,
+    }),
+  ]);
+  await dispatchMessage('getWatchResolution', 'rejected');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'rejected',
+      reason: S,
+    }),
+  ]);
+  await dispatchMessage('getWatchResolution', 'start fulfilled');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: S,
+    }),
+  ]);
+
   t.is(
     lastPImport - firstPImport + 1,
-    7,
-    'imported 7 promises (1 per dispatch)',
+    dispatches,
+    `imported ${dispatches} promises (1 per dispatch)`,
   );
   t.is(
     lastPExport - firstPExport + 1,
-    4,
-    'exported 4 promises: first, orphaned, fulfilled, rejected',
+    exportedPromises.size,
+    `exported ${exportedPromises.size} promises: ${[...exportedPromises].join(', ')}`,
   );
 
   // Simulate upgrade by starting from the non-empty kvStore.
   // t.log(Object.fromEntries([...kvStore.entries()].sort(compareEntriesByKey)));
   const clonedStore = new Map(kvStore);
-  ({ v, dispatch, dispatchMessage } = await setupTestLiveslots(
+  const startImported2P = firstPImport - 3;
+  const v2StartOperations = [
+    ['importPromise', 'start imported 2', kslot(`p-${startImported2P}`)], // import of new promise
+    ['importPromise', 'imported', kslot(`p-${importedP}`)], // import previously imported and watched promise
+    ['importPromise', 'orphaned exported', kslot(`p+${orphanedExportedP}`)], // import previously exported but unwatched promise
+    ['watchPromise', 'orphaned exported'],
+  ];
+  ({
+    v,
+    dispatch,
+    dispatchMessage: rawDispatch,
+  } = await setupTestLiveslots(
     t,
     buildPromiseWatcherRootObject,
     'durable-promise-watcher-v2',
-    { kvStore: clonedStore, nextPromiseImportNumber: lastPImport + 1 },
+    {
+      kvStore: clonedStore,
+      nextPromiseImportNumber: lastPImport + 1,
+      vatParameters: { startOperations: v2StartOperations },
+    },
   ));
   vatLogs = v.log;
 
+  // startVat logs
+  t.deepEqual(getDispatchLogs(), [
+    subscribeMessage(`p-${startImported2P}`),
+    subscribeMessage(`p-${importedP}`),
+    subscribeMessage(`p+${orphanedExportedP}`),
+  ]);
   // Simulate kernel rejection of promises orphaned by termination/upgrade of their decider vat.
   const expectedDeletions = [...clonedStore.entries()].filter(entry =>
     entry[1].includes('orphaned'),
   );
   t.true(expectedDeletions.length >= 1);
-  await dispatch(
-    makeReject(`p+${firstPExport + 1}`, kser('tomorrow never came')),
-  );
+  for (const orphanedPExport of v1OrphanedPExports) {
+    await dispatch(
+      makeReject(`p+${orphanedPExport}`, kser('tomorrow never came')),
+    );
+  }
+  await dispatchMessage('getWatchResolution', 'orphaned');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'rejected',
+      reason: 'tomorrow never came',
+    }),
+  ]);
+  await dispatchMessage('getWatchResolution', 'start orphaned');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'rejected',
+      reason: 'tomorrow never came',
+    }),
+  ]);
+  await dispatchMessage('getWatchResolution', 'orphaned exported');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'rejected',
+      reason: 'tomorrow never came',
+    }),
+  ]);
   for (const [key, value] of expectedDeletions) {
     t.false(clonedStore.has(key), `entry should be removed: ${key}: ${value}`);
   }
+  // Simulate resolution of imported promises watched in previous incarnation
+  await dispatch(makeResolve(`p-${importedP}`, kser(undefined)));
+  await dispatchMessage('getWatchResolution', 'imported');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: undefined,
+    }),
+  ]);
+  await dispatch(makeResolve(`p-${startImportedP}`, kser(undefined)));
+  await dispatchMessage('getWatchResolution', 'start imported');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: undefined,
+    }),
+  ]);
+  await dispatch(makeResolve(`p-${startImported2P}`, kser(undefined)));
+  await dispatchMessage('getWatchResolution', 'start imported 2');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, undefined),
+  ]);
+  // simulate resolution of imported promise watched after resolution
+  await dispatchMessage('watchPromise', 'start imported 2');
+  t.deepEqual(getDispatchLogs(), [
+    // Promise was previously resolved, so it is re-exported
+    subscribeMessage(`p+${nextPExport()}`),
+    fulfillmentMessage(
+      `p-${nextPImport()}`,
+      'watched promise: start imported 2',
+    ),
+    fulfillmentMessage(`p+${lastPExport}`, undefined),
+  ]);
+  await dispatchMessage('getWatchResolution', 'start imported 2');
+  t.deepEqual(getDispatchLogs(), [
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: undefined,
+    }),
+  ]);
 
   // Verify that the data is still in loadable condition.
   const finalClonedStore = new Map(clonedStore);
-  ({ v, dispatch, dispatchMessage } = await setupTestLiveslots(
+  ({
+    v,
+    dispatch,
+    dispatchMessage: rawDispatch,
+  } = await setupTestLiveslots(
     t,
     buildPromiseWatcherRootObject,
     'durable-promise-watcher-final',
@@ -303,12 +514,17 @@ test('past-incarnation watched promises', async t => {
   vatLogs = v.log;
   vatLogs.length = 0;
   await dispatchMessage('createLocalPromise', 'final', S);
-  await dispatchMessage('watchLocalPromise', 'final');
+  await dispatchMessage('watchPromise', 'final');
+  await dispatchMessage('getWatchResolution', 'final');
   t.deepEqual(getDispatchLogs(), [
     fulfillmentMessage(`p-${nextPImport()}`, 'created local promise: final'),
     subscribeMessage(`p+${nextPExport()}`),
-    fulfillmentMessage(`p-${nextPImport()}`, 'watched local promise: final'),
+    fulfillmentMessage(`p-${nextPImport()}`, 'watched promise: final'),
     fulfillmentMessage(`p+${lastPExport}`, S),
+    fulfillmentMessage(`p-${nextPImport()}`, {
+      status: 'fulfilled',
+      value: S,
+    }),
   ]);
 });
 

package/test/liveslots-helpers.js

@@ -131,6 +131,7 @@ export async function makeDispatch(
   build,
   vatID = 'vatA',
   liveSlotsOptions = {},
+  vatParameters = undefined,
 ) {
   const gcTools = harden({
     WeakRef,
@@ -150,7 +151,7 @@ export async function makeDispatch(
       return { buildRootObject: build };
     },
   );
-  await dispatch(['startVat', kser()]);
+  await dispatch(['startVat', kser(vatParameters)]);
   return { dispatch, testHooks };
 }
 
@@ -171,6 +172,7 @@ function makeRPMaker(nextNumber = 1) {
  * @param {Map<string, string>} [options.kvStore]
  * @param {number} [options.nextPromiseImportNumber]
  * @param {boolean} [options.skipLogging]
+ * @param {any} [options.vatParameters]
  */
 export async function setupTestLiveslots(
   t,
@@ -183,6 +185,7 @@ export async function setupTestLiveslots(
     kvStore = new Map(),
     nextPromiseImportNumber,
     skipLogging = false,
+    vatParameters,
   } = options;
   const { log, syscall, fakestore } = buildSyscall({ skipLogging, kvStore });
   const nextRP = makeRPMaker(nextPromiseImportNumber);
@@ -190,6 +193,8 @@ export async function setupTestLiveslots(
     syscall,
     buildRootObject,
     vatName,
+    {},
+    vatParameters,
   );
 
   async function dispatchMessage(message, ...args) {

package/test/liveslots-mock-gc.test.js

@@ -11,6 +11,7 @@ import {
   makeStartVat,
   makeBringOutYourDead,
   makeResolve,
+  makeRetireImports,
 } from './util.js';
 import { makeMockGC } from './mock-gc.js';
 
@@ -465,3 +466,101 @@ for (const firstType of ['object', 'collection']) {
 }
 
 // test('double-free', doublefreetest, { firstType: 'object', lastType: 'collection', order: 'first->last' });
+
+test('retirement', async t => {
+  const { syscall, fakestore, log } = buildSyscall();
+  const gcTools = makeMockGC();
+
+  // A is a weak collection, with one entry, whose key is B (a
+  // Presence). We drop the RAM pillar for B and do a BOYD, which
+  // should provoke a syscall.dropImports. Then, when we delete A (by
+  // dropping the RAM pillar), the next BOYD should see a
+  // `syscall.retireImports`.
+
+  let weakmapA;
+  let presenceB;
+
+  function buildRootObject(vatPowers) {
+    const { VatData } = vatPowers;
+    const { makeScalarBigWeakMapStore } = VatData;
+
+    weakmapA = makeScalarBigWeakMapStore();
+
+    return Far('root', {
+      add: p => {
+        presenceB = p;
+        weakmapA.init(presenceB, 'value');
+      },
+    });
+  }
+
+  const makeNS = () => ({ buildRootObject });
+  const ls = makeLiveSlots(syscall, 'vatA', {}, {}, gcTools, undefined, makeNS);
+  const { dispatch, testHooks } = ls;
+  const { valToSlot } = testHooks;
+
+  await dispatch(makeStartVat(kser()));
+  log.length = 0;
+  const weakmapAvref = valToSlot.get(weakmapA);
+  const { subid } = parseVatSlot(weakmapAvref);
+  const collectionID = String(subid);
+
+  const rootA = 'o+0';
+  const presenceBvref = 'o-1';
+  await dispatch(makeMessage(rootA, 'add', [kslot(presenceBvref)]));
+  log.length = 0;
+
+  // the fact that weakmapA can recognize presenceA is recorded in a
+  // vatstore key
+  const recognizerKey = `vom.ir.${presenceBvref}|${collectionID}`;
+  t.is(fakestore.get(recognizerKey), '1');
+
+  // tell mockGC that userspace has dropped presenceB
+  gcTools.kill(presenceB);
+  gcTools.flushAllFRs();
+
+  await dispatch(makeBringOutYourDead());
+  const priorKey = `vom.ir.${presenceBvref}|`;
+
+  t.deepEqual(log.splice(0), [
+    // when a Presence is dropped, scanForDeadObjects can't drop the
+    // underlying vref import until it knows that virtual data isn't
+    // holding a reference, so we expect a refcount check
+    { type: 'vatstoreGet', key: `vom.rc.${presenceBvref}`, result: undefined },
+
+    // the vref is now in importsToDrop, but since this commonly means
+    // it can be retired too, scanForDeadObjects goes ahead and checks
+    // for recognizers
+    { type: 'vatstoreGetNextKey', priorKey, result: recognizerKey },
+
+    // it found a recognizer, so the vref cannot be retired
+    // yet. scanForDeadObjects finishes the BOYD by emitting the
+    // dropImports, but should keep watching for an opportunity to
+    // retire it too
+    { type: 'dropImports', slots: [presenceBvref] },
+  ]);
+
+  // now tell mockGC that we're dropping the weakmap too
+  gcTools.kill(weakmapA);
+  gcTools.flushAllFRs();
+
+  // this will provoke the deletion of the collection and all its
+  // data. It should *also* trigger a syscall.retireImports of the
+  // no-longer-recognizable key
+  await dispatch(makeBringOutYourDead());
+  const retires = log.filter(e => e.type === 'retireImports');
+
+  t.deepEqual(retires, [{ type: 'retireImports', slots: [presenceBvref] }]);
+
+  // If the bug is present, the vat won't send `syscall.retireImports`
+  // to the kernel. In a full system, that means the kernel can
+  // eventually send a `dispatch.retireImports` into the vat, if/when
+  // the object's hosting vat decides to drop it. Make sure that won't
+  // cause a crash.
+
+  if (!retires.length) {
+    console.log(`testing kernel's dispatch.retireImports`);
+    await dispatch(makeRetireImports(presenceBvref));
+    console.log(`dispatch.retireImports did not crash`);
+  }
+});

package/test/liveslots-real-gc.test.js

@@ -308,6 +308,14 @@ test.serial('GC dispatch.dropExports', async t => {
   // that should allow ex1 to be collected
   t.true(collected.result);
 
+  // upon collection, the vat should scan for local recognizers (weak
+  // collection keys) in case any need to be dropped, and find none
+  t.deepEqual(log.shift(), {
+    type: 'vatstoreGetNextKey',
+    priorKey: `vom.ir.${ex1}|`,
+    result: 'vom.rc.o+d6/1',
+  });
+
   // and once it's collected, the vat should emit `syscall.retireExport`
   // because nobody else will be able to recognize it again
   const l2 = log.shift();
@@ -394,8 +402,16 @@ test.serial(
     // which should let the export be collected
     t.true(collected.result);
 
-    // the vat should *not* emit `syscall.retireExport`, because it already
-    // received a dispatch.retireExport
+    // the vat should scan for local recognizers (weak collection
+    // keys) in case any need to be dropped, and find none
+    t.deepEqual(log.shift(), {
+      type: 'vatstoreGetNextKey',
+      priorKey: 'vom.ir.o+10|',
+      result: 'vom.rc.o+d6/1',
+    });
+
+    // the vat should *not* emit `syscall.retireExport`, because it
+    // already received a dispatch.retireExport
     t.deepEqual(log, []);
   },
 );

package/test/liveslots.test.js

@@ -1,10 +1,10 @@
 // @ts-nocheck
 import test from 'ava';
 
+import { Fail } from '@endo/errors';
 import { E } from '@endo/eventual-send';
 import { Far } from '@endo/marshal';
 import { makePromiseKit } from '@endo/promise-kit';
-import { Fail } from '@agoric/assert';
 import { kslot, kser, kunser } from '@agoric/kmarshal';
 import { M } from '@agoric/store';
 import { makeLiveSlots, makeMarshaller } from '../src/liveslots.js';