@voidhash/mimic-effect 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/testing/ColdStorageTestSuite.cjs

@@ -0,0 +1,508 @@
+const require_ColdStorage = require('../ColdStorage.cjs');
+const require_objectSpread2 = require('../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.cjs');
+const require_assertions = require('./assertions.cjs');
+let effect = require("effect");
+
+//#region src/testing/ColdStorageTestSuite.ts
+/**
+* @voidhash/mimic-effect/testing - ColdStorage Test Suite
+*
+* Comprehensive test suite for ColdStorage adapter implementations.
+* These tests verify that an adapter correctly implements the ColdStorage interface
+* and can reliably store/retrieve document snapshots without data loss.
+*/
+const Categories = {
+	BasicOperations: "Basic Operations",
+	DataIntegrity: "Data Integrity",
+	VersionHandling: "Version Handling",
+	TimestampHandling: "Timestamp Handling",
+	DocumentIdEdgeCases: "Document ID Edge Cases",
+	DocumentIsolation: "Document Isolation",
+	ConsistencyGuarantees: "Consistency Guarantees"
+};
+const makeDoc = (overrides = {}) => require_objectSpread2._objectSpread2({
+	state: { title: "Test Document" },
+	version: 1,
+	schemaVersion: 1,
+	savedAt: Date.now()
+}, overrides);
+const generateLargeState = (sizeKB) => {
+	const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+	const targetBytes = sizeKB * 1024;
+	let content = "";
+	while (content.length < targetBytes) content += chars[Math.floor(Math.random() * 62)];
+	return {
+		content,
+		padding: Array(100).fill("x")
+	};
+};
+const tests = [
+	{
+		name: "load returns undefined for non-existent document",
+		category: Categories.BasicOperations,
+		run: effect.Effect.gen(function* () {
+			yield* require_assertions.assertUndefined(yield* (yield* require_ColdStorage.ColdStorageTag).load("non-existent-doc-id-12345"), "Expected undefined for non-existent document");
+		})
+	},
+	{
+		name: "save then load returns exact same document",
+		category: Categories.BasicOperations,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc();
+			yield* storage.save("test-doc-1", doc);
+			yield* require_assertions.assertEqual(yield* storage.load("test-doc-1"), doc, "Loaded document should match saved document");
+		})
+	},
+	{
+		name: "save overwrites existing document",
+		category: Categories.BasicOperations,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc1 = makeDoc({
+				state: { title: "First" },
+				version: 1
+			});
+			const doc2 = makeDoc({
+				state: { title: "Second" },
+				version: 2
+			});
+			yield* storage.save("test-doc-2", doc1);
+			yield* storage.save("test-doc-2", doc2);
+			yield* require_assertions.assertEqual(yield* storage.load("test-doc-2"), doc2, "Should return the second (overwritten) document");
+		})
+	},
+	{
+		name: "delete removes document",
+		category: Categories.BasicOperations,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc();
+			yield* storage.save("test-doc-3", doc);
+			yield* storage.delete("test-doc-3");
+			yield* require_assertions.assertUndefined(yield* storage.load("test-doc-3"), "Document should be undefined after deletion");
+		})
+	},
+	{
+		name: "delete on non-existent document does not error",
+		category: Categories.BasicOperations,
+		run: effect.Effect.gen(function* () {
+			yield* (yield* require_ColdStorage.ColdStorageTag).delete("definitely-non-existent-doc-xyz");
+		})
+	},
+	{
+		name: "all StoredDocument fields are preserved",
+		category: Categories.DataIntegrity,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = {
+				state: { nested: { value: 42 } },
+				version: 123,
+				schemaVersion: 2,
+				savedAt: 17040672e5
+			};
+			yield* storage.save("fields-test", doc);
+			const definedLoaded = yield* require_assertions.assertDefined(yield* storage.load("fields-test"), "Document should exist");
+			yield* require_assertions.assertEqual(definedLoaded.state, doc.state, "state should be preserved");
+			yield* require_assertions.assertEqual(definedLoaded.version, doc.version, "version should be preserved");
+			yield* require_assertions.assertEqual(definedLoaded.schemaVersion, doc.schemaVersion, "schemaVersion should be preserved");
+			yield* require_assertions.assertEqual(definedLoaded.savedAt, doc.savedAt, "savedAt should be preserved");
+		})
+	},
+	{
+		name: "complex nested state objects survive roundtrip",
+		category: Categories.DataIntegrity,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ state: {
+				level1: {
+					level2: { level3: {
+						value: "deep",
+						array: [
+							1,
+							2,
+							{ nested: true }
+						]
+					} },
+					sibling: "value"
+				},
+				topLevel: 42
+			} });
+			yield* storage.save("complex-state", doc);
+			yield* require_assertions.assertEqual(yield* storage.load("complex-state"), doc, "Complex nested state should survive roundtrip");
+		})
+	},
+	{
+		name: "arrays in state survive roundtrip",
+		category: Categories.DataIntegrity,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ state: {
+				numbers: [
+					1,
+					2,
+					3,
+					4,
+					5
+				],
+				strings: [
+					"a",
+					"b",
+					"c"
+				],
+				mixed: [
+					1,
+					"two",
+					{ three: 3 },
+					[4]
+				],
+				empty: []
+			} });
+			yield* storage.save("arrays-test", doc);
+			yield* require_assertions.assertEqual(yield* storage.load("arrays-test"), doc, "Arrays should survive roundtrip");
+		})
+	},
+	{
+		name: "null values in state survive roundtrip",
+		category: Categories.DataIntegrity,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ state: {
+				nullValue: null,
+				nested: { alsoNull: null },
+				array: [
+					null,
+					1,
+					null
+				]
+			} });
+			yield* storage.save("null-test", doc);
+			yield* require_assertions.assertEqual(yield* storage.load("null-test"), doc, "null values should survive roundtrip");
+		})
+	},
+	{
+		name: "empty object survives roundtrip",
+		category: Categories.DataIntegrity,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ state: {} });
+			yield* storage.save("empty-obj", doc);
+			yield* require_assertions.assertEqual(yield* storage.load("empty-obj"), doc, "Empty object should survive roundtrip");
+		})
+	},
+	{
+		name: "empty array survives roundtrip",
+		category: Categories.DataIntegrity,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ state: [] });
+			yield* storage.save("empty-arr", doc);
+			yield* require_assertions.assertEqual(yield* storage.load("empty-arr"), doc, "Empty array should survive roundtrip");
+		})
+	},
+	{
+		name: "unicode strings in state survive roundtrip",
+		category: Categories.DataIntegrity,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ state: {
+				emoji: "Hello! How are you?",
+				chinese: "Chinese Characters",
+				arabic: "Arabic Letters",
+				special: "Combined: Cafe"
+			} });
+			yield* storage.save("unicode-test", doc);
+			yield* require_assertions.assertEqual(yield* storage.load("unicode-test"), doc, "Unicode strings should survive roundtrip");
+		})
+	},
+	{
+		name: "large state objects (100KB+) survive roundtrip",
+		category: Categories.DataIntegrity,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ state: generateLargeState(100) });
+			yield* storage.save("large-doc", doc);
+			yield* require_assertions.assertEqual(yield* storage.load("large-doc"), doc, "Large documents should survive roundtrip");
+		})
+	},
+	{
+		name: "special JSON characters survive roundtrip",
+		category: Categories.DataIntegrity,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ state: {
+				quotes: "He said \"hello\"",
+				backslash: "path\\to\\file",
+				newline: "line1\nline2",
+				tab: "col1	col2",
+				mixed: "All: \"\\\n	"
+			} });
+			yield* storage.save("special-chars", doc);
+			yield* require_assertions.assertEqual(yield* storage.load("special-chars"), doc, "Special JSON characters should survive roundtrip");
+		})
+	},
+	{
+		name: "version 0 is preserved correctly",
+		category: Categories.VersionHandling,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ version: 0 });
+			yield* storage.save("version-0", doc);
+			yield* require_assertions.assertEqual((yield* require_assertions.assertDefined(yield* storage.load("version-0"), "Document should exist")).version, 0, "Version 0 should be preserved");
+		})
+	},
+	{
+		name: "version 1 is preserved correctly",
+		category: Categories.VersionHandling,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ version: 1 });
+			yield* storage.save("version-1", doc);
+			yield* require_assertions.assertEqual((yield* require_assertions.assertDefined(yield* storage.load("version-1"), "Document should exist")).version, 1, "Version 1 should be preserved");
+		})
+	},
+	{
+		name: "large version numbers are preserved",
+		category: Categories.VersionHandling,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const largeVersion = Number.MAX_SAFE_INTEGER;
+			const doc = makeDoc({ version: largeVersion });
+			yield* storage.save("large-version", doc);
+			yield* require_assertions.assertEqual((yield* require_assertions.assertDefined(yield* storage.load("large-version"), "Document should exist")).version, largeVersion, "Large version number should be preserved exactly");
+		})
+	},
+	{
+		name: "schema version is preserved correctly",
+		category: Categories.VersionHandling,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ schemaVersion: 42 });
+			yield* storage.save("schema-version", doc);
+			yield* require_assertions.assertEqual((yield* require_assertions.assertDefined(yield* storage.load("schema-version"), "Document should exist")).schemaVersion, 42, "Schema version should be preserved");
+		})
+	},
+	{
+		name: "savedAt timestamp is preserved exactly",
+		category: Categories.TimestampHandling,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const timestamp = 17040672e5;
+			const doc = makeDoc({ savedAt: timestamp });
+			yield* storage.save("timestamp-exact", doc);
+			yield* require_assertions.assertEqual((yield* require_assertions.assertDefined(yield* storage.load("timestamp-exact"), "Document should exist")).savedAt, timestamp, "savedAt should be preserved exactly");
+		})
+	},
+	{
+		name: "timestamp 0 is preserved correctly",
+		category: Categories.TimestampHandling,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc = makeDoc({ savedAt: 0 });
+			yield* storage.save("timestamp-0", doc);
+			yield* require_assertions.assertEqual((yield* require_assertions.assertDefined(yield* storage.load("timestamp-0"), "Document should exist")).savedAt, 0, "Timestamp 0 should be preserved");
+		})
+	},
+	{
+		name: "recent timestamps are preserved correctly",
+		category: Categories.TimestampHandling,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const now = Date.now();
+			const doc = makeDoc({ savedAt: now });
+			yield* storage.save("timestamp-recent", doc);
+			yield* require_assertions.assertEqual((yield* require_assertions.assertDefined(yield* storage.load("timestamp-recent"), "Document should exist")).savedAt, now, "Recent timestamp should be preserved");
+		})
+	},
+	{
+		name: "long documentId (1000+ chars) works",
+		category: Categories.DocumentIdEdgeCases,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const longId = "x".repeat(1e3);
+			const doc = makeDoc();
+			yield* storage.save(longId, doc);
+			yield* require_assertions.assertEqual(yield* storage.load(longId), doc, "Long documentId should work correctly");
+		})
+	},
+	{
+		name: "unicode documentId works",
+		category: Categories.DocumentIdEdgeCases,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const unicodeId = "doc-test-id";
+			const doc = makeDoc();
+			yield* storage.save(unicodeId, doc);
+			yield* require_assertions.assertEqual(yield* storage.load(unicodeId), doc, "Unicode documentId should work correctly");
+		})
+	},
+	{
+		name: "documentId with special chars works",
+		category: Categories.DocumentIdEdgeCases,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const specialId = "doc/path:to.file";
+			const doc = makeDoc();
+			yield* storage.save(specialId, doc);
+			yield* require_assertions.assertEqual(yield* storage.load(specialId), doc, "DocumentId with special chars should work");
+		})
+	},
+	{
+		name: "documentId with spaces works",
+		category: Categories.DocumentIdEdgeCases,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const spacedId = "doc with spaces";
+			const doc = makeDoc();
+			yield* storage.save(spacedId, doc);
+			yield* require_assertions.assertEqual(yield* storage.load(spacedId), doc, "DocumentId with spaces should work");
+		})
+	},
+	{
+		name: "different documents are stored independently",
+		category: Categories.DocumentIsolation,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc1 = makeDoc({
+				state: { id: 1 },
+				version: 1
+			});
+			const doc2 = makeDoc({
+				state: { id: 2 },
+				version: 2
+			});
+			yield* storage.save("iso-doc-1", doc1);
+			yield* storage.save("iso-doc-2", doc2);
+			const loaded1 = yield* storage.load("iso-doc-1");
+			const loaded2 = yield* storage.load("iso-doc-2");
+			yield* require_assertions.assertEqual(loaded1, doc1, "First document should be unchanged");
+			yield* require_assertions.assertEqual(loaded2, doc2, "Second document should be unchanged");
+		})
+	},
+	{
+		name: "deleting one document does not affect others",
+		category: Categories.DocumentIsolation,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc1 = makeDoc({ state: { id: 1 } });
+			const doc2 = makeDoc({ state: { id: 2 } });
+			yield* storage.save("del-iso-1", doc1);
+			yield* storage.save("del-iso-2", doc2);
+			yield* storage.delete("del-iso-1");
+			const loaded1 = yield* storage.load("del-iso-1");
+			const loaded2 = yield* storage.load("del-iso-2");
+			yield* require_assertions.assertUndefined(loaded1, "Deleted document should be undefined");
+			yield* require_assertions.assertEqual(loaded2, doc2, "Other document should be unchanged");
+		})
+	},
+	{
+		name: "updating one document does not affect others",
+		category: Categories.DocumentIsolation,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc1v1 = makeDoc({
+				state: {
+					id: 1,
+					v: 1
+				},
+				version: 1
+			});
+			const doc1v2 = makeDoc({
+				state: {
+					id: 1,
+					v: 2
+				},
+				version: 2
+			});
+			const doc2 = makeDoc({ state: { id: 2 } });
+			yield* storage.save("upd-iso-1", doc1v1);
+			yield* storage.save("upd-iso-2", doc2);
+			yield* storage.save("upd-iso-1", doc1v2);
+			const loaded1 = yield* storage.load("upd-iso-1");
+			const loaded2 = yield* storage.load("upd-iso-2");
+			yield* require_assertions.assertEqual(loaded1, doc1v2, "Updated document should have new value");
+			yield* require_assertions.assertEqual(loaded2, doc2, "Other document should be unchanged");
+		})
+	},
+	{
+		name: "multiple saves to same doc, load returns latest",
+		category: Categories.ConsistencyGuarantees,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc1 = makeDoc({
+				state: { v: 1 },
+				version: 1
+			});
+			const doc2 = makeDoc({
+				state: { v: 2 },
+				version: 2
+			});
+			const doc3 = makeDoc({
+				state: { v: 3 },
+				version: 3
+			});
+			yield* storage.save("multi-save", doc1);
+			yield* storage.save("multi-save", doc2);
+			yield* storage.save("multi-save", doc3);
+			yield* require_assertions.assertEqual(yield* storage.load("multi-save"), doc3, "Should return the latest saved document");
+		})
+	},
+	{
+		name: "save-delete-save sequence works correctly",
+		category: Categories.ConsistencyGuarantees,
+		run: effect.Effect.gen(function* () {
+			const storage = yield* require_ColdStorage.ColdStorageTag;
+			const doc1 = makeDoc({
+				state: { phase: "first" },
+				version: 1
+			});
+			const doc2 = makeDoc({
+				state: { phase: "second" },
+				version: 2
+			});
+			yield* storage.save("sds-test", doc1);
+			yield* storage.delete("sds-test");
+			yield* storage.save("sds-test", doc2);
+			yield* require_assertions.assertEqual(yield* storage.load("sds-test"), doc2, "Should return document saved after delete");
+		})
+	}
+];
+/**
+* Get all ColdStorage test cases.
+*
+* @returns Array of test cases that require ColdStorageTag
+*/
+const makeTests = () => tests;
+/**
+* Run all tests and collect results.
+*
+* @returns Effect that produces TestResults
+*/
+const runAll = () => effect.Effect.gen(function* () {
+	const passed = [];
+	const failed = [];
+	for (const test of tests) {
+		const result = yield* effect.Effect.either(test.run);
+		if (result._tag === "Right") passed.push(test);
+		else failed.push({
+			test,
+			error: result.left
+		});
+	}
+	return {
+		passed,
+		failed,
+		total: tests.length,
+		passCount: passed.length,
+		failCount: failed.length
+	};
+});
+const ColdStorageTestSuite = {
+	Categories,
+	makeTests,
+	runAll
+};
+
+//#endregion
+exports.Categories = Categories;
+exports.ColdStorageTestSuite = ColdStorageTestSuite;

package/dist/testing/ColdStorageTestSuite.d.cts

@@ -0,0 +1,36 @@
+import { ColdStorageError } from "../Errors.cjs";
+import { ColdStorageTag } from "../ColdStorage.cjs";
+import { StorageTestCase, TestError, TestResults } from "./types.cjs";
+import { Effect } from "effect";
+
+//#region src/testing/ColdStorageTestSuite.d.ts
+
+/**
+ * Error type for ColdStorage tests - can be either a TestError or a ColdStorageError
+ */
+type ColdStorageTestError = TestError | ColdStorageError;
+declare const Categories: {
+  readonly BasicOperations: "Basic Operations";
+  readonly DataIntegrity: "Data Integrity";
+  readonly VersionHandling: "Version Handling";
+  readonly TimestampHandling: "Timestamp Handling";
+  readonly DocumentIdEdgeCases: "Document ID Edge Cases";
+  readonly DocumentIsolation: "Document Isolation";
+  readonly ConsistencyGuarantees: "Consistency Guarantees";
+};
+declare const ColdStorageTestSuite: {
+  Categories: {
+    readonly BasicOperations: "Basic Operations";
+    readonly DataIntegrity: "Data Integrity";
+    readonly VersionHandling: "Version Handling";
+    readonly TimestampHandling: "Timestamp Handling";
+    readonly DocumentIdEdgeCases: "Document ID Edge Cases";
+    readonly DocumentIsolation: "Document Isolation";
+    readonly ConsistencyGuarantees: "Consistency Guarantees";
+  };
+  makeTests: () => StorageTestCase<ColdStorageTestError, ColdStorageTag>[];
+  runAll: () => Effect.Effect<TestResults<ColdStorageTestError, ColdStorageTag>, never, ColdStorageTag>;
+};
+//#endregion
+export { Categories, ColdStorageTestError, ColdStorageTestSuite };
+//# sourceMappingURL=ColdStorageTestSuite.d.cts.map

package/dist/testing/ColdStorageTestSuite.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColdStorageTestSuite.d.cts","names":[],"sources":["../../src/testing/ColdStorageTestSuite.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AA6iBE,KAvhBU,oBAAA,GAAuB,SAuhBjC,GAvhB6C,gBAuhB7C;AAHwB,cA9gBb,UA8gBoB,EAAA;EAAM,SAAA,eAAA,EAAA,kBAAA;;;;;;;;cA8B1B;;;;;;;;;;mBAxCgB,gBAC3B,sBACA;gBAQwB,MAAA,CAAO,OAC/B,YAAY,sBAAsB,wBAElC"}

package/dist/testing/ColdStorageTestSuite.d.mts

@@ -0,0 +1,36 @@
+import { ColdStorageError } from "../Errors.mjs";
+import { ColdStorageTag } from "../ColdStorage.mjs";
+import { StorageTestCase, TestError, TestResults } from "./types.mjs";
+import { Effect } from "effect";
+
+//#region src/testing/ColdStorageTestSuite.d.ts
+
+/**
+ * Error type for ColdStorage tests - can be either a TestError or a ColdStorageError
+ */
+type ColdStorageTestError = TestError | ColdStorageError;
+declare const Categories: {
+  readonly BasicOperations: "Basic Operations";
+  readonly DataIntegrity: "Data Integrity";
+  readonly VersionHandling: "Version Handling";
+  readonly TimestampHandling: "Timestamp Handling";
+  readonly DocumentIdEdgeCases: "Document ID Edge Cases";
+  readonly DocumentIsolation: "Document Isolation";
+  readonly ConsistencyGuarantees: "Consistency Guarantees";
+};
+declare const ColdStorageTestSuite: {
+  Categories: {
+    readonly BasicOperations: "Basic Operations";
+    readonly DataIntegrity: "Data Integrity";
+    readonly VersionHandling: "Version Handling";
+    readonly TimestampHandling: "Timestamp Handling";
+    readonly DocumentIdEdgeCases: "Document ID Edge Cases";
+    readonly DocumentIsolation: "Document Isolation";
+    readonly ConsistencyGuarantees: "Consistency Guarantees";
+  };
+  makeTests: () => StorageTestCase<ColdStorageTestError, ColdStorageTag>[];
+  runAll: () => Effect.Effect<TestResults<ColdStorageTestError, ColdStorageTag>, never, ColdStorageTag>;
+};
+//#endregion
+export { Categories, ColdStorageTestError, ColdStorageTestSuite };
+//# sourceMappingURL=ColdStorageTestSuite.d.mts.map

package/dist/testing/ColdStorageTestSuite.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ColdStorageTestSuite.d.mts","names":[],"sources":["../../src/testing/ColdStorageTestSuite.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;AA6iBE,KAvhBU,oBAAA,GAAuB,SAuhBjC,GAvhB6C,gBAuhB7C;AAHwB,cA9gBb,UA8gBoB,EAAA;EAAM,SAAA,eAAA,EAAA,kBAAA;;;;;;;;cA8B1B;;;;;;;;;;mBAxCgB,gBAC3B,sBACA;gBAQwB,MAAA,CAAO,OAC/B,YAAY,sBAAsB,wBAElC"}