@agoric/swingset-liveslots 0.10.3-other-dev-8f8782b.0 → 0.10.3-other-dev-fbe72e7.0.fbe72e7

package/test/{test-initial-vrefs.js → initial-vrefs.test.js}

@@ -1,10 +1,9 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/far';
+import { kunser } from '@agoric/kmarshal';
 import { M } from '@agoric/store';
 import { setupTestLiveslots } from './liveslots-helpers.js';
-import { kunser } from './kmarshal.js';
 
 function buildRootObject(vatPowers, vatParameters, baggage) {
   const vd = vatPowers.VatData;
@@ -71,34 +70,28 @@ test('initial vatstore contents', async t => {
   t.deepEqual(kunser(JSON.parse(get(`vc.1.|schemata`))), stringSchema);
 
   // then three tables for the promise watcher (one virtual, two durable)
-  t.is(getLabel(`vc.3.|schemata`), 'promiseWatcherByKind'); // durable
-  t.is(getLabel(`vc.4.|schemata`), 'watchedPromises'); // durable
-  // the promiseRegistrations table is not durable, and only gets vc.2
-  // on the first incarnation: it will get a new ID on subsequent
-  // incarnations
-  t.is(getLabel(`vc.2.|schemata`), `promiseRegistrations`); // virtual
+  t.is(getLabel(`vc.2.|schemata`), 'promiseWatcherByKind'); // durable
+  t.is(getLabel(`vc.3.|schemata`), 'watchedPromises'); // durable
 
   const watcherTableVref = get('watcherTableID');
   const watchedPromiseTableVref = get('watchedPromiseTableID');
-  t.is(watcherTableVref, `${dmsBase}/3`);
-  t.is(watchedPromiseTableVref, `${dmsBase}/4`);
+  t.is(watcherTableVref, `${dmsBase}/2`);
+  t.is(watchedPromiseTableVref, `${dmsBase}/3`);
 
   // baggage and the two durable promise-watcher tables are pinned
   t.is(get(`vom.rc.${baggageVref}`), '1');
   t.is(get(`vom.rc.${watcherTableVref}`), '1');
   t.is(get(`vom.rc.${watchedPromiseTableVref}`), '1');
 
-  // promiseRegistrations and promiseWatcherByKind arbitrary scalars as keys
-  const scalarSchema2 = { label: 'promiseRegistrations', keyShape: M.scalar() };
+  // promiseWatcherByKind arbitrary scalars as keys
   const scalarSchema3 = { label: 'promiseWatcherByKind', keyShape: M.scalar() };
-  t.deepEqual(kunser(JSON.parse(get(`vc.2.|schemata`))), scalarSchema2);
-  t.deepEqual(kunser(JSON.parse(get(`vc.3.|schemata`))), scalarSchema3);
+  t.deepEqual(kunser(JSON.parse(get(`vc.2.|schemata`))), scalarSchema3);
   // watchedPromises uses vref (string) keys
   const scalarStringSchema = {
     label: 'watchedPromises',
     keyShape: M.and(M.scalar(), M.string()),
   };
-  t.deepEqual(kunser(JSON.parse(get(`vc.4.|schemata`))), scalarStringSchema);
+  t.deepEqual(kunser(JSON.parse(get(`vc.3.|schemata`))), scalarStringSchema);
 });
 
 test('vrefs', async t => {
@@ -142,11 +135,11 @@ test('vrefs', async t => {
   const dh2Vref = (await run('getDinstance2')).slots[0];
   t.is(dh2Vref, expectedDH2Vref);
 
-  // the liveslots-created collections consume vc.1 through vc.4,
-  // leaving vc.5 for the first user-created collection
-  t.is(getLabel('vc.5.|schemata'), 'store1');
-  const expectedStore1Vref = `o+v${initialKindIDs.scalarMapStore}/5`;
+  // the liveslots-created collections consume vc.1 through vc.3,
+  // leaving vc.4 for the first user-created collection
+  t.is(getLabel('vc.4.|schemata'), 'store1');
+  const expectedStore1Vref = `o+v${initialKindIDs.scalarMapStore}/4`;
   const store1Vref = (await run('getStore1')).slots[0];
   t.is(store1Vref, expectedStore1Vref);
-  t.deepEqual(kunser(JSON.parse(fakestore.get(`vc.5.s${'key'}`))), 'value');
+  t.is(kunser(JSON.parse(fakestore.get(`vc.4.s${'key'}`))), 'value');
 });

package/test/liveslots-helpers.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @param {object} [options]
+ * @param {boolean} [options.skipLogging]
+ * @param {Map<string, string>} [options.kvStore]
+ */
+export function buildSyscall(options?: {
+    skipLogging?: boolean | undefined;
+    kvStore?: Map<string, string> | undefined;
+}): {
+    syscall: {
+        send(targetSlot: any, methargs: any, resultSlot: any): void;
+        subscribe(target: any): void;
+        resolve(resolutions: any): void;
+        dropImports(slots: any): void;
+        retireImports(slots: any): void;
+        retireExports(slots: any): void;
+        exit(isFailure: any, info: any): void;
+        vatstoreGet(key: any): any;
+        vatstoreGetNextKey(priorKey: any): any;
+        vatstoreSet(key: any, value: any): void;
+        vatstoreDelete(key: any): void;
+    };
+    fakestore: Map<any, any>;
+    log: any[];
+};
+export function makeDispatch(syscall: any, build: any, vatID?: string, liveSlotsOptions?: {}, vatParameters?: undefined): Promise<{
+    dispatch: any;
+    testHooks: any;
+}>;
+/**
+ * @param {import('ava').ExecutionContext} t
+ * @param {Function} buildRootObject
+ * @param {string} vatName
+ * @param {object} [options]
+ * @param {boolean} [options.forceGC]
+ * @param {Map<string, string>} [options.kvStore]
+ * @param {number} [options.nextPromiseImportNumber]
+ * @param {boolean} [options.skipLogging]
+ * @param {any} [options.vatParameters]
+ */
+export function setupTestLiveslots(t: import("ava").ExecutionContext, buildRootObject: Function, vatName: string, options?: {
+    forceGC?: boolean | undefined;
+    kvStore?: Map<string, string> | undefined;
+    nextPromiseImportNumber?: number | undefined;
+    skipLogging?: boolean | undefined;
+    vatParameters?: any;
+}): Promise<{
+    v: {
+        t: import("ava").ExecutionContext<unknown>;
+        log: any[];
+        fakestore: Map<any, any>;
+        dumpFakestore: () => void;
+    };
+    dispatch: any;
+    dispatchMessage: (message: any, ...args: any[]) => Promise<string>;
+    dispatchMessageSuccessfully: (message: any, ...args: any[]) => Promise<any>;
+    dispatchDropExports: (...vrefs: any[]) => Promise<void>;
+    dispatchRetireExports: (...vrefs: any[]) => Promise<void>;
+    dispatchRetireImports: (...vrefs: any[]) => Promise<void>;
+    nextPImport: () => string;
+    testHooks: any;
+}>;
+export function findSyscallsByType(log: any, type: any): any;
+//# sourceMappingURL=liveslots-helpers.d.ts.map

package/test/liveslots-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveslots-helpers.d.ts","sourceRoot":"","sources":["liveslots-helpers.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,uCAHG;IAA0B,WAAW;IACC,OAAO;CAAC;;;;;;;;;;;;;;;;EA2GhD;AAED;;;GA2BC;AAUD;;;;;;;;;;GAUG;AACH,sCAVW,OAAO,KAAK,EAAE,gBAAgB,sCAE9B,MAAM,YAEd;IAA0B,OAAO;IACK,OAAO;IACpB,uBAAuB;IACtB,WAAW;IACf,aAAa,GAA3B,GAAG;CAAyB;;;;;;;;;;;;;;;GA6GtC;AAED,6DAEC"}

package/test/liveslots-helpers.js

@@ -1,6 +1,7 @@
 /* global WeakRef, FinalizationRegistry */
-import engineGC from './engine-gc.js';
+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';
@@ -12,12 +13,11 @@ import {
   makeRetireExports,
   makeBringOutYourDead,
 } from './util.js';
-import { kser } from './kmarshal.js';
 
 /**
  * @param {object} [options]
- * @param {boolean} [options.skipLogging = false]
- * @param {Map<string, string>} [options.kvStore = new Map()]
+ * @param {boolean} [options.skipLogging]
+ * @param {Map<string, string>} [options.kvStore]
  */
 export function buildSyscall(options = {}) {
   const { skipLogging = false, kvStore: fakestore = new Map() } = options;
@@ -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 };
 }
 
@@ -168,9 +169,10 @@ function makeRPMaker(nextNumber = 1) {
  * @param {string} vatName
  * @param {object} [options]
  * @param {boolean} [options.forceGC]
- * @param {Map<string, string>} [options.kvStore = new Map()]
+ * @param {Map<string, string>} [options.kvStore]
  * @param {number} [options.nextPromiseImportNumber]
- * @param {boolean} [options.skipLogging = false]
+ * @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) {
@@ -273,6 +278,7 @@ export async function setupTestLiveslots(
     dispatchDropExports,
     dispatchRetireExports,
     dispatchRetireImports,
+    nextPImport: nextRP,
     testHooks,
   };
 }

package/test/{test-liveslots-mock-gc.js → liveslots-mock-gc.test.js}

@@ -1,16 +1,17 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
+import { kslot, kser } from '@agoric/kmarshal';
 import { makeLiveSlots } from '../src/liveslots.js';
 import { parseVatSlot } from '../src/parseVatSlots.js';
-import { kslot, kser } from './kmarshal.js';
 import { buildSyscall } from './liveslots-helpers.js';
 import {
   makeMessage,
   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/{test-liveslots-real-gc.js → liveslots-real-gc.test.js}

@@ -1,12 +1,13 @@
-/* global WeakRef */
+// @ts-nocheck
+/* global process */
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
 import { makePromiseKit } from '@endo/promise-kit';
+import { kslot, kser } from '@agoric/kmarshal';
+import { avaRetry } from '@agoric/internal/tools/avaRetry.js';
 import engineGC from './engine-gc.js';
-import { makeGcAndFinalize } from './gc-and-finalize.js';
-import { kslot, kser } from './kmarshal.js';
+import { watchCollected, makeGcAndFinalize } from './gc-and-finalize.js';
 import { buildSyscall, makeDispatch } from './liveslots-helpers.js';
 import {
   makeMessage,
@@ -26,15 +27,15 @@ const gcAndFinalize = makeGcAndFinalize(engineGC);
 // inconsistent GC behavior under Node.js and AVA with tests running
 // in parallel, so we mark them all with test.serial()
 
-test.serial('liveslots retains pending exported promise', async t => {
+avaRetry(test.serial, 'liveslots retains pending exported promise', async t => {
   const { log, syscall } = buildSyscall();
-  let watch;
+  let collected;
   const success = [];
   function build(_vatPowers) {
     const root = Far('root', {
       make() {
         const pk = makePromiseKit();
-        watch = new WeakRef(pk.promise);
+        collected = watchCollected(pk.promise);
         // we export the Promise, but do not retain resolve/reject
         return [pk.promise];
       },
@@ -55,7 +56,7 @@ test.serial('liveslots retains pending exported promise', async t => {
   const resultP = 'p-1';
   await dispatch(makeMessage(rootA, 'make', [], resultP));
   await gcAndFinalize();
-  t.truthy(watch.deref(), 'Promise not retained');
+  t.false(collected.result, 'Promise retained');
   t.is(log[0].type, 'resolve');
   const res0 = log[0].resolutions[0];
   t.is(res0[0], resultP);
@@ -64,15 +65,15 @@ test.serial('liveslots retains pending exported promise', async t => {
   t.deepEqual(success, ['yes']);
 });
 
-test.serial('liveslots retains device nodes', async t => {
+avaRetry(test.serial, 'liveslots retains device nodes', async t => {
   const { syscall } = buildSyscall();
-  let watch;
+  let collected;
   const recognize = new WeakSet(); // real WeakSet
   const success = [];
   function build(_vatPowers) {
     const root = Far('root', {
       first(dn) {
-        watch = new WeakRef(dn);
+        collected = watchCollected(dn);
         recognize.add(dn);
       },
       second(dn) {
@@ -87,25 +88,24 @@ test.serial('liveslots retains device nodes', async t => {
   const device = 'd-1';
   await dispatch(makeMessage(rootA, 'first', [kslot(device)]));
   await gcAndFinalize();
-  t.truthy(watch.deref(), 'Device node not retained');
+  t.false(collected.result, 'Device node retained');
   await dispatch(makeMessage(rootA, 'second', [kslot(device)]));
   t.deepEqual(success, [true]);
 });
 
-test.serial('GC syscall.dropImports', async t => {
+avaRetry(test.serial, 'GC syscall.dropImports', async t => {
   const { log, syscall } = buildSyscall();
-  let wr;
+  let collected;
   function build(_vatPowers) {
-    // eslint-disable-next-line no-unused-vars
-    let presence1;
+    const holder = new Set();
     const root = Far('root', {
       one(arg) {
-        presence1 = arg;
-        wr = new WeakRef(arg);
+        holder.add(arg);
+        collected = watchCollected(arg);
       },
       two() {},
       three() {
-        presence1 = undefined; // drops the import
+        holder.clear(); // drops the import
       },
     });
     return root;
@@ -121,19 +121,29 @@ test.serial('GC syscall.dropImports', async t => {
   // rp1 = root~.one(arg)
   await dispatch(makeMessage(rootA, 'one', [kslot(arg)]));
   await dispatch(makeBringOutYourDead());
-  t.truthy(wr.deref());
+  t.false(collected.result);
 
   // an intermediate message will trigger GC, but the presence is still held
   await dispatch(makeMessage(rootA, 'two', []));
   await dispatch(makeBringOutYourDead());
-  t.truthy(wr.deref());
+  t.false(collected.result);
 
   // now tell the vat to drop the 'arg' presence we gave them earlier
   await dispatch(makeMessage(rootA, 'three', []));
   await dispatch(makeBringOutYourDead());
 
+  const isV8 =
+    typeof process !== 'undefined' && 'v8' in (process.versions || {});
+
   // the presence itself should be gone
-  t.falsy(wr.deref());
+  if (!collected.result) {
+    if (isV8) {
+      // Flake in v8/node: https://github.com/Agoric/agoric-sdk/issues/8883
+      t.log('skipping flake in v8');
+      return;
+    }
+    t.fail('import not collected');
+  }
 
   // first it will check that there are no VO's holding onto it
   const l2 = log.shift();
@@ -168,7 +178,7 @@ test.serial('GC syscall.dropImports', async t => {
   t.deepEqual(log, []);
 });
 
-test.serial('GC dispatch.retireImports', async t => {
+avaRetry(test.serial, 'GC dispatch.retireImports', async t => {
   const { log, syscall } = buildSyscall();
   function build(_vatPowers) {
     // eslint-disable-next-line no-unused-vars
@@ -201,7 +211,7 @@ test.serial('GC dispatch.retireImports', async t => {
   // when we implement VOM.vrefIsRecognizable, this test might do more
 });
 
-test.serial('GC dispatch.retireExports', async t => {
+avaRetry(test.serial, 'GC dispatch.retireExports', async t => {
   const { log, syscall } = buildSyscall();
   function build(_vatPowers) {
     const ex1 = Far('export', {});
@@ -244,14 +254,14 @@ test.serial('GC dispatch.retireExports', async t => {
   t.deepEqual(log, []);
 });
 
-test.serial('GC dispatch.dropExports', async t => {
+avaRetry(test.serial, 'GC dispatch.dropExports', async t => {
   const { log, syscall } = buildSyscall();
-  let wr;
+  let collected;
   function build(_vatPowers) {
     const root = Far('root', {
       one() {
         const ex1 = Far('export', {});
-        wr = new WeakRef(ex1);
+        collected = watchCollected(ex1);
         return ex1;
         // ex1 goes out of scope, dropping last userspace strongref
       },
@@ -279,25 +289,33 @@ test.serial('GC dispatch.dropExports', async t => {
   t.deepEqual(log.shift(), {
     type: 'vatstoreSet',
     key: 'idCounters',
-    value: '{"exportID":11,"collectionID":5,"promiseID":5}',
+    value: '{"exportID":11,"collectionID":4,"promiseID":5}',
   });
   t.deepEqual(log, []);
 
   // the exported Remotable should be held in place by exportedRemotables
   // until we tell the vat we don't need it any more
-  t.truthy(wr.deref());
+  t.false(collected.result);
 
   // an intermediate message will trigger GC, but the presence is still held
   await dispatch(makeMessage(rootA, 'two', []));
   await dispatch(makeBringOutYourDead());
-  t.truthy(wr.deref());
+  t.false(collected.result);
 
   // now tell the vat we don't need a strong reference to that export.
   await dispatch(makeDropExports(ex1));
   await dispatch(makeBringOutYourDead());
 
   // that should allow ex1 to be collected
-  t.falsy(wr.deref());
+  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
@@ -309,23 +327,24 @@ test.serial('GC dispatch.dropExports', async t => {
   t.deepEqual(log, []);
 });
 
-test.serial(
+avaRetry(
+  test.serial,
   'GC dispatch.retireExports inhibits syscall.retireExports',
   async t => {
     const { log, syscall } = buildSyscall();
-    let wr;
+    let collected;
     function build(_vatPowers) {
-      let ex1;
+      const holder = new Set();
       const root = Far('root', {
         hold() {
-          ex1 = Far('export', {});
-          wr = new WeakRef(ex1);
+          const ex1 = Far('export', {});
+          holder.add(ex1);
+          collected = watchCollected(ex1);
           return ex1;
         },
         two() {},
         drop() {
-          // eslint-disable-next-line no-unused-vars
-          ex1 = undefined; // drop the last userspace strongref
+          holder.clear(); // drop the last userspace strongref
         },
       });
       return root;
@@ -350,25 +369,25 @@ test.serial(
     t.deepEqual(log.shift(), {
       type: 'vatstoreSet',
       key: 'idCounters',
-      value: '{"exportID":11,"collectionID":5,"promiseID":5}',
+      value: '{"exportID":11,"collectionID":4,"promiseID":5}',
     });
     t.deepEqual(log, []);
 
     // the exported Remotable should be held in place by exportedRemotables
     // until we tell the vat we don't need it any more
-    t.truthy(wr.deref());
+    t.false(collected.result);
 
     // an intermediate message will trigger GC, but the presence is still held
     await dispatch(makeMessage(rootA, 'two', []));
     await dispatch(makeBringOutYourDead());
-    t.truthy(wr.deref());
+    t.false(collected.result);
 
     // now tell the vat we don't need a strong reference to that export.
     await dispatch(makeDropExports(ex1));
     await dispatch(makeBringOutYourDead());
 
     // that removes the liveslots strongref, but the vat's remains in place
-    t.truthy(wr.deref());
+    t.false(collected.result);
 
     // now the kernel tells the vat we can't even recognize the export
     await dispatch(makeRetireExports(ex1));
@@ -376,17 +395,25 @@ test.serial(
 
     // that ought to delete the table entry, but doesn't affect the vat
     // strongref
-    t.truthy(wr.deref());
+    t.false(collected.result);
 
     // now tell the vat to drop its strongref
     await dispatch(makeMessage(rootA, 'drop', []));
     await dispatch(makeBringOutYourDead());
 
     // which should let the export be collected
-    t.falsy(wr.deref());
+    t.true(collected.result);
+
+    // 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
+    // the vat should *not* emit `syscall.retireExport`, because it
+    // already received a dispatch.retireExport
     t.deepEqual(log, []);
   },
 );