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

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

@@ -1,13 +1,13 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
 
+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';
-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',
@@ -714,7 +713,7 @@ test('capdata size limit on syscalls', async t => {
     const label = 'test';
     t.deepEqual(log.shift(), {
       type: 'vatstoreGet',
-      key: 'vc.5.|schemata',
+      key: 'vc.4.|schemata',
       result: JSON.stringify(kser({ label, keyShape: M.scalar() })),
     });
   };
@@ -724,7 +723,7 @@ test('capdata size limit on syscalls', async t => {
   gotSchema();
   t.deepEqual(log.shift(), {
     type: 'vatstoreGet',
-    key: 'vc.5.skey',
+    key: 'vc.4.skey',
     result: undefined,
   });
   expectFail();
@@ -736,7 +735,7 @@ test('capdata size limit on syscalls', async t => {
   gotSchema();
   t.deepEqual(log.shift(), {
     type: 'vatstoreGet',
-    key: 'vc.5.skey',
+    key: 'vc.4.skey',
     result: undefined,
   });
   expectFail();
@@ -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,13 @@
+// @ts-nocheck
 import test from 'ava';
-import '@endo/init/debug.js';
+import { avaRetry } from '@agoric/internal/tools/avaRetry.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
@@ -14,12 +15,12 @@ import { parseVatSlot } from '../../src/parseVatSlots.js';
 
 function getLastCollection(v) {
   // makeAndHold() uses makeScalarBigMapStore, and since we call it
-  // early, it always gets "store #6", in vref o+2/6 (o+2 means
-  // scalarMapStore, non-durable, and /6 means collectionID=6)
-  const vref = 'o+v2/6';
+  // early, it always gets "store #5", in vref o+2/5 (o+2 means
+  // scalarMapStore, non-durable, and /5 means collectionID=5)
+  const vref = 'o+v2/5';
   // double-check that at least the collectionID is right
   const { t, fakestore } = v;
-  t.is(JSON.parse(fakestore.get('idCounters')).collectionID, 7); // last was 6
+  t.is(JSON.parse(fakestore.get('idCounters')).collectionID, 6); // last was 5
   return vref;
 }
 
@@ -66,7 +67,7 @@ function assertState(v, vref, reachable, erv) {
 // different test.
 
 // test 1: lerv -> Lerv -> LerV -> Lerv -> lerv
-test.serial('store lifecycle 1', async t => {
+avaRetry(test.serial, 'store lifecycle 1', async t => {
   const { v, dispatchMessageSuccessfully } = await setupTestLiveslots(
     t,
     buildRootObject,
@@ -94,7 +95,7 @@ test.serial('store lifecycle 1', async t => {
 
 // test 2: lerv -> Lerv -> LerV -> lerV -> LerV -> LERV -> lERV -> LERV ->
 //   lERV -> LERV -> lERV -> leRV -> LeRV -> leRV -> LeRV -> LerV
-test.serial('store lifecycle 2', async t => {
+avaRetry(test.serial, 'store lifecycle 2', async t => {
   const {
     v,
     dispatchMessageSuccessfully,
@@ -170,7 +171,7 @@ test.serial('store lifecycle 2', async t => {
 });
 
 // test 3: lerv -> Lerv -> LerV -> LERV -> LeRV -> leRV -> lerV -> lerv
-test.serial('store lifecycle 3', async t => {
+avaRetry(test.serial, 'store lifecycle 3', async t => {
   const {
     v,
     dispatchMessageSuccessfully,
@@ -211,7 +212,7 @@ test.serial('store lifecycle 3', async t => {
 });
 
 // test 4: lerv -> Lerv -> LERv -> LeRv -> lerv
-test.serial('store lifecycle 4', async t => {
+avaRetry(test.serial, 'store lifecycle 4', async t => {
   const { v, dispatchMessageSuccessfully, dispatchDropExports } =
     await setupTestLiveslots(t, buildRootObject, 'bob', { forceGC: true });
 
@@ -239,7 +240,7 @@ test.serial('store lifecycle 4', async t => {
 });
 
 // test 5: lerv -> Lerv -> LERv -> LeRv -> Lerv -> lerv
-test.serial('store lifecycle 5', async t => {
+avaRetry(test.serial, 'store lifecycle 5', async t => {
   const {
     v,
     dispatchMessageSuccessfully,
@@ -277,7 +278,7 @@ test.serial('store lifecycle 5', async t => {
 });
 
 // test 6: lerv -> Lerv -> LERv -> LeRv -> LeRV -> LeRv -> LeRV -> leRV -> lerv
-test.serial('store lifecycle 6', async t => {
+avaRetry(test.serial, 'store lifecycle 6', async t => {
   const { v, dispatchMessageSuccessfully, dispatchDropExports } =
     await setupTestLiveslots(t, buildRootObject, 'bob', { forceGC: true });
 
@@ -322,7 +323,7 @@ test.serial('store lifecycle 6', async t => {
 });
 
 // test 7: lerv -> Lerv -> LERv -> lERv -> LERv -> lERv -> lerv
-test.serial('store lifecycle 7', async t => {
+avaRetry(test.serial, 'store lifecycle 7', async t => {
   const { v, dispatchMessageSuccessfully, dispatchDropExports } =
     await setupTestLiveslots(t, buildRootObject, 'bob', { forceGC: true });
 
@@ -361,7 +362,7 @@ test.serial('store lifecycle 7', async t => {
 });
 
 // test 8: lerv -> Lerv -> LERv -> LERV -> LERv -> LERV -> lERV -> lERv -> lerv
-test.serial('store lifecycle 8', async t => {
+avaRetry(test.serial, 'store lifecycle 8', async t => {
   const { v, dispatchMessageSuccessfully, dispatchDropExports } =
     await setupTestLiveslots(t, buildRootObject, 'bob', { forceGC: true });
 

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/strict-test-env-upgrade.test.js

@@ -0,0 +1,94 @@
+/* global globalThis */
+// eslint-disable-next-line import/order
+import { annihilate, startLife } from '../tools/prepare-strict-test-env.js';
+
+import test from 'ava';
+
+import { makeUpgradeDisconnection } from '@agoric/internal/src/upgrade-api.js';
+import { makeExoUtils } from './exo-utils.js';
+
+test.serial('kind redefinition enforced', async t => {
+  annihilate();
+
+  const { prepareExoClass } = makeExoUtils(globalThis.VatData);
+
+  await startLife(async baggage => {
+    const makeTestExo = prepareExoClass(
+      baggage,
+      'TestExo',
+      undefined,
+      () => ({}),
+      {
+        foo() {
+          return 'bar';
+        },
+      },
+    );
+
+    baggage.init('testExo', makeTestExo());
+  });
+
+  await t.throwsAsync(
+    async () =>
+      startLife(async () => {
+        // Not redefining the kind here
+      }),
+    { message: 'defineDurableKind not called for tags: [TestExo]' },
+  );
+
+  await startLife(async baggage => {
+    prepareExoClass(baggage, 'TestExo', undefined, () => ({}), {
+      foo() {
+        return 'baz';
+      },
+    });
+
+    t.is(baggage.get('testExo').foo(), 'baz');
+  });
+});
+
+test.serial('decided promise rejected', async t => {
+  annihilate();
+
+  const { prepareExo } = makeExoUtils(globalThis.VatData);
+  const { watchPromise } = globalThis.VatData;
+
+  t.plan(1);
+
+  await startLife(async baggage => {
+    const watcher = prepareExo(
+      baggage,
+      'DurablePromiseTestWatcher',
+      undefined,
+      {
+        onFulfilled(value) {
+          t.fail(
+            `First incarnation watcher onFulfilled triggered with value ${value}`,
+          );
+        },
+        onRejected(reason) {
+          t.fail(
+            `First incarnation watcher onRejected triggered with reason ${reason}`,
+          );
+        },
+      },
+    );
+
+    const never = harden(new Promise(() => {}));
+
+    watchPromise(never, watcher);
+  });
+
+  await startLife(async baggage => {
+    prepareExo(baggage, 'DurablePromiseTestWatcher', undefined, {
+      onFulfilled(value) {
+        t.fail(
+          `Second incarnation watcher onFulfilled triggered with value ${value}`,
+        );
+      },
+      onRejected(reason) {
+        t.deepEqual(reason, makeUpgradeDisconnection('vat upgraded', 1));
+      },
+    });
+  });
+});

package/test/util.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @param {(d: unknown) => void} [onDispatchCallback ]
+ */
+export function buildDispatch(onDispatchCallback?: (d: unknown) => void): {
+    log: any[];
+    dispatch: (vatDeliverObject: any) => void;
+};
+/**
+ * @param {unknown} target
+ * @param {string | symbol} method
+ * @param {any[]} args
+ * @param {unknown} result
+ */
+export function makeMessage(target: unknown, method: string | symbol, args?: any[], result?: unknown): unknown[];
+export function makeStartVat(vatParametersCapData?: import("@endo/marshal").CapData<string>): (string | import("@endo/marshal").CapData<string>)[];
+export function makeBringOutYourDead(): string[];
+export function makeResolutions(resolutions: any): any[];
+export function makeResolve(target: any, result: any): any[];
+export function makeReject(target: any, result: any): (string | any[][])[];
+export function makeDropExports(...vrefs: any[]): (string | any[])[];
+export function makeRetireExports(...vrefs: any[]): (string | any[])[];
+export function makeRetireImports(...vrefs: any[]): (string | any[])[];
+export { vstr };
+import { vstr } from './vat-util.js';
+//# sourceMappingURL=util.d.ts.map

package/test/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["util.js"],"names":[],"mappings":"AAKA;;GAEG;AACH,mDAFW,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI;;;EAwC9B;AAED;;;;;GAKG;AACH,oCALW,OAAO,UACP,MAAM,GAAG,MAAM,SACf,GAAG,EAAE,WACL,OAAO,aAOjB;AAED,mJAEC;AAED,iDAEC;AAED,yDAGC;AAED,6DAGC;AAED,2EAIC;AAED,qEAGC;AAED,uEAGC;AAED,uEAGC;;qBAjGoB,eAAe"}

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
  */
@@ -59,8 +59,8 @@ export function makeMessage(target, method, args = [], result = null) {
   return vatDeliverObject;
 }
 
-export function makeStartVat(vatParameters) {
-  return harden(['startVat', vatParameters]);
+export function makeStartVat(vatParametersCapData = kser(undefined)) {
+  return harden(['startVat', vatParametersCapData]);
 }
 
 export function makeBringOutYourDead() {

package/test/vat-environment.test.js

@@ -0,0 +1,65 @@
+// @ts-nocheck
+import '@endo/init/debug.js';
+import test from 'ava';
+import { Far } from '@endo/marshal';
+import { kser } from '@agoric/kmarshal';
+import { passStyleOf } from '@endo/pass-style';
+import { PassStyleOfEndowmentSymbol } from '@endo/pass-style/endow.js';
+import { makeLiveSlots } from '../src/index.js';
+import { makeStartVat } from './util.js';
+import { buildSyscall } from './liveslots-helpers.js';
+import { makeMockGC } from './mock-gc.js';
+
+test('vat globals', async t => {
+  const { syscall } = buildSyscall();
+  const gcTools = makeMockGC();
+  const buildRootObject = () => Far('root', {});
+  let called = 0;
+  let vatGlobals;
+  let inescapableGlobalProperties;
+  const vatNS = harden({ buildRootObject });
+  // buildVatNamespace
+  const bVN = async (vG, iGP) => {
+    called += 1;
+    vatGlobals = vG;
+    inescapableGlobalProperties = iGP;
+    return vatNS;
+  };
+
+  const ls = makeLiveSlots(syscall, 'vatA', {}, {}, gcTools, undefined, bVN);
+  t.is(called, 0); // not called yet
+  await ls.dispatch(makeStartVat(kser()));
+  t.is(called, 1);
+  t.truthy(vatGlobals);
+
+  // 'harden' is provided by SES (installed by the lockdown bundle),
+  // not liveslots
+  t.is(typeof vatGlobals.harden, 'undefined');
+
+  // but liveslots provides VatData
+  t.is(typeof vatGlobals.VatData, 'object');
+  t.is(typeof vatGlobals.VatData, 'object');
+  t.is(typeof vatGlobals.VatData.defineKind, 'function');
+  t.is(typeof vatGlobals.VatData.defineKindMulti, 'function');
+  t.is(typeof vatGlobals.VatData.defineDurableKind, 'function');
+  t.is(typeof vatGlobals.VatData.defineDurableKindMulti, 'function');
+  t.is(typeof vatGlobals.VatData.makeKindHandle, 'function');
+  t.is(typeof vatGlobals.VatData.canBeDurable, 'function');
+  t.is(typeof vatGlobals.VatData.providePromiseWatcher, 'function');
+  t.is(typeof vatGlobals.VatData.watchPromise, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigMapStore, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigWeakMapStore, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigSetStore, 'function');
+  t.is(typeof vatGlobals.VatData.makeScalarBigWeakSetStore, 'function');
+
+  t.is(typeof inescapableGlobalProperties.WeakMap, 'function');
+  t.not(inescapableGlobalProperties.WeakMap, WeakMap);
+  t.is(typeof inescapableGlobalProperties.WeakSet, 'function');
+  t.not(inescapableGlobalProperties.WeakSet, WeakSet);
+  t.is(
+    typeof inescapableGlobalProperties[PassStyleOfEndowmentSymbol],
+    'function',
+  );
+  // this is the passStyleOf created by liveslots, with a real WeakMap
+  t.is(inescapableGlobalProperties[PassStyleOfEndowmentSymbol], passStyleOf);
+});

package/test/vat-util.d.ts

@@ -0,0 +1,9 @@
+export function extractMessage(vatDeliverObject: any): {
+    facetID: any;
+    method: any;
+    args: import("@endo/marshal").CapData<string>;
+    result: any;
+};
+export function ignore(p: any): void;
+export function vstr(v: any): string;
+//# sourceMappingURL=vat-util.d.ts.map

package/test/vat-util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vat-util.d.ts","sourceRoot":"","sources":["vat-util.js"],"names":[],"mappings":"AAMA;;;;;EAQC;AAED,qCAKC;AAEM,qCAAyC"}

package/test/vat-util.js

@@ -1,8 +1,8 @@
 // this file is imported by some test vats, so don't import any non-pure
 // modules
 
-import { Fail } from '@agoric/assert';
-import { kser, kunser } from './kmarshal.js';
+import { Fail } from '@endo/errors';
+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,22 +1,20 @@
 import test from 'ava';
-import '@endo/init/debug.js';
 // this sets process.env.DEBUG = 'label-instances'
 import './set-debug-label-instances.js';
 
 import { passStyleOf } from '@endo/far';
 
 // this samples it
+import { q } from '@endo/errors';
 import { makeFakeVirtualStuff } from '../../tools/fakeVirtualSupport.js';
 // all tests in this file will be run with DEBUG='label-instances'
 import { parseVatSlot } from '../../src/parseVatSlots.js';
 
-const { quote: q } = assert;
-
 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 +31,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);