@agoric/swingset-liveslots 0.10.3-upgrade-19-dev-0754752.0 → 0.10.3-upgrade-18a-dev-4ee0508.0

package/tools/fakeCollectionManager.d.ts.map

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

package/tools/fakeVirtualObjectManager.d.ts

@@ -1,32 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,278 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,37 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

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

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

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

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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,2 +0,0 @@
-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

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