@agoric/swingset-xsnap-supervisor 0.9.1-dev-6e51de2.0

package/dist/supervisor.bundle.sha256

@@ -0,0 +1 @@
+9ed047832309a39356fd383c3e74e8b0973c7230f29b7b02d71a2e3555e4d60f

package/lib/capdata.js

@@ -0,0 +1,20 @@
+import { Fail } from '@agoric/assert';
+
+/* eslint-disable jsdoc/require-returns-check */
+/**
+ * Assert function to ensure that something expected to be a capdata object
+ * actually is.  A capdata object should have a .body property that's a string
+ * and a .slots property that's an array of strings.
+ *
+ * @param {any} capdata  The object to be tested
+ * @throws {Error} if, upon inspection, the parameter does not satisfy the above
+ *   criteria.
+ * @returns {asserts capdata is import('@endo/marshal').CapData<string>}
+ */
+export function insistCapData(capdata) {
+  typeof capdata.body === 'string' ||
+    Fail`capdata has non-string .body ${capdata.body}`;
+  Array.isArray(capdata.slots) ||
+    Fail`capdata has non-Array slots ${capdata.slots}`;
+  // TODO check that the .slots array elements are actually strings
+}

package/lib/entry.js

@@ -0,0 +1 @@
+import './supervisor-subprocess-xsnap.js';

package/lib/gc-and-finalize.js

@@ -0,0 +1,91 @@
+/* global setImmediate */
+
+/* A note on our GC terminology:
+ *
+ * We define four states for any JS object to be in:
+ *
+ * REACHABLE: There exists a path from some root (live export or top-level
+ * global) to this object, making it ineligible for collection. Userspace vat
+ * code has a strong reference to it (and userspace is not given access to
+ * WeakRef, so it has no weak reference that might be used to get access).
+ *
+ * UNREACHABLE: There is no strong reference from a root to the object.
+ * Userspace vat code has no means to access the object, although liveslots
+ * might (via a WeakRef). The object is eligible for collection, but that
+ * collection has not yet happened. The liveslots WeakRef is still alive: if
+ * it were to call `.deref()`, it would get the object.
+ *
+ * COLLECTED: The JS engine has performed enough GC to notice the
+ * unreachability of the object, and has collected it. The liveslots WeakRef
+ * is dead: `wr.deref() === undefined`. Neither liveslots nor userspace has
+ * any way to reach the object, and never will again. A finalizer callback
+ * has been queued, but not yet executed.
+ *
+ * FINALIZED: The JS engine has run the finalizer callback. Once the
+ * callback completes, the object is thoroughly dead and unremembered,
+ * and no longer exists in one of these four states.
+ *
+ * The transition from REACHABLE to UNREACHABLE always happens as a result of
+ * a message delivery or resolution notification (e.g when userspace
+ * overwrites a variable, deletes a Map entry, or a callback on the promise
+ * queue which closed over some objects is retired and deleted).
+ *
+ * The transition from UNREACHABLE to COLLECTED can happen spontaneously, as
+ * the JS engine decides it wants to perform GC. It will also happen
+ * deliberately if we provoke a GC call with a magic function like `gc()`
+ * (when Node.js imports `engine-gc`, which is morally-equivalent to
+ * running with `--expose-gc`, or when XS is configured to provide it as a
+ * C-level callback). We can force GC, but we cannot prevent it from happening
+ * at other times.
+ *
+ * FinalizationRegistry callbacks are defined to run on their own turn, so
+ * the transition from COLLECTED to FINALIZED occurs at a turn boundary.
+ * Node.js appears to schedule these finalizers on the timer/IO queue, not
+ * the promise/microtask queue. So under Node.js, you need a `setImmediate()`
+ * or two to ensure that finalizers have had a chance to run. XS is different
+ * but responds well to similar techniques.
+ */
+
+/*
+ * `gcAndFinalize` must be defined in the start compartment. It uses
+ * platform-specific features to provide a function which provokes a full GC
+ * operation: all "UNREACHABLE" objects should transition to "COLLECTED"
+ * before it returns. In addition, `gcAndFinalize()` returns a Promise. This
+ * Promise will resolve (with `undefined`) after all FinalizationRegistry
+ * callbacks have executed, causing all COLLECTED objects to transition to
+ * FINALIZED. If the caller can manage call gcAndFinalize with an empty
+ * promise queue, then their .then callback will also start with an empty
+ * promise queue, and there will be minimal uncollected unreachable objects
+ * in the heap when it begins.
+ *
+ * `gcAndFinalize` depends upon platform-specific tools to provoke a GC sweep
+ * and wait for finalizers to run: a `gc()` function, and `setImmediate`. If
+ * these tools do not exist, this function will do nothing, and return a
+ * dummy pre-resolved Promise.
+ */
+
+export function makeGcAndFinalize(gcPower) {
+  if (typeof gcPower !== 'function') {
+    if (gcPower !== false) {
+      // We weren't explicitly disabled, so warn.
+      console.warn(
+        Error(`no gcPower() function; skipping finalizer provocation`),
+      );
+    }
+  }
+  return async function gcAndFinalize() {
+    if (typeof gcPower !== 'function') {
+      return;
+    }
+
+    // on Node.js, GC seems to work better if the promise queue is empty first
+    await new Promise(setImmediate);
+    // on xsnap, we must do it twice for some reason
+    await new Promise(setImmediate);
+    gcPower();
+    // this gives finalizers a chance to run
+    await new Promise(setImmediate);
+    // Node.js seems to need another for promises to get cleared out
+    await new Promise(setImmediate);
+  };
+}

package/lib/supervisor-helper.js

@@ -0,0 +1,169 @@
+import { assert } from '@agoric/assert';
+import {
+  insistVatSyscallObject,
+  insistVatSyscallResult,
+} from '@agoric/swingset-liveslots';
+
+/**
+ * @typedef {import('@agoric/swingset-liveslots').VatDeliveryObject} VatDeliveryObject
+ * @typedef {import('@agoric/swingset-liveslots').VatDeliveryResult} VatDeliveryResult
+ * @typedef {import('@agoric/swingset-liveslots').VatSyscallObject} VatSyscallObject
+ * @typedef {import('@agoric/swingset-liveslots').VatSyscaller} VatSyscaller
+ * @typedef {import('@endo/marshal').CapData<string>} SwingSetCapData
+ * @typedef { (delivery: VatDeliveryObject) => (VatDeliveryResult | Promise<VatDeliveryResult>) } VatDispatcherSyncAsync
+ * @typedef { (delivery: VatDeliveryObject) => Promise<VatDeliveryResult> } VatDispatcher
+ */
+
+/**
+ * Given the liveslots 'dispatch' function, return a version that never
+ * rejects. It will always return a VatDeliveryResult, even if liveslots
+ * throws or rejects. All supervisors should wrap the liveslots `dispatch`
+ * function with this one, and call it in response to messages from the
+ * manager process.
+ *
+ * @param {VatDispatcherSyncAsync} dispatch
+ * @returns {VatDispatcher}
+ */
+function makeSupervisorDispatch(dispatch) {
+  /**
+   * @param {VatDeliveryObject} delivery
+   * @returns {Promise<VatDeliveryResult>}
+   */
+  async function dispatchToVat(delivery) {
+    // the (low-level) vat is responsible for giving up agency, but we still
+    // protect against exceptions
+    return Promise.resolve(delivery)
+      .then(dispatch)
+      .then(
+        () => harden(['ok', null, null]),
+        err => {
+          // TODO react more thoughtfully, maybe terminate the vat
+          console.warn(`error during vat dispatch() of ${delivery}`, err);
+          return harden(['error', `${err}`, null]);
+        },
+      );
+  }
+
+  return harden(dispatchToVat);
+}
+harden(makeSupervisorDispatch);
+export { makeSupervisorDispatch };
+
+/**
+ * This returns a function that is provided to liveslots as the 'syscall'
+ * argument: an object with one method per syscall type. These methods return
+ * data, or nothing. If the kernel experiences a problem executing the syscall,
+ * the method will throw, or the kernel will kill the vat, or both.
+ *
+ * I should be given a `syscallToManager` function that accepts a
+ * VatSyscallObject and (synchronously) returns a VatSyscallResult.
+ *
+ * @param {VatSyscaller} syscallToManager
+ * @param {boolean} workerCanBlock
+ * @typedef { unknown } TheSyscallObjectWithMethodsThatLiveslotsWants
+ * @returns {TheSyscallObjectWithMethodsThatLiveslotsWants}
+ */
+function makeSupervisorSyscall(syscallToManager, workerCanBlock) {
+  function doSyscall(fields) {
+    insistVatSyscallObject(fields);
+    /** @type { VatSyscallObject } */
+    const vso = harden(fields);
+    let r;
+    try {
+      r = syscallToManager(vso);
+    } catch (err) {
+      console.warn(`worker got error during syscall:`, err);
+      throw err;
+    }
+    if (!workerCanBlock) {
+      // we don't expect an answer
+      return null;
+    }
+    const vsr = r;
+    insistVatSyscallResult(vsr);
+    const [type, ...rest] = vsr;
+    switch (type) {
+      case 'ok': {
+        const [data] = rest;
+        return data;
+      }
+      case 'error': {
+        const [err] = rest;
+        throw Error(`syscall.${fields[0]} failed: ${err}`);
+      }
+      default:
+        throw Error(`unknown result type ${type}`);
+    }
+  }
+
+  // this will be given to liveslots, it should have distinct methods that
+  // return immediate results or throw errors
+  const syscallForVat = {
+    /** @type {(target: string, method: string, args: SwingSetCapData, result?: string) => unknown } */
+    send: (target, methargs, result) =>
+      doSyscall(['send', target, { methargs, result }]),
+    subscribe: vpid => doSyscall(['subscribe', vpid]),
+    resolve: resolutions => doSyscall(['resolve', resolutions]),
+    exit: (isFailure, data) => doSyscall(['exit', isFailure, data]),
+    dropImports: vrefs => doSyscall(['dropImports', vrefs]),
+    retireImports: vrefs => doSyscall(['retireImports', vrefs]),
+    retireExports: vrefs => doSyscall(['retireExports', vrefs]),
+    abandonExports: vrefs => doSyscall(['abandonExports', vrefs]),
+
+    // These syscalls should be omitted if the worker cannot get a
+    // synchronous return value back from the kernel, such as when the worker
+    // is in a child process or thread, and cannot be blocked until the
+    // result gets back. vatstoreSet and vatstoreDelete are included because
+    // vatstoreSet requires a result, and we offer them as a group.
+    callNow: (target, method, args) =>
+      doSyscall(['callNow', target, method, args]),
+    vatstoreGet: key => {
+      const result = doSyscall(['vatstoreGet', key]);
+      return result === null ? undefined : result;
+    },
+    vatstoreGetNextKey: priorKey => doSyscall(['vatstoreGetNextKey', priorKey]),
+    vatstoreSet: (key, value) => doSyscall(['vatstoreSet', key, value]),
+    vatstoreDelete: key => doSyscall(['vatstoreDelete', key]),
+  };
+
+  const blocking = [
+    'callNow',
+    'vatstoreGet',
+    'vatstoreGetNextKey',
+    'vatstoreSet',
+    'vatstoreDelete',
+  ];
+
+  if (!workerCanBlock) {
+    for (const name of blocking) {
+      const err = `this non-blocking worker transport cannot syscall.${name}`;
+      syscallForVat[name] = () => assert.fail(err);
+    }
+  }
+
+  return harden(syscallForVat);
+}
+
+harden(makeSupervisorSyscall);
+export { makeSupervisorSyscall };
+
+/**
+ * Create a vat console from a log stream maker.
+ *
+ * TODO: consider other methods per SES VirtualConsole.
+ * See https://github.com/Agoric/agoric-sdk/issues/2146
+ *
+ * @param {(level: string) => (...args: any[]) => void} makeLog
+ */
+function makeVatConsole(makeLog) {
+  return harden({
+    debug: makeLog('debug'),
+    log: makeLog('log'),
+    info: makeLog('info'),
+    warn: makeLog('warn'),
+    error: makeLog('error'),
+  });
+}
+
+harden(makeVatConsole);
+export { makeVatConsole };

package/lib/supervisor-subprocess-xsnap.js

@@ -0,0 +1,333 @@
+/* global globalThis WeakRef FinalizationRegistry */
+import { assert, Fail } from '@agoric/assert';
+import { importBundle } from '@endo/import-bundle';
+import { makeMarshal } from '@endo/marshal';
+import {
+  makeLiveSlots,
+  insistVatDeliveryObject,
+  insistVatSyscallResult,
+} from '@agoric/swingset-liveslots';
+// import '../../types-ambient.js';
+// grumble... waitUntilQuiescent is exported and closes over ambient authority
+import { waitUntilQuiescent } from './waitUntilQuiescent.js';
+import { makeGcAndFinalize } from './gc-and-finalize.js';
+
+import {
+  makeSupervisorDispatch,
+  makeSupervisorSyscall,
+  makeVatConsole,
+} from './supervisor-helper.js';
+
+/**
+ * @typedef {import('@agoric/swingset-liveslots').VatDeliveryObject} VatDeliveryObject
+ * @typedef {import('@agoric/swingset-liveslots').VatDeliveryResult} VatDeliveryResult
+ * @typedef {import('@agoric/swingset-liveslots').VatSyscallObject} VatSyscallObject
+ * @typedef {import('@agoric/swingset-liveslots').VatSyscallResult} VatSyscallResult
+ * @typedef {import('@agoric/swingset-liveslots').VatSyscaller} VatSyscaller
+ * @typedef {import('@agoric/swingset-liveslots').LiveSlotsOptions} LiveSlotsOptions
+ * @typedef {import('@agoric/swingset-liveslots').MeterControl} MeterControl
+ */
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+// eslint-disable-next-line no-unused-vars
+function workerLog(first, ...args) {
+  // eslint-disable-next-line
+  // console.log(`---worker: ${first}`, ...args);
+}
+
+workerLog(`supervisor started`);
+
+function makeMeterControl() {
+  let meteringDisabled = 0;
+
+  function isMeteringDisabled() {
+    return !!meteringDisabled;
+  }
+
+  function assertIsMetered(msg) {
+    assert(!meteringDisabled, msg);
+  }
+  function assertNotMetered(msg) {
+    assert(!!meteringDisabled, msg);
+  }
+
+  function runWithoutMetering(thunk) {
+    const limit = globalThis.currentMeterLimit();
+    const before = globalThis.resetMeter(0, 0);
+    meteringDisabled += 1;
+    try {
+      return thunk();
+    } finally {
+      globalThis.resetMeter(limit, before);
+      meteringDisabled -= 1;
+    }
+  }
+
+  async function runWithoutMeteringAsync(thunk) {
+    const limit = globalThis.currentMeterLimit();
+    const before = globalThis.resetMeter(0, 0);
+    meteringDisabled += 1;
+    return Promise.resolve()
+      .then(() => thunk())
+      .finally(() => {
+        globalThis.resetMeter(limit, before);
+        meteringDisabled -= 1;
+      });
+  }
+
+  // return a version of f that runs outside metering
+  function unmetered(f) {
+    function wrapped(...args) {
+      return runWithoutMetering(() => f(...args));
+    }
+    return harden(wrapped);
+  }
+
+  /** @type { MeterControl } */
+  const meterControl = {
+    isMeteringDisabled,
+    assertIsMetered,
+    assertNotMetered,
+    runWithoutMetering,
+    runWithoutMeteringAsync,
+    unmetered,
+  };
+  return harden(meterControl);
+}
+
+const meterControl = makeMeterControl();
+
+/**
+ * Wrap byte-level protocols with tagged array codec.
+ *
+ * @param {(cmd: ArrayBuffer) => ArrayBuffer} issueCommand as from xsnap
+ * @typedef { [unknown, ...unknown[]] } Tagged tagged array
+ */
+function managerPort(issueCommand) {
+  /** @type { (item: Tagged) => ArrayBuffer } */
+  const encode = item => {
+    let txt;
+    try {
+      txt = JSON.stringify(item);
+    } catch (nope) {
+      workerLog(nope.message, item);
+      throw nope;
+    }
+    return encoder.encode(txt).buffer;
+  };
+
+  /** @type { (msg: ArrayBuffer) => any } */
+  const decodeData = msg => JSON.parse(decoder.decode(msg) || 'null');
+
+  /** @type { (msg: ArrayBuffer) => Tagged } */
+  function decode(msg) {
+    /** @type { Tagged } */
+    const item = decodeData(msg);
+    Array.isArray(item) || Fail`expected array`;
+    item.length > 0 || Fail`empty array lacks tag`;
+    return item;
+  }
+
+  return harden({
+    /** @type { (item: Tagged) => void } */
+    send: item => {
+      issueCommand(encode(item));
+    },
+    /** @type { (item: Tagged) => unknown } */
+    call: item => decodeData(issueCommand(encode(item))),
+
+    /**
+     * Wrap an async Tagged handler in the xsnap async reporting idiom.
+     *
+     * @param {(item: Tagged) => Promise<Tagged>} f async Tagged handler
+     * @returns {(msg: ArrayBuffer) => Report<ArrayBuffer>} xsnap style handleCommand
+     *
+     * @typedef { { result?: T } } Report<T> report T when idle
+     * @template T
+     */
+    handlerFrom(f) {
+      const lastResort = encoder.encode(`exception from ${f.name}`).buffer;
+      return msg => {
+        const report = {};
+        f(decode(msg))
+          .then(item => {
+            workerLog('result', item);
+            report.result = encode(item);
+          })
+          .catch(err => {
+            report.result = encode(['err', err.name, err.message]);
+          })
+          .catch(_err => {
+            report.result = lastResort;
+          });
+        return report;
+      };
+    },
+  });
+}
+
+// please excuse copy-and-paste from kernel.js
+function abbreviateReplacer(_, arg) {
+  if (typeof arg === 'bigint') {
+    // since testLog is only for testing, 2^53 is enough.
+    // precedent: 32a1dd3
+    return Number(arg);
+  }
+  if (typeof arg === 'string' && arg.length >= 40) {
+    // truncate long strings
+    return `${arg.slice(0, 15)}...${arg.slice(arg.length - 15)}`;
+  }
+  return arg;
+}
+
+/**
+ * @param {ReturnType<typeof managerPort>} port
+ */
+function makeWorker(port) {
+  /** @type { ((delivery: VatDeliveryObject) => Promise<VatDeliveryResult>) | null } */
+  let dispatch = null;
+
+  /**
+   * @param {unknown} vatID
+   * @param {unknown} bundle
+   * @param {LiveSlotsOptions} liveSlotsOptions
+   * @returns {Promise<Tagged>}
+   */
+  async function setBundle(vatID, bundle, liveSlotsOptions) {
+    /** @type { VatSyscaller } */
+    function syscallToManager(vatSyscallObject) {
+      workerLog('doSyscall', vatSyscallObject);
+      const result = port.call(['syscall', vatSyscallObject]);
+      workerLog(' ... syscall result:', result);
+      insistVatSyscallResult(result);
+      return result;
+    }
+
+    const syscall = makeSupervisorSyscall(syscallToManager, true);
+
+    const vatPowers = {
+      makeMarshal,
+      testLog: (...args) =>
+        port.send([
+          'testLog',
+          ...args.map(arg =>
+            typeof arg === 'string'
+              ? arg
+              : JSON.stringify(arg, abbreviateReplacer),
+          ),
+        ]),
+    };
+
+    const gcTools = harden({
+      WeakRef,
+      FinalizationRegistry,
+      waitUntilQuiescent,
+      gcAndFinalize: makeGcAndFinalize(globalThis.gc),
+      meterControl,
+    });
+
+    /** @param {string} source */
+    const makeLogMaker = source => {
+      /** @param {string} level */
+      const makeLog = level => {
+        // Capture the `console.log`, etc.'s `printAll` function.
+        const printAll = console[level];
+        assert.typeof(printAll, 'function');
+        const portSendingPrinter = (...args) => {
+          port.send(['sourcedConsole', source, level, ...args]);
+        };
+        return (...args) => {
+          // Use the causal console, but output to the port.
+          //
+          // FIXME: This is a hack until the start compartment can create
+          // Console objects that log to a different destination than
+          // `globalThis.console`.
+          const { print: savePrinter } = globalThis;
+          try {
+            globalThis.print = portSendingPrinter;
+            printAll(...args);
+          } finally {
+            globalThis.print = savePrinter;
+          }
+        };
+      };
+      return makeLog;
+    };
+
+    const workerEndowments = {
+      console: makeVatConsole(makeLogMaker('vat')),
+      assert,
+      // bootstrap provides HandledPromise
+      HandledPromise: globalThis.HandledPromise,
+      TextEncoder,
+      TextDecoder,
+      Base64: globalThis.Base64, // Present only in XSnap
+    };
+
+    async function buildVatNamespace(
+      lsEndowments,
+      inescapableGlobalProperties,
+    ) {
+      const vatNS = await importBundle(bundle, {
+        endowments: { ...workerEndowments, ...lsEndowments },
+        inescapableGlobalProperties,
+      });
+      workerLog(`got vatNS:`, Object.keys(vatNS).join(','));
+      return vatNS;
+    }
+
+    const ls = makeLiveSlots(
+      syscall,
+      vatID,
+      vatPowers,
+      liveSlotsOptions,
+      gcTools,
+      makeVatConsole(makeLogMaker('ls')),
+      buildVatNamespace,
+    );
+
+    assert(ls.dispatch);
+    dispatch = makeSupervisorDispatch(ls.dispatch);
+    workerLog(`got dispatch`);
+    return ['dispatchReady'];
+  }
+
+  /** @type { (item: Tagged) => Promise<Tagged> } */
+  async function handleItem([tag, ...args]) {
+    workerLog('handleItem', tag, args.length);
+    switch (tag) {
+      case 'setBundle': {
+        assert(!dispatch, 'cannot setBundle again');
+        const liveSlotsOptions = /** @type LiveSlotsOptions */ (args[2]);
+        return setBundle(args[0], args[1], liveSlotsOptions);
+      }
+      case 'deliver': {
+        assert(dispatch, 'cannot deliver before setBundle');
+        const [vatDeliveryObject] = args;
+        harden(vatDeliveryObject);
+        insistVatDeliveryObject(vatDeliveryObject);
+        return dispatch(vatDeliveryObject);
+      }
+      default:
+        workerLog('handleItem: bad tag', tag, args.length);
+        return ['bad tag', tag];
+    }
+  }
+
+  return harden({
+    handleItem,
+  });
+}
+
+// xsnap provides issueCommand global
+const port = managerPort(globalThis.issueCommand);
+const worker = makeWorker(port);
+
+// Send unexpected console messages to the manager port.
+globalThis.print = (...args) => {
+  port.send(['sourcedConsole', 'xsnap', 'error', ...args]);
+};
+
+globalThis.handleCommand = port.handlerFrom(worker.handleItem);

package/lib/waitUntilQuiescent.js

@@ -0,0 +1,18 @@
+/* global setImmediate */
+import { makePromiseKit } from '@endo/promise-kit';
+
+// This can only be imported from the Start Compartment, where 'setImmediate'
+// is available.
+
+export function waitUntilQuiescent() {
+  // the delivery might cause some number of (native) Promises to be
+  // created and resolved, so we use the IO queue to detect when the
+  // Promise queue is empty. The IO queue (setImmediate and setTimeout) is
+  // lower-priority than the Promise queue on browsers and Node 11, but on
+  // Node 10 it is higher. So this trick requires Node 11.
+  // https://jsblog.insiderattack.net/new-changes-to-timers-and-microtasks-from-node-v11-0-0-and-above-68d112743eb3
+  /** @type {import('@endo/promise-kit').PromiseKit<void>} */
+  const { promise: queueEmptyP, resolve } = makePromiseKit();
+  setImmediate(() => resolve());
+  return queueEmptyP;
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@agoric/swingset-xsnap-supervisor",
+  "version": "0.9.1-dev-6e51de2.0+6e51de2",
+  "description": "Supervisor/Liveslots bundle for swingset xsnap workers",
+  "author": "Agoric",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build:bundle": "node scripts/build-bundle.js",
+    "build": "yarn build:bundle",
+    "clean": "rm -rf dist",
+    "lint": "run-s --continue-on-error lint:*",
+    "lint:js": "eslint 'lib/**/*.js' 'src/**/*.js' 'scripts/**/*.js' 'test/**/*.js'",
+    "lint:types": "tsc -p jsconfig.json",
+    "lint-fix": "eslint --fix 'lib/**/*.js' 'src/**/*.js' 'scripts/**/*.js' 'test/**/*.js'",
+    "test": "ava",
+    "test:c8": "c8 $C8_OPTIONS ava --config=ava-nesm.config.js",
+    "test:xs": "exit 0"
+  },
+  "devDependencies": {
+    "@agoric/assert": "0.5.2-dev-6e51de2.0+6e51de2",
+    "@agoric/swingset-liveslots": "0.9.1-dev-6e51de2.0+6e51de2",
+    "@endo/bundle-source": "^2.4.2",
+    "@endo/import-bundle": "^0.3.0",
+    "@endo/init": "^0.5.52",
+    "@endo/marshal": "^0.8.1",
+    "ava": "^5.2.0",
+    "c8": "^7.13.0"
+  },
+  "files": [
+    "LICENSE*",
+    "lib",
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "ava": {
+    "files": [
+      "test/**/test-*.js"
+    ],
+    "timeout": "2m",
+    "workerThreads": false
+  },
+  "gitHead": "6e51de2dd0b371a2e52355a23be623a25d6390ff"
+}