@agoric/swingset-liveslots 0.10.3-u14.0 → 0.10.3-u16.0

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

@@ -1,12 +1,12 @@
-/* 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 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,
@@ -28,13 +28,13 @@ const gcAndFinalize = makeGcAndFinalize(engineGC);
 
 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 +55,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);
@@ -66,13 +66,13 @@ test.serial('liveslots retains pending exported promise', async t => {
 
 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 +87,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 => {
   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 +120,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();
@@ -246,12 +255,12 @@ test.serial('GC dispatch.retireExports', async t => {
 
 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
       },
@@ -285,19 +294,19 @@ test.serial('GC dispatch.dropExports', async t => {
 
   // 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);
 
   // and once it's collected, the vat should emit `syscall.retireExport`
   // because nobody else will be able to recognize it again
@@ -313,19 +322,19 @@ 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;
@@ -356,19 +365,19 @@ test.serial(
 
     // 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,14 +385,14 @@ 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 *not* emit `syscall.retireExport`, because it already
     // received a dispatch.retireExport

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

@@ -1,13 +1,13 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 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';
-import { kslot, kser, kunser } from './kmarshal.js';
 import { buildSyscall, makeDispatch } from './liveslots-helpers.js';
 import { makeMessage, makeStartVat, makeResolve, makeReject } from './util.js';
 import { makeMockGC } from './mock-gc.js';
@@ -45,14 +45,14 @@ test('calls', async t => {
 
   // root!one() // sendOnly
   await dispatch(makeMessage(rootA, 'one', ['args']));
-  t.deepEqual(log.shift(), 'one');
+  t.is(log.shift(), 'one');
 
   // pr = makePromise()
   // root!two(pr.promise)
   // pr.resolve('result')
   await dispatch(makeMessage(rootA, 'two', [kslot('p-1')]));
   t.deepEqual(log.shift(), { type: 'subscribe', target: 'p-1' });
-  t.deepEqual(log.shift(), 'two true');
+  t.is(log.shift(), 'two true');
 
   await dispatch(makeResolve('p-1', kser('result')));
   t.deepEqual(log.shift(), ['res', 'result']);
@@ -63,7 +63,7 @@ test('calls', async t => {
 
   await dispatch(makeMessage(rootA, 'two', [kslot('p-2')]));
   t.deepEqual(log.shift(), { type: 'subscribe', target: 'p-2' });
-  t.deepEqual(log.shift(), 'two true');
+  t.is(log.shift(), 'two true');
 
   await dispatch(makeReject('p-2', kser('rejection')));
   t.deepEqual(log.shift(), ['rej', 'rejection']);
@@ -99,7 +99,7 @@ test('liveslots pipelines to syscall.send', async t => {
   // for x!pipe1(), a second pipelined to the result promise of it, and a
   // third pipelined to the result of the second.
 
-  t.deepEqual(log.shift(), 'sent p1p2p3');
+  t.is(log.shift(), 'sent p1p2p3');
   t.deepEqual(log.shift(), {
     type: 'send',
     targetSlot: x,
@@ -656,8 +656,7 @@ test('capdata size limit on syscalls', async t => {
   };
 
   const send = op => dispatch(makeMessage(rootA, op, [kslot(target)], rp));
-  const expectFail = () =>
-    t.deepEqual(log.shift(), 'fail: syscall capdata too large');
+  const expectFail = () => t.is(log.shift(), 'fail: syscall capdata too large');
   const expectVoidReturn = () =>
     t.deepEqual(log.shift(), {
       type: 'resolve',
@@ -906,7 +905,7 @@ test('disable disavow', async t => {
 
   // root~.one() // sendOnly
   await dispatch(makeMessage(rootA, 'one', []));
-  t.deepEqual(log.shift(), false);
+  t.is(log.shift(), false);
   t.deepEqual(log, []);
 });
 
@@ -967,7 +966,7 @@ test('disavow', async t => {
   // root~.one(import1) // sendOnly
   await dispatch(makeMessage(rootA, 'one', [kslot(import1)]));
   t.deepEqual(log.shift(), { type: 'dropImports', slots: [import1] });
-  t.deepEqual(log.shift(), 'disavowed pres1');
+  t.is(log.shift(), 'disavowed pres1');
 
   function loggedError(re) {
     const l = log.shift();
@@ -975,11 +974,11 @@ test('disavow', async t => {
     t.truthy(re.test(l.message));
   }
   loggedError(/attempt to disavow unknown/);
-  t.deepEqual(log.shift(), 'tried duplicate disavow');
+  t.is(log.shift(), 'tried duplicate disavow');
   loggedError(/attempt to disavow unknown/);
-  t.deepEqual(log.shift(), 'tried to disavow Promise');
+  t.is(log.shift(), 'tried to disavow Promise');
   loggedError(/attempt to disavow an export/);
-  t.deepEqual(log.shift(), 'tried to disavow export');
+  t.is(log.shift(), 'tried to disavow export');
   const msg = log.shift();
   t.like(msg, {
     type: 'exit',
@@ -987,7 +986,7 @@ test('disavow', async t => {
   });
   expectError(t, msg.info, /this Presence has been disavowed/);
   t.deepEqual(log.shift(), Error('this Presence has been disavowed'));
-  t.deepEqual(log.shift(), 'tried to send to disavowed');
+  t.is(log.shift(), 'tried to send to disavowed');
   t.deepEqual(log, []);
 });
 

package/test/mock-gc.js

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

package/test/storeGC/{test-lifecycle.js → lifecycle.test.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 → refcount-management.test.js}

@@ -1,6 +1,6 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
+import { kslot } from '@agoric/kmarshal';
 import {
   findSyscallsByType,
   setupTestLiveslots,
@@ -12,7 +12,6 @@ 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 → scalar-store-kind.test.js}

@@ -1,5 +1,4 @@
 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 → weak-key.test.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,7 +8,6 @@ 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

package/test/util.js

@@ -1,5 +1,5 @@
+import { kser } from '@agoric/kmarshal';
 import { vstr } from './vat-util.js';
-import { kser } from './kmarshal.js';
 
 export { vstr };
 
@@ -48,7 +48,7 @@ export function buildDispatch(onDispatchCallback) {
 
 /**
  * @param {unknown} target
- * @param {string} method
+ * @param {string | symbol} method
  * @param {any[]} args
  * @param {unknown} result
  */

package/test/vat-util.js

@@ -2,7 +2,7 @@
 // modules
 
 import { Fail } from '@agoric/assert';
-import { kser, kunser } from './kmarshal.js';
+import { kser, kunser } from '@agoric/kmarshal';
 
 export function extractMessage(vatDeliverObject) {
   const [type, ...vdoargs] = vatDeliverObject;

package/test/virtual-objects/{test-cease-recognition.js → cease-recognition.test.js}

@@ -1,6 +1,6 @@
+// @ts-nocheck
 /* global FinalizationRegistry WeakRef */
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { buildSyscall } from '../liveslots-helpers.js';
 import { makeVirtualReferenceManager } from '../../src/virtualReferences.js';
@@ -38,7 +38,7 @@ function weakKeyCheck(t, log, vref) {
   t.true(result === undefined || !result.startsWith(prefix), `ew:${result}`);
 }
 
-test('only enumerate virtual objects', async t => {
+test('only enumerate virtual objects', t => {
   const { log, vrm } = makeVRM();
 
   // retiring a plain Remotable does a is-it-a-weak-key chck

package/test/virtual-objects/{test-cross-facet.js → cross-facet.test.js}

@@ -1,5 +1,4 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { makeFakeVirtualObjectManager } from '../../tools/fakeVirtualSupport.js';
 
@@ -15,7 +14,7 @@ function attack2(mut1, immut2) {
   Reflect.apply(mutableProto.set, immut2, [6]);
 }
 
-test('forbid cross-facet prototype attack', async t => {
+test('forbid cross-facet prototype attack', t => {
   const vom = makeFakeVirtualObjectManager();
   const init = () => ({ value: 0 });
   const behavior = {
@@ -34,10 +33,12 @@ test('forbid cross-facet prototype attack', async t => {
   thing2.mutable.set(2);
 
   t.throws(() => attack1(thing1.mutable, thing2.immutable), {
-    message: /^illegal cross-facet access/,
+    message:
+      '"In \\"set\\" method of (thing mutable)" may only be applied to a valid instance: "[Alleged: thing immutable]"',
   });
   t.throws(() => attack2(thing1.mutable, thing2.immutable), {
-    message: /^illegal cross-facet access/,
+    message:
+      '"In \\"set\\" method of (thing mutable)" may only be applied to a valid instance: "[Alleged: thing immutable]"',
   });
   t.is(thing1.immutable.get(), 1);
   t.is(thing2.immutable.get(), 2);

package/test/virtual-objects/{test-empty-data.js → empty-data.test.js}

@@ -1,9 +1,8 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { makeFakeVirtualObjectManager } from '../../tools/fakeVirtualSupport.js';
 
-test('non-object initial data message', async t => {
+test('non-object initial data message', t => {
   const vom = makeFakeVirtualObjectManager();
   const goodInit = () => ({ value: 0 });
   // 'badInit' is  () =>  { value: 0 }

package/test/virtual-objects/{test-facets.js → facets.test.js}

@@ -1,9 +1,8 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { makeFakeVirtualObjectManager } from '../../tools/fakeVirtualSupport.js';
 
-test('facets', async t => {
+test('facets', t => {
   const vom = makeFakeVirtualObjectManager();
   const init = () => ({ value: 0 });
   const behavior = {

package/test/virtual-objects/{test-kind-changes.js → kind-changes.test.js}

@@ -1,10 +1,10 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 import { Far } from '@endo/marshal';
+import { kser } from '@agoric/kmarshal';
 import { makeFakeVirtualStuff } from '../../tools/fakeVirtualSupport.js';
 import { makeLiveSlots } from '../../src/liveslots.js';
 import { parseVatSlot } from '../../src/parseVatSlots.js';
-import { kser } from '../kmarshal.js';
 import { buildSyscall } from '../liveslots-helpers.js';
 import { makeStartVat, makeMessage } from '../util.js';
 import { makeMockGC } from '../mock-gc.js';

package/test/virtual-objects/{test-reachable-vrefs.js → reachable-vrefs.test.js}

@@ -1,5 +1,5 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Remotable } from '@endo/marshal';
 import { initEmpty } from '@agoric/store';
@@ -7,7 +7,7 @@ import { initEmpty } from '@agoric/store';
 import { makeVatSlot } from '../../src/parseVatSlots.js';
 import { makeFakeVirtualStuff } from '../../tools/fakeVirtualSupport.js';
 
-test('VOM tracks reachable vrefs', async t => {
+test('VOM tracks reachable vrefs', t => {
   const { vom, vrm, cm } = makeFakeVirtualStuff();
   const { defineKind } = vom;
   const { makeScalarBigWeakMapStore } = cm;

package/test/virtual-objects/{test-rep-tostring.js → rep-tostring.test.js}

@@ -1,5 +1,4 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 // this sets process.env.DEBUG = 'label-instances'
 import './set-debug-label-instances.js';
 
@@ -16,7 +15,7 @@ const init = () => ({});
 const behavior = {};
 const facets = { foo: {}, bar: {} };
 
-test('representatives with label-instances', async t => {
+test('representatives with label-instances', t => {
   const { fakeStuff, vom } = makeFakeVirtualStuff();
   const { getSlotForVal } = fakeStuff;
   const makeThing = vom.defineKind('thing', init, behavior);
@@ -33,7 +32,7 @@ test('representatives with label-instances', async t => {
   t.is(`${q(thing2)}`, `"[Alleged: thing#${thing2vref}]"`);
 });
 
-test('facets with label-instances', async t => {
+test('facets with label-instances', t => {
   const { fakeStuff, vom } = makeFakeVirtualStuff();
   const { getSlotForVal } = fakeStuff;
   const makeThings = vom.defineKindMulti('thing', init, facets);

package/test/virtual-objects/{test-retain-remotable.js → retain-remotable.test.js}

@@ -1,56 +1,57 @@
-/* global WeakRef */
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
 import { initEmpty } from '@agoric/store';
 
 import engineGC from '../engine-gc.js';
-import { makeGcAndFinalize } from '../gc-and-finalize.js';
+import { makeGcAndFinalize, watchCollected } from '../gc-and-finalize.js';
 import { makeFakeVirtualStuff } from '../../tools/fakeVirtualSupport.js';
 
-function makeHeld() {
-  const held = Far('held');
-  const wr = new WeakRef(held);
+function makeStashKit(name = 'held') {
+  const held = Far(name);
+  const collected = watchCollected(held);
   const ws = new WeakSet(); // note: real WeakSet, not vref-aware
   ws.add(held);
   function isHeld(obj) {
     return ws.has(obj);
   }
-  return { held, wr, isHeld };
+  function isCollected() {
+    return collected.result;
+  }
+  return { held, isCollected, isHeld };
 }
 
 function prepareEphemeral(vom) {
-  const ephemeral = Far('ephemeral');
-  vom.registerEntry('o+12345', ephemeral);
-  const wr = new WeakRef(ephemeral);
-  return { wr };
+  const { held, isCollected } = makeStashKit('ephemeral');
+  vom.registerEntry('o+12345', held);
+  return { isCollected };
 }
 
 function stashRemotableOne(weakStore, key1) {
-  const { held, wr, isHeld } = makeHeld();
+  const { held, isCollected, isHeld } = makeStashKit();
   weakStore.init(key1, held);
-  return { wr, isHeld };
+  return { isCollected, isHeld };
 }
 
 function stashRemotableTwo(weakStore, key1) {
-  const { held, wr, isHeld } = makeHeld();
+  const { held, isCollected, isHeld } = makeStashKit();
   weakStore.init(key1, 'initial');
   weakStore.set(key1, held);
-  return { wr, isHeld };
+  return { isCollected, isHeld };
 }
 
 function stashRemotableThree(holderMaker) {
-  const { held, wr, isHeld } = makeHeld();
+  const { held, isCollected, isHeld } = makeStashKit();
   const holder = holderMaker(held);
-  return { wr, isHeld, holder };
+  return { isCollected, isHeld, holder };
 }
 
 function stashRemotableFour(holderMaker) {
-  const { held, wr, isHeld } = makeHeld();
+  const { held, isCollected, isHeld } = makeStashKit();
   const holder = holderMaker('initial');
   holder.setHeld(held);
-  return { wr, isHeld, holder };
+  return { isCollected, isHeld, holder };
 }
 
 test('remotables retained by virtualized data', async t => {
@@ -74,7 +75,7 @@ test('remotables retained by virtualized data', async t => {
   // false positive in the subsequent test
   const stash0 = prepareEphemeral(vom);
   await gcAndFinalize();
-  t.falsy(stash0.wr.deref(), `caution: fake VOM didn't release Remotable`);
+  t.true(stash0.isCollected(), `caution: fake VOM didn't release Remotable`);
 
   // stash a Remotable in the value of a weakStore
   const key1 = makeKey();
@@ -84,14 +85,14 @@ test('remotables retained by virtualized data', async t => {
   // Representatives or Presences, so the value is not holding a strong
   // reference to the Remotable. The VOM is supposed to keep it alive, via
   // reachableRemotables.
-  t.truthy(stash1.wr.deref());
+  t.false(stash1.isCollected());
   t.truthy(stash1.isHeld(weakStore.get(key1)));
 
   // do the same, but exercise weakStore.set instead of .init
   const key2 = makeKey();
   const stash2 = stashRemotableTwo(weakStore, key2);
   await gcAndFinalize();
-  t.truthy(stash2.wr.deref());
+  t.false(stash2.isCollected());
   t.truthy(stash2.isHeld(weakStore.get(key2)));
 
   // now stash a Remotable in the state of a virtual object during init()
@@ -100,12 +101,12 @@ test('remotables retained by virtualized data', async t => {
   // Each state property is virtualized upon write (via the generated
   // setters). So again we rely on the VOM to keep the Remotable alive in
   // case someone retrieves it again.
-  t.truthy(stash3.wr.deref());
+  t.false(stash3.isCollected());
   t.truthy(stash3.isHeld(stash3.holder.getHeld()));
 
   // same, but stash after init()
   const stash4 = stashRemotableFour(makeHolder);
   await gcAndFinalize();
-  t.truthy(stash4.wr.deref());
+  t.false(stash4.isCollected());
   t.truthy(stash4.isHeld(stash4.holder.getHeld()));
 });