@agoric/swingset-vat 0.33.0-u16.0 → 0.33.0-u17.0

package/src/kernel/state/reachable.js

@@ -1,4 +1,4 @@
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 
 export function parseReachableAndVatSlot(value) {
   typeof value === 'string' || Fail`non-string value: ${value}`;

package/src/kernel/state/stats.js

@@ -1,4 +1,4 @@
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 
 /** @typedef {'counter' | 'gauge'} KernelStatsMetricType */
 /**

package/src/kernel/state/storageHelper.js

@@ -1,6 +1,6 @@
 // @ts-check
 
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 
 /**
  * Iterate over keys with a given prefix, in lexicographic order,

package/src/kernel/state/vatKeeper.js

@@ -1,8 +1,9 @@
 /**
  * Kernel's keeper of persistent state for a vat.
  */
-import { Nat, isNat } from '@endo/nat';
-import { assert, q, Fail } from '@agoric/assert';
+import { Nat } from '@endo/nat';
+import { assert, q, Fail } from '@endo/errors';
+import { isObject } from '@endo/marshal';
 import { parseKernelSlot } from '../parseKernelSlots.js';
 import { makeVatSlot, parseVatSlot } from '../../lib/parseVatSlots.js';
 import { insistVatID } from '../../lib/id.js';
@@ -18,7 +19,9 @@ import { enumeratePrefixedKeys } from './storageHelper.js';
  * @typedef { import('../../types-external.js').SnapStore } SnapStore
  * @typedef { import('../../types-external.js').SourceOfBundle } SourceOfBundle
  * @typedef { import('../../types-external.js').TranscriptStore } TranscriptStore
+ * @typedef { import('../../types-internal.js').Dirt } Dirt
  * @typedef { import('../../types-internal.js').VatManager } VatManager
+ * @typedef { import('../../types-internal.js').ReapDirtThreshold } ReapDirtThreshold
  * @typedef { import('../../types-internal.js').RecordedVatOptions } RecordedVatOptions
  * @typedef { import('../../types-internal.js').TranscriptEntry } TranscriptEntry
  * @import {TranscriptDeliverySaveSnapshot} from '../../types-internal.js'
@@ -32,18 +35,50 @@ const FIRST_OBJECT_ID = 50n;
 const FIRST_PROMISE_ID = 60n;
 const FIRST_DEVICE_ID = 70n;
 
+// TODO: we export this from vatKeeper.js, and import it from
+// kernelKeeper.js, because both files need it, and we want to avoid
+// an import cycle (kernelKeeper imports other things from vatKeeper),
+// but it really wants to live in kernelKeeper not vatKeeper
+export const DEFAULT_REAP_DIRT_THRESHOLD_KEY =
+  'kernel.defaultReapDirtThreshold';
+
+const isBundleSource = source => {
+  return (
+    isObject(source) &&
+    (isObject(source.bundle) ||
+      typeof source.bundleName === 'string' ||
+      typeof source.bundleID === 'string')
+  );
+};
+
 /**
  * Establish a vat's state.
  *
  * @param {*} kvStore  The key-value store in which the persistent state will be kept
  * @param {*} transcriptStore  Accompanying transcript store
  * @param {string} vatID The vat ID string of the vat in question
- * TODO: consider making this part of makeVatKeeper
+ * @param {SourceOfBundle} source
+ * @param {RecordedVatOptions} options
  */
-export function initializeVatState(kvStore, transcriptStore, vatID) {
+export function initializeVatState(
+  kvStore,
+  transcriptStore,
+  vatID,
+  source,
+  options,
+) {
+  assert(isBundleSource(source), `vat ${vatID} source has wrong shape`);
+  assert(
+    isObject(options) && isObject(options.workerOptions),
+    `vat ${vatID} options is missing workerOptions`,
+  );
+
   kvStore.set(`${vatID}.o.nextID`, `${FIRST_OBJECT_ID}`);
   kvStore.set(`${vatID}.p.nextID`, `${FIRST_PROMISE_ID}`);
   kvStore.set(`${vatID}.d.nextID`, `${FIRST_DEVICE_ID}`);
+  kvStore.set(`${vatID}.reapDirt`, JSON.stringify({}));
+  kvStore.set(`${vatID}.source`, JSON.stringify(source));
+  kvStore.set(`${vatID}.options`, JSON.stringify(options));
   transcriptStore.initTranscript(vatID);
 }
 
@@ -68,6 +103,7 @@ export function initializeVatState(kvStore, transcriptStore, vatID) {
  * @param {*} incStat
  * @param {*} decStat
  * @param {*} getCrankNumber
+ * @param {*} scheduleReap
  * @param {SnapStore} [snapStore]
  * returns an object to hold and access the kernel's state for the given vat
  */
@@ -88,10 +124,16 @@ export function makeVatKeeper(
   incStat,
   decStat,
   getCrankNumber,
+  scheduleReap,
   snapStore = undefined,
 ) {
   insistVatID(vatID);
 
+  // note: calling makeVatKeeper() does not change the DB. Any
+  // initialization or upgrade must be complete before it is
+  // called. Only the methods returned by makeVatKeeper() will change
+  // the DB.
+
   function getRequired(key) {
     const value = kvStore.get(key);
     if (value === undefined) {
@@ -100,6 +142,8 @@ export function makeVatKeeper(
     return value;
   }
 
+  const reapDirtKey = `${vatID}.reapDirt`;
+
   /**
    * @param {SourceOfBundle} source
    * @param {RecordedVatOptions} options
@@ -125,45 +169,80 @@ export function makeVatKeeper(
 
   function getOptions() {
     /** @type { RecordedVatOptions } */
-    const options = JSON.parse(kvStore.get(`${vatID}.options`) || '{}');
+    const options = JSON.parse(getRequired(`${vatID}.options`));
     return harden(options);
   }
 
-  function initializeReapCountdown(count) {
-    count === 'never' || isNat(count) || Fail`bad reapCountdown ${count}`;
-    kvStore.set(`${vatID}.reapInterval`, `${count}`);
-    kvStore.set(`${vatID}.reapCountdown`, `${count}`);
-  }
+  // This is named "addDirt" because it should increment all dirt
+  // counters (both for reap/BOYD and for heap snapshotting). We don't
+  // have `heapSnapshotDirt` yet, but when we do, it should get
+  // incremented here.
 
-  function updateReapInterval(reapInterval) {
-    reapInterval === 'never' ||
-      isNat(reapInterval) ||
-      Fail`bad reapInterval ${reapInterval}`;
-    kvStore.set(`${vatID}.reapInterval`, `${reapInterval}`);
-    if (reapInterval === 'never') {
-      kvStore.set(`${vatID}.reapCountdown`, 'never');
+  /**
+   * Add some "dirt" to the vat, possibly triggering a reap/BOYD.
+   *
+   * @param {Dirt} moreDirt
+   */
+  function addDirt(moreDirt) {
+    assert.typeof(moreDirt, 'object');
+    const reapDirt = JSON.parse(getRequired(reapDirtKey));
+    const thresholds = {
+      ...JSON.parse(getRequired(DEFAULT_REAP_DIRT_THRESHOLD_KEY)),
+      ...JSON.parse(getRequired(`${vatID}.options`)).reapDirtThreshold,
+    };
+    let reap = false;
+    for (const key of Object.keys(moreDirt)) {
+      const threshold = thresholds[key];
+      // Don't accumulate dirt if it can't eventually trigger a
+      // BOYD. This is mainly to keep comms from counting upwards
+      // forever. TODO revisit this when we add heapSnapshotDirt,
+      // maybe check both thresholds and accumulate the dirt if either
+      // one is non-'never'.
+      if (threshold && threshold !== 'never') {
+        const oldDirt = reapDirt[key] || 0;
+        // The 'moreDirt' value might be Number or BigInt (eg
+        // .computrons). We coerce to Number so we can JSON-stringify.
+        const newDirt = oldDirt + Number(moreDirt[key]);
+        reapDirt[key] = newDirt;
+        if (newDirt >= threshold) {
+          reap = true;
+        }
+      }
     }
-  }
-
-  function countdownToReap() {
-    const rawCount = getRequired(`${vatID}.reapCountdown`);
-    if (rawCount === 'never') {
-      return false;
-    } else {
-      const count = Number.parseInt(rawCount, 10);
-      if (count === 1) {
-        kvStore.set(
-          `${vatID}.reapCountdown`,
-          getRequired(`${vatID}.reapInterval`),
-        );
-        return true;
-      } else {
-        kvStore.set(`${vatID}.reapCountdown`, `${count - 1}`);
-        return false;
+    if (!thresholds.never) {
+      kvStore.set(reapDirtKey, JSON.stringify(reapDirt));
+      if (reap) {
+        scheduleReap(vatID);
       }
     }
   }
 
+  function getReapDirt() {
+    return JSON.parse(getRequired(reapDirtKey));
+  }
+
+  function clearReapDirt() {
+    // This is only called after a BOYD, so it should only clear the
+    // reap/BOYD counters. If/when we add heap-snapshot counters,
+    // those should get cleared in a separate clearHeapSnapshotDirt()
+    // function.
+    const reapDirt = {};
+    kvStore.set(reapDirtKey, JSON.stringify(reapDirt));
+  }
+
+  function getReapDirtThreshold() {
+    return getOptions().reapDirtThreshold;
+  }
+
+  /**
+   * @param {ReapDirtThreshold} reapDirtThreshold
+   */
+  function setReapDirtThreshold(reapDirtThreshold) {
+    assert.typeof(reapDirtThreshold, 'object');
+    const options = { ...getOptions(), reapDirtThreshold };
+    kvStore.set(`${vatID}.options`, JSON.stringify(options));
+  }
+
   function nextDeliveryNum() {
     const { endPos } = transcriptStore.getCurrentSpanBounds(vatID);
     return Nat(endPos);
@@ -576,7 +655,7 @@ export function makeVatKeeper(
     addToTranscript(makeSaveSnapshotItem(snapshotID));
 
     // then start a new transcript span
-    transcriptStore.rolloverSpan(vatID);
+    await transcriptStore.rolloverSpan(vatID);
 
     // then push a load-snapshot entry, so that the current span
     // always starts with an initialize-worker or load-snapshot
@@ -596,14 +675,47 @@ export function makeVatKeeper(
     });
   }
 
-  function deleteSnapshotsAndTranscript() {
-    if (snapStore) {
-      snapStore.deleteVatSnapshots(vatID);
+  /**
+   * Perform some (possibly-limited) cleanup work for a vat. Returns
+   * 'done' (where false means "please call me again", and true means
+   * "you can delete the vatID now"), and a count of how much work was
+   * done (so the runPolicy can decide when to stop).
+   *
+   * @param {number} [budget]
+   * @returns {{ done: boolean, cleanups: number }}
+   *
+   */
+  function deleteSnapshots(budget = undefined) {
+    // Each budget=1 allows us to delete one snapshot entry.
+    if (!snapStore) {
+      return { done: true, cleanups: 0 };
     }
-    transcriptStore.deleteVatTranscripts(vatID);
+    // initially uses 2+2*budget DB statements, then just 1 when done
+    return snapStore.deleteVatSnapshots(vatID, budget);
+  }
+
+  /**
+   * Perform some (possibly-limited) cleanup work for a vat. Returns
+   * 'done' (where false means "please call me again", and true means
+   * "you can delete the vatID now"), and a count of how much work was
+   * done (so the runPolicy can decide when to stop).
+   *
+   * @param {number} [budget]
+   * @returns {{ done: boolean, cleanups: number }}
+   *
+   */
+  function deleteTranscripts(budget = undefined) {
+    // Each budget=1 allows us to delete one transcript span and any
+    // transcript items associated with that span. Some nodes will
+    // have historical transcript items, some will not. Using budget=5
+    // and snapshotInterval=200 means we delete 5 span records and
+    // maybe 1000 span items.
+
+    // initially uses 2+3*budget DB statements, then just 1 when done
+    return transcriptStore.deleteVatTranscripts(vatID, budget);
   }
 
-  function beginNewIncarnation() {
+  async function beginNewIncarnation() {
     if (snapStore) {
       snapStore.stopUsingLastSnapshot(vatID);
     }
@@ -656,9 +768,11 @@ export function makeVatKeeper(
     setSourceAndOptions,
     getSourceAndOptions,
     getOptions,
-    initializeReapCountdown,
-    countdownToReap,
-    updateReapInterval,
+    addDirt,
+    getReapDirt,
+    clearReapDirt,
+    getReapDirtThreshold,
+    setReapDirtThreshold,
     nextDeliveryNum,
     getIncarnationNumber,
     importsKernelSlot,
@@ -680,7 +794,8 @@ export function makeVatKeeper(
     dumpState,
     saveSnapshot,
     getSnapshotInfo,
-    deleteSnapshotsAndTranscript,
+    deleteSnapshots,
+    deleteTranscripts,
     beginNewIncarnation,
   });
 }

package/src/kernel/vat-admin-hooks.js

@@ -1,4 +1,4 @@
-import { assert } from '@agoric/assert';
+import { assert } from '@endo/errors';
 import { kser, kunser } from '@agoric/kmarshal';
 import { insistVatID } from '../lib/id.js';
 
@@ -94,6 +94,9 @@ export function makeVatAdminHooks(tools) {
       // we don't need to incrementRefCount because if terminateVat sends
       // 'reason' to vat-admin, it uses notifyTermination / queueToKref /
       // doSend, and doSend() does its own incref
+      // FIXME: This assumes that most work of terminateVat happens in the
+      // synchronous prelude, which should be made more obvious. For details,
+      // see https://github.com/Agoric/agoric-sdk/pull/10055#discussion_r1754918394
       void terminateVat(vatID, true, marshalledReason);
       // TODO: terminateVat is async, result doesn't fire until worker
       // is dead. To fix this we'll probably need to move termination

package/src/kernel/vat-loader/manager-factory.js

@@ -1,4 +1,4 @@
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 import { assertKnownOptions } from '../../lib/assertOptions.js';
 import { makeLocalVatManagerFactory } from './manager-local.js';
 import { makeNodeSubprocessFactory } from './manager-subprocess-node.js';
@@ -45,7 +45,6 @@ export function makeVatManagerFactory({
       'enableSetup',
       'useTranscript',
       'critical',
-      'reapInterval',
       'sourcedConsole',
       'name',
     ]);

package/src/kernel/vat-loader/manager-helper.js

@@ -1,4 +1,4 @@
-import { assert } from '@agoric/assert';
+import { assert } from '@endo/errors';
 import '../../types-ambient.js';
 import {
   insistVatDeliveryResult,

package/src/kernel/vat-loader/manager-local.js

@@ -1,6 +1,6 @@
 /* global globalThis */
 
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 import { importBundle } from '@endo/import-bundle';
 import { makeLiveSlots } from '@agoric/swingset-liveslots';
 import { makeManagerKit } from './manager-helper.js';

package/src/kernel/vat-loader/manager-subprocess-node.js

@@ -1,6 +1,6 @@
 // import { spawn } from 'child_process'; // not from Compartment
 
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 import { E } from '@endo/eventual-send';
 import { makePromiseKit } from '@endo/promise-kit';
 import { makeManagerKit } from './manager-helper.js';

package/src/kernel/vat-loader/manager-subprocess-xsnap.js

@@ -1,5 +1,5 @@
 import { synchronizedTee } from '@agoric/internal';
-import { assert, Fail, q } from '@agoric/assert';
+import { assert, Fail, q } from '@endo/errors';
 import { ExitCode } from '@agoric/xsnap/api.js';
 import { makeManagerKit } from './manager-helper.js';
 

package/src/kernel/vat-loader/vat-loader.js

@@ -1,4 +1,4 @@
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 import { assertKnownOptions } from '../../lib/assertOptions.js';
 import { makeVatSlot } from '../../lib/parseVatSlots.js';
 
@@ -26,7 +26,7 @@ export function makeVatLoader(stuff) {
     'enablePipelining',
     'useTranscript',
     'critical',
-    'reapInterval',
+    'reapDirtThreshold',
   ];
 
   /**

package/src/kernel/vat-warehouse.js

@@ -1,4 +1,4 @@
-import { assert, Fail, quote as q } from '@agoric/assert';
+import { assert, Fail, q } from '@endo/errors';
 import { isNat } from '@endo/nat';
 import { makeVatTranslators } from './vatTranslator.js';
 import { insistVatDeliveryResult } from '../lib/message.js';
@@ -544,6 +544,10 @@ export function makeVatWarehouse({
       vatKeeper.addToTranscript(getTranscriptEntry(vd, deliveryResult));
     }
 
+    if (kd[0] === 'bringOutYourDead') {
+      vatKeeper.clearReapDirt(); // BOYD zeros out the when-to-BOYD counters
+    }
+
     // TODO: if per-vat policy decides it wants a BOYD or heap snapshot,
     // now is the time to do it, or to ask the kernel to schedule it
 

package/src/kernel/vatTranslator.js

@@ -1,4 +1,4 @@
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 import { insistMessage } from '../lib/message.js';
 import { insistKernelType, parseKernelSlot } from './parseKernelSlots.js';
 import { insistVatType, parseVatSlot } from '../lib/parseVatSlots.js';
@@ -481,9 +481,6 @@ function makeTranslateVatSyscallToKernelSyscall(vatID, kernelKeeper) {
       assert.equal(allocatedByVat, true); // abandon *exports*, not imports
       // kref must already be in the clist
       const kref = mapVatSlotToKernelSlot(vref, gcSyscallMapOpts);
-      // note that this is effectful and also performed outside of a syscall
-      // by processUpgradeVat in {@link ./kernel.js}
-      vatKeeper.deleteCListEntry(kref, vref);
       return kref;
     });
     kdebug(`syscall[${vatID}].abandonExports(${krefs.join(' ')})`);

package/src/lib/assertOptions.js

@@ -1,4 +1,4 @@
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 
 export function assertKnownOptions(options, knownNames) {
   assert(knownNames instanceof Array);

package/src/lib/capdata.js

@@ -1,4 +1,4 @@
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 import { passStyleOf } from '@endo/far';
 import { kunser, krefOf } from '@agoric/kmarshal';
 

package/src/lib/id.js

@@ -1,6 +1,6 @@
 import { Nat } from '@endo/nat';
 
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 
 // Vats are identified by an integer index, which (for typechecking purposes)
 // is encoded as `vNN`. Devices are similarly identified as `dNN`. Both have

package/src/lib/message.js

@@ -1,4 +1,4 @@
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 import { insistCapData } from './capdata.js';
 
 /**

package/src/lib/parseVatSlots.js

@@ -1,5 +1,5 @@
 import { Nat } from '@endo/nat';
-import { assert, Fail } from '@agoric/assert';
+import { assert, Fail } from '@endo/errors';
 
 // NOTE: confusing terminology: "slot" vs. "reference".  All these things
 // called "slots" are references, but the word "slot" suggests something into

package/src/lib/recordVatOptions.js

@@ -1,4 +1,4 @@
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 import { makeWorkerOptions } from './workerOptions.js';
 
 export const makeVatOptionRecorder = (kernelKeeper, bundleHandler) => {
@@ -10,7 +10,9 @@ export const makeVatOptionRecorder = (kernelKeeper, bundleHandler) => {
       enablePipelining = false,
       enableDisavow = false,
       useTranscript = true,
-      reapInterval = kernelKeeper.getDefaultReapInterval(),
+      reapInterval,
+      reapGCKrefs,
+      neverReap = false,
       critical = false,
       meterID = undefined,
       managerType = kernelKeeper.getDefaultManagerType(),
@@ -21,6 +23,17 @@ export const makeVatOptionRecorder = (kernelKeeper, bundleHandler) => {
     if (unused.length) {
       Fail`OptionRecorder: ${vatID} unused options ${unused.join(',')}`;
     }
+    const reapDirtThreshold = {};
+    if (reapInterval !== undefined) {
+      reapDirtThreshold.deliveries = reapInterval;
+    }
+    if (reapGCKrefs !== undefined) {
+      reapDirtThreshold.gcKrefs = reapGCKrefs;
+    }
+    if (neverReap) {
+      reapDirtThreshold.never = true;
+    }
+    // TODO no computrons knob?
     const workerOptions = await makeWorkerOptions(
       managerType,
       bundleHandler,
@@ -35,13 +48,12 @@ export const makeVatOptionRecorder = (kernelKeeper, bundleHandler) => {
       enablePipelining,
       enableDisavow,
       useTranscript,
-      reapInterval,
+      reapDirtThreshold,
       critical,
       meterID,
     });
-    const vatKeeper = kernelKeeper.provideVatKeeper(vatID);
-    vatKeeper.setSourceAndOptions(source, vatOptions);
-    vatKeeper.initializeReapCountdown(vatOptions.reapInterval);
+    // want vNN.options to be in place before provideVatKeeper, so it can cache reapDirtThreshold in RAM, so:
+    kernelKeeper.createVatState(vatID, source, vatOptions);
   };
 
   /**

package/src/lib/runPolicies.js

@@ -1,8 +1,11 @@
-import { assert } from '@agoric/assert';
+import { assert } from '@endo/errors';
 
 export function foreverPolicy() {
   /** @type { RunPolicy } */
   return harden({
+    allowCleanup() {
+      return true; // unlimited budget
+    },
     vatCreated(_details) {
       return true;
     },
@@ -27,6 +30,9 @@ export function crankCounter(
   let vats = 0;
   /** @type { RunPolicy } */
   const policy = harden({
+    allowCleanup() {
+      return { default: 100 }; // limited budget
+    },
     vatCreated() {
       vats += 1;
       return vats < maxCreateVats;
@@ -47,13 +53,21 @@ export function crankCounter(
   return policy;
 }
 
-export function computronCounter(limit) {
+export function computronCounter(limit, options = {}) {
   assert.typeof(limit, 'bigint');
+  const {
+    cleanupBudget = 100,
+    vatCreatedComputrons = 100_000n, // pretend that's the cost
+    crankFailedComputrons = 1_000_000n,
+  } = options;
   let total = 0n;
   /** @type { RunPolicy } */
   const policy = harden({
+    allowCleanup() {
+      return { default: cleanupBudget }; // limited budget
+    },
     vatCreated() {
-      total += 100000n; // pretend vat creation takes 100k computrons
+      total += vatCreatedComputrons;
       return total < limit;
     },
     crankComplete(details = {}) {
@@ -65,7 +79,7 @@ export function computronCounter(limit) {
       return total < limit;
     },
     crankFailed() {
-      total += 1000000n; // who knows, 1M is as good as anything
+      total += crankFailedComputrons;
       return total < limit;
     },
     emptyCrank() {
@@ -79,6 +93,7 @@ export function wallClockWaiter(seconds) {
   const timeout = Date.now() + 1000 * seconds;
   /** @type { RunPolicy } */
   const policy = harden({
+    allowCleanup: () => true, // unlimited budget
     vatCreated: () => Date.now() < timeout,
     crankComplete: () => Date.now() < timeout,
     crankFailed: () => Date.now() < timeout,
@@ -86,3 +101,34 @@ export function wallClockWaiter(seconds) {
   });
   return policy;
 }
+
+export function noCleanup() {
+  /** @type { RunPolicy } */
+  const policy = harden({
+    allowCleanup: () => false,
+    vatCreated: () => true,
+    crankComplete: () => true,
+    crankFailed: () => true,
+    emptyCrank: () => true,
+  });
+  return policy;
+}
+
+export function someCleanup(budget) {
+  let once = true;
+  /** @type { RunPolicy } */
+  const policy = harden({
+    allowCleanup: () => {
+      if (once) {
+        once = false;
+        return { default: budget };
+      }
+      return false;
+    },
+    vatCreated: () => true,
+    crankComplete: () => true,
+    crankFailed: () => true,
+    emptyCrank: () => true,
+  });
+  return policy;
+}

package/src/lib/storageAPI.js

@@ -1,4 +1,4 @@
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 
 /**
  * Assert function to ensure that an object implements the StorageAPI

package/src/lib/workerOptions.js

@@ -1,4 +1,4 @@
-import { Fail } from '@agoric/assert';
+import { Fail } from '@endo/errors';
 
 /**
  * @param {string} managerType

package/src/supervisors/subprocess-node/supervisor-subprocess-node.js

@@ -8,7 +8,7 @@ import fs from 'fs';
 import { Buffer } from 'buffer';
 import process from 'node:process';
 
-import { assert, details as X, Fail } from '@agoric/assert';
+import { assert, X, Fail } from '@endo/errors';
 import { importBundle } from '@endo/import-bundle';
 import { makeMarshal } from '@endo/marshal';
 import {