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

package/tools/fakeVirtualSupport.d.ts

@@ -0,0 +1,278 @@
+export function makeFakeLiveSlotsStuff(options?: {}): {
+    syscall: {
+        vatstoreGet(key: any): any;
+        vatstoreGetNextKey(priorKey: any): any;
+        vatstoreSet(key: any, value: any): void;
+        vatstoreDelete(key: any): void;
+    };
+    allocateExportID: () => any;
+    allocatePromiseID: () => any;
+    allocateCollectionID: () => any;
+    getSlotForVal: (val: any) => any;
+    requiredValForSlot: (slot: any) => any;
+    getValForSlot: (slot: any) => any;
+    setValForSlot: (slot: any, val: any) => void;
+    registerEntry: (baseRef: any, val: any, valIsCohort: any) => void;
+    valToSlot: any;
+    slotToVal: Map<any, any>;
+    convertValToSlot: (val: any) => any;
+    convertSlotToVal: (slot: any) => any;
+    marshal: {
+        toCapData: import("@endo/marshal").ToCapData<any>;
+        fromCapData: import("@endo/marshal").FromCapData<any>;
+        serialize: import("@endo/marshal").ToCapData<any>;
+        unserialize: import("@endo/marshal").FromCapData<any>;
+    };
+    deleteEntry: (slot: any, val: any) => void;
+    FinalizationRegistry: any;
+    WeakRef: any;
+    WeakMap: any;
+    WeakSet: any;
+    addToPossiblyDeadSet: any;
+    addToPossiblyRetiredSet: any;
+    dumpStore: () => any[][];
+    setVrm: (vrmToUse: any) => void;
+    assertAcceptableSyscallCapdataSize: (_capdatas: any) => void;
+    maybeExportPromise: (_vref: any) => boolean;
+};
+export function makeFakeVirtualReferenceManager(fakeStuff: any, relaxDurabilityRules?: boolean): {
+    registerDroppedCollection: (target: any, descriptor: any) => void;
+    isDurable: (vref: string) => boolean;
+    isDurableKind: (kindID: string) => boolean;
+    registerKind: (kindID: string, reanimator?: (string: any, boolean: any) => object, deleter?: (string: any) => boolean, durable?: boolean) => void;
+    rememberFacetNames: (kindID: string, facetNames: string[] | null) => void;
+    getFacet: (kindID: any, facets: any, facetIndex: any) => any;
+    getFacetNames: (kindID: any) => any;
+    reanimate: (baseRef: string) => any;
+    addReachableVref: (vref: any) => void;
+    removeReachableVref: (vref: any) => boolean;
+    updateReferenceCounts: (beforeSlots: any, afterSlots: any) => void;
+    getReachablePromiseRefCount: (p: any) => number;
+    addRecognizableValue: (value: any, recognizer: string | (Map<string, any> | Set<string>), recognizerIsVirtual?: boolean) => void;
+    removeRecognizableVref: (vref: string, recognizer: string | (Map<string, any> | Set<string>), recognizerIsVirtual?: boolean) => void;
+    removeRecognizableValue: (value: any, recognizer: string | (Map<string, any> | Set<string>), recognizerIsVirtual?: boolean) => void;
+    vrefKey: (value: any) => string | undefined;
+    isPresenceReachable: (vref: string) => boolean;
+    isVrefRecognizable: (vref: any) => boolean;
+    setExportStatus: (vref: any, exportStatus: any) => void;
+    isVirtualObjectReachable: (baseRef: string) => boolean;
+    deleteVirtualObject: (baseRef: string) => [boolean, string[]];
+    ceaseRecognition: (vref: string) => boolean;
+    setDeleteCollectionEntry: (fn: any) => void;
+    getRetentionStats: () => {
+        remotableRefCounts: number;
+        vrefRecognizers: number;
+        kindInfoTable: number;
+    };
+    initializeIDCounters: () => void;
+    allocateNextID: (name: any) => number;
+    flushIDCounters: () => void;
+    testHooks: {
+        getReachableRefCount: (vref: any) => number | undefined;
+        countCollectionsForWeakKey: (vref: any) => number;
+        getDroppedCollectionRegistry: () => any;
+        remotableRefCounts: Map<any, number>;
+        vrefRecognizers: Map<string, Set<Map<string, any> | Set<string>>>;
+        kindInfoTable: Map<any, any>;
+    };
+};
+export function makeFakeWatchedPromiseManager(vrm: any, vom: any, collectionManager: any, fakeStuff: any): {
+    preparePromiseWatcherTables: () => void;
+    loadWatchedPromiseTable: (revivePromise: (vref: any) => Promise<any>) => void;
+    providePromiseWatcher: <V, A extends any[]>(kindHandle: import("../src/vatDataTypes.js").DurableKindHandle, fulfillHandler?: (value: V, ...args: A) => void, rejectHandler?: (reason: any, ...args: A) => void) => import("../src/types.js").PromiseWatcher<V, A>;
+    watchPromise: <P extends Promise<any>, A extends any[]>(p: P, watcher: import("../src/types.js").PromiseWatcher<Awaited<P>, A>, ...args: A) => void;
+};
+/**
+ * Configure virtual stuff with relaxed durability rules and fake liveslots
+ *
+ * @param {object} [options]
+ * @param {number} [options.cacheSize]
+ * @param {boolean} [options.relaxDurabilityRules]
+ * @param {Map<string, string>} [options.fakeStore]
+ * @param {WeakMapConstructor} [options.WeakMap]
+ * @param {WeakSetConstructor} [options.WeakSet]
+ * @param {boolean} [options.weak]
+ */
+export function makeFakeVirtualStuff(options?: {
+    cacheSize?: number | undefined;
+    relaxDurabilityRules?: boolean | undefined;
+    fakeStore?: Map<string, string> | undefined;
+    WeakMap?: WeakMapConstructor | undefined;
+    WeakSet?: WeakSetConstructor | undefined;
+    weak?: boolean | undefined;
+}): {
+    fakeStuff: {
+        syscall: {
+            vatstoreGet(key: any): any;
+            vatstoreGetNextKey(priorKey: any): any;
+            vatstoreSet(key: any, value: any): void;
+            vatstoreDelete(key: any): void;
+        };
+        allocateExportID: () => any;
+        allocatePromiseID: () => any;
+        allocateCollectionID: () => any;
+        getSlotForVal: (val: any) => any;
+        requiredValForSlot: (slot: any) => any;
+        getValForSlot: (slot: any) => any;
+        setValForSlot: (slot: any, val: any) => void;
+        registerEntry: (baseRef: any, val: any, valIsCohort: any) => void;
+        valToSlot: any;
+        slotToVal: Map<any, any>;
+        convertValToSlot: (val: any) => any;
+        convertSlotToVal: (slot: any) => any;
+        marshal: {
+            toCapData: import("@endo/marshal").ToCapData<any>;
+            fromCapData: import("@endo/marshal").FromCapData<any>;
+            serialize: import("@endo/marshal").ToCapData<any>;
+            unserialize: import("@endo/marshal").FromCapData<any>;
+        };
+        deleteEntry: (slot: any, val: any) => void;
+        FinalizationRegistry: any;
+        WeakRef: any;
+        WeakMap: any;
+        WeakSet: any;
+        addToPossiblyDeadSet: any;
+        addToPossiblyRetiredSet: any;
+        dumpStore: () => any[][];
+        setVrm: (vrmToUse: any) => void;
+        assertAcceptableSyscallCapdataSize: (_capdatas: any) => void;
+        maybeExportPromise: (_vref: any) => boolean;
+    };
+    vrm: {
+        registerDroppedCollection: (target: any, descriptor: any) => void;
+        isDurable: (vref: string) => boolean;
+        isDurableKind: (kindID: string) => boolean;
+        registerKind: (kindID: string, reanimator?: (string: any, boolean: any) => object, deleter?: (string: any) => boolean, durable?: boolean) => void;
+        rememberFacetNames: (kindID: string, facetNames: string[] | null) => void;
+        getFacet: (kindID: any, facets: any, facetIndex: any) => any;
+        getFacetNames: (kindID: any) => any;
+        reanimate: (baseRef: string) => any;
+        addReachableVref: (vref: any) => void;
+        removeReachableVref: (vref: any) => boolean;
+        updateReferenceCounts: (beforeSlots: any, afterSlots: any) => void;
+        getReachablePromiseRefCount: (p: any) => number;
+        addRecognizableValue: (value: any, recognizer: string | (Map<string, any> | Set<string>), recognizerIsVirtual?: boolean) => void;
+        removeRecognizableVref: (vref: string, recognizer: string | (Map<string, any> | Set<string>), recognizerIsVirtual?: boolean) => void;
+        removeRecognizableValue: (value: any, recognizer: string | (Map<string, any> | Set<string>), recognizerIsVirtual?: boolean) => void;
+        vrefKey: (value: any) => string | undefined;
+        isPresenceReachable: (vref: string) => boolean;
+        isVrefRecognizable: (vref: any) => boolean;
+        setExportStatus: (vref: any, exportStatus: any) => void;
+        isVirtualObjectReachable: (baseRef: string) => boolean;
+        deleteVirtualObject: (baseRef: string) => [boolean, string[]];
+        ceaseRecognition: (vref: string) => boolean;
+        setDeleteCollectionEntry: (fn: any) => void;
+        getRetentionStats: () => {
+            remotableRefCounts: number;
+            vrefRecognizers: number;
+            kindInfoTable: number;
+        };
+        initializeIDCounters: () => void;
+        allocateNextID: (name: any) => number;
+        flushIDCounters: () => void;
+        testHooks: {
+            getReachableRefCount: (vref: any) => number | undefined;
+            countCollectionsForWeakKey: (vref: any) => number;
+            getDroppedCollectionRegistry: () => any;
+            remotableRefCounts: Map<any, number>;
+            vrefRecognizers: Map<string, Set<Map<string, any> | Set<string>>>;
+            kindInfoTable: Map<any, any>;
+        };
+    };
+    vom: {
+        getValForSlot: any;
+        setValForSlot: any;
+        registerEntry: any;
+        deleteEntry: any;
+        flushStateCache: () => void;
+        dumpStore: any;
+        initializeKindHandleKind: () => void;
+        defineKind: <P extends Array<any>, S, F>(tag: string, init: (...args: P) => S, facet: F, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").KindContext<S, F>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacet<F>;
+        defineKindMulti: <P extends Array<any>, S, B>(tag: string, init: (...args: P) => S, behavior: B, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").MultiKindContext<S, B>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacets<B>;
+        defineDurableKind: <P extends Array<any>, S, F>(kindHandle: import("../src/vatDataTypes.js").DurableKindHandle, init: (...args: P) => S, facet: F, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").KindContext<S, F>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacet<F>;
+        defineDurableKindMulti: <P extends Array<any>, S, B>(kindHandle: import("../src/vatDataTypes.js").DurableKindHandle, init: (...args: P) => S, behavior: B, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").MultiKindContext<S, B>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacets<B>;
+        makeKindHandle: (tag: string) => import("../src/vatDataTypes.js").DurableKindHandle;
+        canBeDurable: (specimen: any) => boolean;
+        insistAllDurableKindsReconnected: () => void;
+        VirtualObjectAwareWeakMap: {
+            new (): {
+                has(key: any): any;
+                get(key: any): any;
+                set(key: any, value: any): /*elided*/ any;
+                delete(key: any): any;
+            };
+        };
+        VirtualObjectAwareWeakSet: {
+            new (): {
+                has(value: any): any;
+                add(value: any): /*elided*/ any;
+                delete(value: any): any;
+            };
+        };
+    };
+    cm: {
+        getValForSlot: any;
+        setValForSlot: any;
+        registerEntry: any;
+        deleteEntry: any;
+        dumpStore: any;
+        makeScalarBigMapStore: <K, V>(label?: string, options?: StoreOptions) => MapStore<K, V>;
+        makeScalarBigWeakMapStore: <K, V>(label?: string, options?: StoreOptions) => WeakMapStore<K, V>;
+        makeScalarBigSetStore: <K>(label?: string, options?: StoreOptions) => SetStore<K>;
+        makeScalarBigWeakSetStore: <K>(label?: string, options?: StoreOptions) => WeakSetStore<K>;
+        provideBaggage: () => any;
+        flushSchemaCache: () => void;
+    };
+    wpm: {
+        preparePromiseWatcherTables: () => void;
+        loadWatchedPromiseTable: (revivePromise: (vref: any) => Promise<any>) => void;
+        providePromiseWatcher: <V, A extends any[]>(kindHandle: import("../src/vatDataTypes.js").DurableKindHandle, fulfillHandler?: (value: V, ...args: A) => void, rejectHandler?: (reason: any, ...args: A) => void) => import("../src/types.js").PromiseWatcher<V, A>;
+        watchPromise: <P extends Promise<any>, A extends any[]>(p: P, watcher: import("../src/types.js").PromiseWatcher<Awaited<P>, A>, ...args: A) => void;
+    };
+};
+export function makeStandaloneFakeVirtualObjectManager(options?: {}): {
+    getValForSlot: any;
+    setValForSlot: any;
+    registerEntry: any;
+    deleteEntry: any;
+    flushStateCache: () => void;
+    dumpStore: any;
+    initializeKindHandleKind: () => void;
+    defineKind: <P extends Array<any>, S, F>(tag: string, init: (...args: P) => S, facet: F, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").KindContext<S, F>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacet<F>;
+    defineKindMulti: <P extends Array<any>, S, B>(tag: string, init: (...args: P) => S, behavior: B, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").MultiKindContext<S, B>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacets<B>;
+    defineDurableKind: <P extends Array<any>, S, F>(kindHandle: import("../src/vatDataTypes.js").DurableKindHandle, init: (...args: P) => S, facet: F, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").KindContext<S, F>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacet<F>;
+    defineDurableKindMulti: <P extends Array<any>, S, B>(kindHandle: import("../src/vatDataTypes.js").DurableKindHandle, init: (...args: P) => S, behavior: B, options?: import("../src/vatDataTypes.js").DefineKindOptions<import("../src/vatDataTypes.js").MultiKindContext<S, B>>) => (...args: P) => import("../src/vatDataTypes.js").KindFacets<B>;
+    makeKindHandle: (tag: string) => import("../src/vatDataTypes.js").DurableKindHandle;
+    canBeDurable: (specimen: any) => boolean;
+    insistAllDurableKindsReconnected: () => void;
+    VirtualObjectAwareWeakMap: {
+        new (): {
+            has(key: any): any;
+            get(key: any): any;
+            set(key: any, value: any): /*elided*/ any;
+            delete(key: any): any;
+        };
+    };
+    VirtualObjectAwareWeakSet: {
+        new (): {
+            has(value: any): any;
+            add(value: any): /*elided*/ any;
+            delete(value: any): any;
+        };
+    };
+};
+export function makeStandaloneFakeCollectionManager(options?: {}): {
+    getValForSlot: any;
+    setValForSlot: any;
+    registerEntry: any;
+    deleteEntry: any;
+    dumpStore: any;
+    makeScalarBigMapStore: <K, V>(label?: string, options?: StoreOptions) => MapStore<K, V>;
+    makeScalarBigWeakMapStore: <K, V>(label?: string, options?: StoreOptions) => WeakMapStore<K, V>;
+    makeScalarBigSetStore: <K>(label?: string, options?: StoreOptions) => SetStore<K>;
+    makeScalarBigWeakSetStore: <K>(label?: string, options?: StoreOptions) => WeakSetStore<K>;
+    provideBaggage: () => any;
+    flushSchemaCache: () => void;
+};
+export { makeStandaloneFakeVirtualObjectManager as makeFakeVirtualObjectManager, makeStandaloneFakeCollectionManager as makeFakeCollectionManager };
+//# sourceMappingURL=fakeVirtualSupport.d.ts.map

package/tools/fakeVirtualSupport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeVirtualSupport.d.ts","sourceRoot":"","sources":["fakeVirtualSupport.js"],"names":[],"mappings":"AAyCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuQC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcC;AAED;;;4IA5HwB,GAAI,gDAE1B,GAAC;;EAyIF;AAED;;;;;;;;;;GAUG;AACH,+CAPG;IAAyB,SAAS;IACR,oBAAoB;IACR,SAAS;IACV,OAAO;IACP,OAAO;IAClB,IAAI;CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAjFH,GAC9B,+IAKuB,GAAG;0EAQd,GAAG,uJAKV,GAAG;+HAeL,GAAG,+IAKiB,GAAG;oIAOA,GAC1B,uJAGG,GAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gJAvHkB,GAAI,gDAE1B,GAAC;;;EAqKF;AAED;;;;;;;;iEApG+B,GAC9B,+IAKuB,GAAG;sEAQd,GAAG,uJAKV,GAAG;2HAeL,GAAG,+IAKiB,GAAG;gIAOA,GAC1B,uJAGG,GAAE;;;;;;;;;;;;;;;;;;;EA0DL;AAED;;;;;;;;;;;;EAMC"}

package/tools/fakeVirtualSupport.js

@@ -0,0 +1,389 @@
+/* global globalThis */
+/* eslint-disable max-classes-per-file */
+import { assert, Fail } from '@endo/errors';
+import { makeMarshal } from '@endo/marshal';
+import { isPromise } from '@endo/promise-kit';
+
+import { parseVatSlot } from '../src/parseVatSlots.js';
+import { makeVirtualReferenceManager } from '../src/virtualReferences.js';
+import { makeWatchedPromiseManager } from '../src/watchedPromises.js';
+import { makeFakeVirtualObjectManager } from './fakeVirtualObjectManager.js';
+import { makeFakeCollectionManager } from './fakeCollectionManager.js';
+
+const {
+  WeakRef: RealWeakRef,
+  WeakMap: RealWeakMap,
+  WeakSet: RealWeakSet,
+} = globalThis;
+
+class FakeFinalizationRegistry {
+  // eslint-disable-next-line no-useless-constructor, no-empty-function
+  constructor() {}
+
+  // eslint-disable-next-line class-methods-use-this
+  register(_target, _heldValue, _unregisterToken) {}
+
+  // eslint-disable-next-line class-methods-use-this
+  unregister(_unregisterToken) {}
+}
+
+class FakeWeakRef {
+  #target;
+
+  constructor(target) {
+    this.#target = target;
+  }
+
+  deref() {
+    return this.#target; // strong ref
+  }
+}
+
+export function makeFakeLiveSlotsStuff(options = {}) {
+  let vrm;
+  function setVrm(vrmToUse) {
+    assert(!vrm, 'vrm already configured');
+    vrmToUse.initializeIDCounters();
+    vrm = vrmToUse;
+  }
+
+  const {
+    fakeStore = new Map(),
+    weak = false,
+    log,
+    FinalizationRegistry = FakeFinalizationRegistry,
+    WeakRef = FakeWeakRef, // VRM uses this
+    WeakMap = RealWeakMap,
+    WeakSet = RealWeakSet,
+    addToPossiblyDeadSet = () => {},
+    addToPossiblyRetiredSet = () => {},
+  } = options;
+
+  let sortedKeys;
+  let priorKeyReturned;
+  let priorKeyIndex;
+
+  function s(v) {
+    switch (typeof v) {
+      case 'symbol':
+        return v.toString();
+      case 'bigint':
+        return `${v}n`;
+      default:
+        return `${v}`;
+    }
+  }
+
+  function ensureSorted() {
+    if (!sortedKeys) {
+      sortedKeys = [];
+      for (const key of fakeStore.keys()) {
+        sortedKeys.push(key);
+      }
+      sortedKeys.sort((k1, k2) => k1.localeCompare(k2));
+    }
+  }
+
+  function clearGetNextKeyCache() {
+    priorKeyReturned = undefined;
+    priorKeyIndex = -1;
+  }
+  clearGetNextKeyCache();
+
+  function clearSorted() {
+    sortedKeys = undefined;
+    clearGetNextKeyCache();
+  }
+
+  function dumpStore() {
+    ensureSorted();
+    const result = [];
+    for (const key of sortedKeys) {
+      result.push([key, fakeStore.get(key)]);
+    }
+    return result;
+  }
+
+  const syscall = {
+    vatstoreGet(key) {
+      const result = fakeStore.get(key);
+      if (log) {
+        log.push(`get ${s(key)} => ${s(result)}`);
+      }
+      return result;
+    },
+    vatstoreGetNextKey(priorKey) {
+      assert.typeof(priorKey, 'string');
+      ensureSorted();
+      // TODO: binary search for priorKey (maybe missing), then get
+      // the one after that. For now we go simple and slow. But cache
+      // a starting point, because the main use case is a full
+      // iteration. OTOH, the main use case also deletes everything,
+      // which will clobber the cache on each deletion, so it might
+      // not help.
+      const start = priorKeyReturned === priorKey ? priorKeyIndex : 0;
+      let result;
+      for (let i = start; i < sortedKeys.length; i += 1) {
+        const key = sortedKeys[i];
+        if (key > priorKey) {
+          priorKeyReturned = key;
+          priorKeyIndex = i;
+          result = key;
+          break;
+        }
+      }
+      if (!result) {
+        // reached end without finding the key, so clear our cache
+        clearGetNextKeyCache();
+      }
+      if (log) {
+        log.push(`getNextKey ${s(priorKey)} => ${s(result)}`);
+      }
+      return result;
+    },
+    vatstoreSet(key, value) {
+      if (log) {
+        log.push(`set ${s(key)} ${s(value)}`);
+      }
+      if (!fakeStore.has(key)) {
+        clearSorted();
+      }
+      fakeStore.set(key, value);
+    },
+    vatstoreDelete(key) {
+      if (log) {
+        log.push(`delete ${s(key)}`);
+      }
+      if (fakeStore.has(key)) {
+        clearSorted();
+      }
+      fakeStore.delete(key);
+    },
+  };
+
+  function allocateExportID() {
+    return vrm.allocateNextID('exportID');
+  }
+
+  function allocatePromiseID() {
+    return vrm.allocateNextID('promiseID');
+  }
+
+  function allocateCollectionID() {
+    return vrm.allocateNextID('collectionID');
+  }
+
+  // note: The real liveslots slotToVal() maps slots (vrefs) to a WeakRef,
+  // and the WeakRef may or may not contain the target value. Use
+  // options={weak:true} to match that behavior, or the default weak:false to
+  // keep strong references.
+  const WeakRefForSlot = weak ? RealWeakRef : FakeWeakRef;
+  const valToSlot = new WeakMap();
+  const slotToVal = new Map();
+
+  function getSlotForVal(val) {
+    return valToSlot.get(val);
+  }
+
+  function getValForSlot(slot) {
+    const d = slotToVal.get(slot);
+    return d && d.deref();
+  }
+
+  function requiredValForSlot(slot) {
+    const val = getValForSlot(slot);
+    assert(val, `${slot} must have a value`);
+    return val;
+  }
+
+  function setValForSlot(slot, val) {
+    slotToVal.set(slot, new WeakRefForSlot(val));
+  }
+
+  function convertValToSlot(val) {
+    if (!valToSlot.has(val)) {
+      const slot = isPromise(val)
+        ? `p+${allocatePromiseID()}`
+        : `o+${allocateExportID()}`;
+      valToSlot.set(val, slot);
+      setValForSlot(slot, val);
+    }
+    return valToSlot.get(val);
+  }
+
+  function convertSlotToVal(slot) {
+    const { type, id, virtual, durable, facet, baseRef } = parseVatSlot(slot);
+    assert.equal(type, 'object');
+    let val = getValForSlot(baseRef);
+    if (val) {
+      if (virtual || durable) {
+        if (facet !== undefined) {
+          return vrm.getFacet(id, val, facet);
+        }
+      }
+      return val;
+    }
+    let result;
+    if (virtual || durable) {
+      if (vrm) {
+        val = vrm.reanimate(slot);
+        if (facet !== undefined) {
+          result = vrm.getFacet(id, val, facet);
+        }
+      } else {
+        assert.fail('fake liveSlots stuff configured without vrm');
+      }
+    }
+    registerEntry(baseRef, val, facet !== undefined);
+    if (!result) {
+      result = val;
+    }
+    return result;
+  }
+
+  const marshal = makeMarshal(convertValToSlot, convertSlotToVal, {
+    serializeBodyFormat: 'smallcaps',
+    marshalName: 'fakeLiveSlots',
+    errorIdNum: 80_000,
+    marshalSaveError: _err => {},
+  });
+
+  function registerEntry(baseRef, val, valIsCohort) {
+    const { facet } = parseVatSlot(baseRef);
+    !facet ||
+      Fail`registerEntry(${baseRef} should not receive individual facets`;
+    setValForSlot(baseRef, val);
+    if (valIsCohort) {
+      const { id } = parseVatSlot(baseRef);
+      for (const [index, name] of vrm.getFacetNames(id).entries()) {
+        valToSlot.set(val[name], `${baseRef}:${index}`);
+      }
+    } else {
+      valToSlot.set(val, baseRef);
+    }
+  }
+
+  function deleteEntry(slot, val) {
+    if (!val) {
+      val = getValForSlot(slot);
+    }
+    slotToVal.delete(slot);
+    valToSlot.delete(val);
+  }
+
+  function assertAcceptableSyscallCapdataSize(_capdatas) {}
+
+  const maybeExportPromise = _vref => false;
+
+  return {
+    syscall,
+    allocateExportID,
+    allocatePromiseID,
+    allocateCollectionID,
+    getSlotForVal,
+    requiredValForSlot,
+    getValForSlot,
+    setValForSlot,
+    registerEntry,
+    valToSlot,
+    slotToVal,
+    convertValToSlot,
+    convertSlotToVal,
+    marshal,
+    deleteEntry,
+    FinalizationRegistry,
+    WeakRef,
+    WeakMap,
+    WeakSet,
+    addToPossiblyDeadSet,
+    addToPossiblyRetiredSet,
+    dumpStore,
+    setVrm,
+    assertAcceptableSyscallCapdataSize,
+    maybeExportPromise,
+  };
+}
+
+export function makeFakeVirtualReferenceManager(
+  fakeStuff,
+  relaxDurabilityRules = true,
+) {
+  return makeVirtualReferenceManager(
+    fakeStuff.syscall,
+    fakeStuff.getSlotForVal,
+    fakeStuff.getValForSlot,
+    fakeStuff.FinalizationRegistry,
+    fakeStuff.WeakRef,
+    fakeStuff.addToPossiblyDeadSet,
+    fakeStuff.addToPossiblyRetiredSet,
+    relaxDurabilityRules,
+  );
+}
+
+export function makeFakeWatchedPromiseManager(
+  vrm,
+  vom,
+  collectionManager,
+  fakeStuff,
+) {
+  return makeWatchedPromiseManager({
+    syscall: fakeStuff.syscall,
+    vrm,
+    vom,
+    collectionManager,
+    convertValToSlot: fakeStuff.convertValToSlot,
+    convertSlotToVal: fakeStuff.convertSlotToVal,
+    maybeExportPromise: fakeStuff.maybeExportPromise,
+  });
+}
+
+/**
+ * Configure virtual stuff with relaxed durability rules and fake liveslots
+ *
+ * @param {object} [options]
+ * @param {number} [options.cacheSize]
+ * @param {boolean} [options.relaxDurabilityRules]
+ * @param {Map<string, string>} [options.fakeStore]
+ * @param {WeakMapConstructor} [options.WeakMap]
+ * @param {WeakSetConstructor} [options.WeakSet]
+ * @param {boolean} [options.weak]
+ */
+export function makeFakeVirtualStuff(options = {}) {
+  const actualOptions = {
+    relaxDurabilityRules: true,
+    ...options,
+  };
+  const { relaxDurabilityRules } = actualOptions;
+  const fakeStuff = makeFakeLiveSlotsStuff(actualOptions);
+  const vrm = makeFakeVirtualReferenceManager(fakeStuff, relaxDurabilityRules);
+  fakeStuff.setVrm(vrm);
+  const vom = makeFakeVirtualObjectManager(vrm, fakeStuff);
+  vom.initializeKindHandleKind();
+  const cm = makeFakeCollectionManager(vrm, fakeStuff, actualOptions);
+  const wpm = makeFakeWatchedPromiseManager(vrm, vom, cm, fakeStuff);
+  wpm.preparePromiseWatcherTables();
+  return { fakeStuff, vrm, vom, cm, wpm };
+}
+
+export function makeStandaloneFakeVirtualObjectManager(options = {}) {
+  const fakeStuff = makeFakeLiveSlotsStuff(options);
+  const { relaxDurabilityRules = true } = options;
+  const vrm = makeFakeVirtualReferenceManager(fakeStuff, relaxDurabilityRules);
+  fakeStuff.setVrm(vrm);
+  const vom = makeFakeVirtualObjectManager(vrm, fakeStuff);
+  vom.initializeKindHandleKind();
+  return vom;
+}
+
+export function makeStandaloneFakeCollectionManager(options = {}) {
+  const fakeStuff = makeFakeLiveSlotsStuff(options);
+  const { relaxDurabilityRules = true } = options;
+  const vrm = makeFakeVirtualReferenceManager(fakeStuff, relaxDurabilityRules);
+  fakeStuff.setVrm(vrm);
+  return makeFakeCollectionManager(vrm, fakeStuff, options);
+}
+
+export {
+  makeStandaloneFakeVirtualObjectManager as makeFakeVirtualObjectManager,
+  makeStandaloneFakeCollectionManager as makeFakeCollectionManager,
+};