@agoric/swingset-liveslots 0.10.3-dev-7ffae88.0 → 0.10.3-dev-32c4d68.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/swingset-liveslots",
-  "version": "0.10.3-dev-7ffae88.0+7ffae88",
+  "version": "0.10.3-dev-32c4d68.0+32c4d68",
   "description": "SwingSet ocap support layer",
   "type": "module",
   "main": "src/index.js",
@@ -17,23 +17,23 @@
     "lint:eslint": "eslint ."
   },
   "dependencies": {
-    "@agoric/assert": "0.6.1-dev-7ffae88.0+7ffae88",
-    "@agoric/internal": "0.3.3-dev-7ffae88.0+7ffae88",
-    "@agoric/store": "0.9.3-dev-7ffae88.0+7ffae88",
-    "@endo/env-options": "^1.1.0",
-    "@endo/errors": "^1.0.2",
-    "@endo/eventual-send": "^1.1.0",
-    "@endo/exo": "^1.1.0",
-    "@endo/far": "^1.0.2",
-    "@endo/init": "^1.0.2",
-    "@endo/marshal": "^1.1.0",
-    "@endo/nat": "^5.0.2",
-    "@endo/pass-style": "^1.1.0",
-    "@endo/patterns": "^1.1.0",
-    "@endo/promise-kit": "^1.0.2"
+    "@agoric/assert": "0.6.1-dev-32c4d68.0+32c4d68",
+    "@agoric/internal": "0.3.3-dev-32c4d68.0+32c4d68",
+    "@agoric/store": "0.9.3-dev-32c4d68.0+32c4d68",
+    "@endo/env-options": "^1.1.1",
+    "@endo/errors": "^1.1.0",
+    "@endo/eventual-send": "^1.1.2",
+    "@endo/exo": "^1.2.1",
+    "@endo/far": "^1.0.4",
+    "@endo/init": "^1.0.4",
+    "@endo/marshal": "^1.3.0",
+    "@endo/nat": "^5.0.4",
+    "@endo/pass-style": "^1.2.0",
+    "@endo/patterns": "^1.2.0",
+    "@endo/promise-kit": "^1.0.4"
   },
   "devDependencies": {
-    "@agoric/kmarshal": "0.1.1-dev-7ffae88.0+7ffae88",
+    "@agoric/kmarshal": "0.1.1-dev-32c4d68.0+32c4d68",
     "ava": "^5.3.0"
   },
   "files": [
@@ -67,7 +67,7 @@
     "access": "public"
   },
   "typeCoverage": {
-    "atLeast": 75.1
+    "atLeast": 75.2
   },
-  "gitHead": "7ffae88ae37df782d5ffe3cf92261a498b0f636c"
+  "gitHead": "32c4d68c5f675f1e8fea1a8bc08621816e7b491e"
 }

package/test/gc-and-finalize.js

@@ -1,4 +1,4 @@
-/* global setImmediate */
+/* global setImmediate, FinalizationRegistry */
 
 /* A note on our GC terminology:
  *
@@ -89,3 +89,32 @@ export function makeGcAndFinalize(gcPower) {
     await new Promise(setImmediate);
   };
 }
+
+const fr = new FinalizationRegistry(({ promise, resolve }) => {
+  promise.result = true;
+  resolve(true);
+});
+
+const makeCollectedResultKit = () => {
+  /** @type {(val: true) => void} */
+  let resolve;
+
+  const promise = /** @type {Promise<true> & {result: boolean}} */ (
+    new Promise(r => {
+      resolve = r;
+    })
+  );
+  promise.result = false;
+  return {
+    promise,
+    // @ts-expect-error
+    resolve,
+  };
+};
+
+export function watchCollected(target) {
+  const kit = makeCollectedResultKit();
+  fr.register(target, kit);
+
+  return kit.promise;
+}

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

@@ -1,12 +1,12 @@
 // @ts-nocheck
-/* global WeakRef */
+/* global process */
 import test from 'ava';
 
 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 { 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-vpid-liveslots.js

@@ -857,7 +857,7 @@ test('inter-vat circular promise references', async t => {
     let r;
     return Far('root', {
       genPromise() {
-        [p, r] = makePR();
+        void ([p, r] = makePR());
         return p;
       },
       usePromise(pa) {

package/test/virtual-objects/test-retain-remotable.js

@@ -1,56 +1,57 @@
 // @ts-nocheck
-/* global WeakRef */
 import test from 'ava';
 
 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()));
 });

package/test/virtual-objects/test-vo-real-gc.js

@@ -1,13 +1,13 @@
 // @ts-nocheck
-/* global WeakRef */
 import test from 'ava';
 
 import { Far } from '@endo/marshal';
 import { kser, kunser } from '@agoric/kmarshal';
 import { setupTestLiveslots } from '../liveslots-helpers.js';
+import { watchCollected } from '../gc-and-finalize.js';
 
 test('virtual object state writes', async t => {
-  let monitor;
+  let collected;
 
   const initData = { begin: 'ning' };
   const initStateData = { begin: kser(initData.begin) };
@@ -23,11 +23,11 @@ test('virtual object state writes', async t => {
     const root = Far('root', {
       make: () => {
         const thing = makeThing();
-        monitor = new WeakRef(thing);
+        collected = watchCollected(thing);
         return thing;
       },
       ping: thing => {
-        monitor = new WeakRef(thing);
+        collected = watchCollected(thing);
         return thing.ping();
       },
     });
@@ -56,7 +56,7 @@ test('virtual object state writes', async t => {
 
   // 'thing' is exported, but not held in RAM, so the Representative
   // should be dropped
-  t.falsy(monitor.deref());
+  t.true(collected.result);
 
   // Invoking a method, on the other hand, *does* require creation of
   // "state" and "context", and creation of "state" requires reading
@@ -70,5 +70,5 @@ test('virtual object state writes', async t => {
 
   // 'thing' is again dropped by RAM, so it should be dropped. If
   // "context" were erroneously retained, it would stick around.
-  t.falsy(monitor.deref());
+  t.true(collected.result);
 });