@agoric/swingset-liveslots 0.10.3-mainnet1B-dev-26244e8.0 → 0.10.3-orchestration-dev-096c4e8.0

package/test/test-liveslots.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/test-vo-test-harness.js

@@ -1,5 +1,4 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 import { runVOTest } from '../tools/vo-test-harness.js';
 
 async function voTestTest(t, mode) {

package/test/test-vpid-liveslots.js

@@ -1,13 +1,13 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { E } from '@endo/eventual-send';
 import { makePromiseKit } from '@endo/promise-kit';
-import { Fail } from '@agoric/assert';
 import { Far } from '@endo/marshal';
+import { Fail } from '@agoric/assert';
+import { kser, kslot } from '@agoric/kmarshal';
 import { buildSyscall, makeDispatch } from './liveslots-helpers.js';
 import { makeMessage, makeResolve, makeReject } from './util.js';
-import { kser, kslot } from './kmarshal.js';
 
 function hush(p) {
   p.then(
@@ -293,7 +293,6 @@ async function doVatResolveCase23(t, which, mode, stalls) {
         // another few turns. We wait some number of turns before using p1
         // again, to exercise as many race conditions as possible.
         for (let i = 0; i < stalls; i += 1) {
-          // eslint-disable-next-line no-await-in-loop
           await Promise.resolve();
         }
 
@@ -858,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/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

@@ -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

@@ -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 = {

package/test/virtual-objects/test-empty-data.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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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()));
 });

package/test/virtual-objects/test-state-shape.js

@@ -1,10 +1,10 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
+import { kser, kslot } from '@agoric/kmarshal';
 import { M } from '@agoric/store';
 import { makeLiveSlots } from '../../src/liveslots.js';
-import { kser, kslot } 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-virtualObjectGC.js

@@ -1,12 +1,12 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
 import { Far } from '@endo/marshal';
+import { krefOf, kser, kslot } from '@agoric/kmarshal';
 import {
   setupTestLiveslots,
   findSyscallsByType,
 } from '../liveslots-helpers.js';
-import { krefOf, kser, kslot } from '../kmarshal.js';
 import { parseVatSlot } from '../../src/parseVatSlots.js';
 
 // Legs: