@agoric/swingset-liveslots 0.10.3-u18a.0 → 0.10.3-u19.0

package/test/util.d.ts

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

package/test/util.d.ts.map

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

package/test/vat-util.d.ts

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

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

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

package/test/waitUntilQuiescent.d.ts

@@ -0,0 +1,3 @@
+/** @import {PromiseKit} from '@endo/promise-kit' */
+export function waitUntilQuiescent(): Promise<void>;
+//# sourceMappingURL=waitUntilQuiescent.d.ts.map

package/test/waitUntilQuiescent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitUntilQuiescent.d.ts","sourceRoot":"","sources":["waitUntilQuiescent.js"],"names":[],"mappings":"AAGA,oDAAoD;AAKpD,oDAWC"}

package/tools/fakeCollectionManager.d.ts

@@ -0,0 +1,14 @@
+export function makeFakeCollectionManager(vrm: any, fakeStuff: any, _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;
+};
+//# sourceMappingURL=fakeCollectionManager.d.ts.map

package/tools/fakeCollectionManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fakeCollectionManager.d.ts","sourceRoot":"","sources":["fakeCollectionManager.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;EAyCC"}

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;;;mEA9HE,wBAEa,iDACiB,GAAI,gDAI/B,GAAI,4BACuB,iBACtB;kFAgD6D,iBAC/D;EAmFP;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uEAzHJ,wBAEa,iDACiB,GAAI,gDAI/B,GAAI,4BACuB,iBACtB;sFAgD6D,iBAC/D;;EA+GP;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":"AA4DO,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/vo-test-harness.d.ts

@@ -0,0 +1,2 @@
+export function runVOTest(t: any, prepare: any, makeTestObject: any, testTestObject: any): Promise<void>;
+//# 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":"AAyEA,yGAqEC"}