@agoric/swingset-liveslots 0.10.3-other-dev-3eb1a1d.0 → 0.10.3-other-dev-fbe72e7.0.fbe72e7

package/tools/fakeVirtualObjectManager.d.ts

@@ -0,0 +1,32 @@
+export function makeFakeVirtualObjectManager(vrm: any, fakeStuff: any): {
+    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;
+        };
+    };
+};
+//# sourceMappingURL=fakeVirtualObjectManager.d.ts.map

package/tools/fakeVirtualObjectManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeVirtualObjectManager.d.ts","sourceRoot":"","sources":["fakeVirtualObjectManager.js"],"names":[],"mappings":"AAaA;;;;;;;;iEAiDywJ,GAAG,+IAAyF,GAAG;sEAAkK,GAAG,uJAAiG,GAAG;2HAAyQ,GAAG,+IAAyF,GAAG;gIAA2L,GAAG,uJAAiG,GAAG;;;;;;;;;;;;;;;;;;;EAD1vL"}

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/prepare-strict-test-env.d.ts

@@ -0,0 +1,37 @@
+export function annihilate(options?: Omit<ReincarnateOptions, "fakeVomKit" | "fakeStore">): {
+    relaxDurabilityRules?: boolean | undefined;
+    fakeStore: Map<string, string>;
+    weak?: boolean | undefined;
+    cacheSize?: number | undefined;
+    fakeVomKit: import("./setup-vat-data.js").FakeVomKit;
+};
+export function getBaggage(): Baggage;
+export function nextLife(fromIncarnation?: ReincarnateOptions): {
+    relaxDurabilityRules?: boolean | undefined;
+    fakeStore: Map<string, string>;
+    weak?: boolean | undefined;
+    cacheSize?: number | undefined;
+    fakeVomKit: import("./setup-vat-data.js").FakeVomKit;
+};
+export function startLife<B extends (baggage: Baggage) => Promise<any> | any>(build: B, run?: (tools: Awaited<ReturnType<B>>) => Promise<void> | void, { fromIncarnation, cleanStart }?: {
+    fromIncarnation?: {
+        relaxDurabilityRules?: boolean | undefined;
+        fakeStore: Map<string, string>;
+        weak?: boolean | undefined;
+        cacheSize?: number | undefined;
+        fakeVomKit: import("./setup-vat-data.js").FakeVomKit;
+    } | undefined;
+    cleanStart?: boolean | undefined;
+}): Promise<{
+    relaxDurabilityRules?: boolean | undefined;
+    fakeStore: Map<string, string>;
+    weak?: boolean | undefined;
+    cacheSize?: number | undefined;
+    fakeVomKit: import("./setup-vat-data.js").FakeVomKit;
+}>;
+import { flushIncarnation } from './setup-vat-data.js';
+import { eventLoopIteration } from '@agoric/internal/src/testing-utils.js';
+import type { ReincarnateOptions } from './setup-vat-data.js';
+import type { Baggage } from '@agoric/swingset-liveslots';
+export { flushIncarnation, eventLoopIteration as nextCrank };
+//# sourceMappingURL=prepare-strict-test-env.d.ts.map

package/tools/prepare-strict-test-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-strict-test-env.d.ts","sourceRoot":"","sources":["prepare-strict-test-env.js"],"names":[],"mappings":"AAiCO,qCADK,IAAI,CAAC,kBAAkB,EAAE,YAAY,GAAG,WAAW,CAAC;;;;;;EAO/D;AAGM,8BADO,OAAO,CAGpB;AAKM,2CAFI,kBAAkB;;;;;;EAM5B;AAUM,0BAPiD,CAAC,SAA5C,CAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,GAAI,SAC5C,CAAC,QACD,CAAC,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,oCAE/D;IAAqC,eAAe;;;;;;;IAC1B,UAAU;CAAC;;;;;;GA2DvC;iCA5G6C,qBAAqB;mCAIhC,uCAAuC;wCASnC,qBAAqB;6BADhC,4BAA4B"}

package/tools/prepare-test-env.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=prepare-test-env.d.ts.map

package/tools/prepare-test-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-test-env.d.ts","sourceRoot":"","sources":["prepare-test-env.js"],"names":[],"mappings":""}

package/tools/setup-vat-data.d.ts

@@ -0,0 +1,9 @@
+export function flushIncarnation(options?: Partial<ReincarnateOptions>): Omit<ReincarnateOptions, "fakeVomKit">;
+export function reincarnate(options?: Partial<ReincarnateOptions>): ReincarnateOptions;
+export type FakeVomKit = ReturnType<typeof makeFakeVirtualStuff>;
+export type ReincarnateOptions = import("@agoric/internal").Simplify<Omit<NonNullable<Parameters<typeof makeFakeVirtualStuff>[0]>, "WeakMap" | "WeakSet"> & {
+    fakeVomKit: FakeVomKit;
+    fakeStore: Map<string, string>;
+}>;
+import { makeFakeVirtualStuff } from './fakeVirtualSupport.js';
+//# sourceMappingURL=setup-vat-data.d.ts.map

package/tools/setup-vat-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-vat-data.d.ts","sourceRoot":"","sources":["setup-vat-data.js"],"names":[],"mappings":"AA2DO,2CAHI,OAAO,CAAC,kBAAkB,CAAC,GACzB,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAelD;AAOM,sCAHI,OAAO,CAAC,kBAAkB,CAAC,GACzB,kBAAkB,CAiB9B;yBAjFa,UAAU,CAAC,OAAO,oBAAoB,CAAC;iCAmCxC,OAAO,kBAAkB,EAAE,QAAQ,CAC3C,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC,GACxF;IAAM,UAAU,EAAE,UAAU,CAAC;IAAC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAC3D;qCA1CiC,yBAAyB"}

package/tools/setup-vat-data.js

@@ -1,4 +1,3 @@
-// @ts-check
 /* global globalThis */
 
 // This file produces the globalThis.VatData property outside of a

package/tools/vo-test-harness.d.ts

@@ -0,0 +1,33 @@
+export function runVOTest(t: any, prepare: any, makeTestObject: any, testTestObject: any): Promise<void>;
+export function makeSpy(t: import("ava").ExecutionContext): {
+    fail: (msg: any) => void;
+    falsy: (check: any, msg: any) => void;
+    failureMessage: string;
+    falsyMessage: string;
+    context: unknown;
+    title: string;
+    passed: boolean;
+    log: import("ava").LogFn;
+    plan: import("ava").PlanFn;
+    teardown: import("ava").TeardownFn;
+    timeout: import("ava").TimeoutFn;
+    try: import("ava").TryFn<unknown>;
+    assert: import("ava").AssertAssertion;
+    deepEqual: import("ava").DeepEqualAssertion;
+    like: import("ava").LikeAssertion;
+    false: import("ava").FalseAssertion;
+    is: import("ava").IsAssertion;
+    not: import("ava").NotAssertion;
+    notDeepEqual: import("ava").NotDeepEqualAssertion;
+    notRegex: import("ava").NotRegexAssertion;
+    notThrows: import("ava").NotThrowsAssertion;
+    notThrowsAsync: import("ava").NotThrowsAsyncAssertion;
+    pass: import("ava").PassAssertion;
+    regex: import("ava").RegexAssertion;
+    snapshot: import("ava").SnapshotAssertion;
+    throws: import("ava").ThrowsAssertion;
+    throwsAsync: import("ava").ThrowsAsyncAssertion;
+    true: import("ava").TrueAssertion;
+    truthy: import("ava").TruthyAssertion;
+};
+//# sourceMappingURL=vo-test-harness.d.ts.map

package/tools/vo-test-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vo-test-harness.d.ts","sourceRoot":"","sources":["vo-test-harness.js"],"names":[],"mappings":"AA8FA,yGAqEC;AAxJM,2BAFI,OAAO,KAAK,EAAE,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBxC"}

package/tools/vo-test-harness.js

@@ -5,6 +5,27 @@ import { setupTestLiveslots } from '../test/liveslots-helpers.js';
 // is to to help verify that a VO can be garbage collected and then
 // reloaded from persistent storage while maintaining functionality.
 
+/**
+ * A spy wrapping Ava's t for tests that are testing the harness itself.
+ * @param {import('ava').ExecutionContext} t
+ */
+export const makeSpy = t => {
+  const tSpy = {
+    ...t,
+    fail: msg => {
+      tSpy.failureMessage = msg;
+    },
+    // In Ava 6, assertions throw?
+    falsy: (check, msg) => {
+      if (!check) return;
+      tSpy.falsyMessage = msg;
+    },
+    failureMessage: '',
+    falsyMessage: '',
+  };
+  return tSpy;
+};
+
 // Testing VO swapping with runVOTest:
 //
 // Step 1: import the necessary harness paraphernalia