@voidhash/mimic-effect 0.0.9 → 1.0.0-beta.2

package/dist/testing/FailingStorage.cjs

@@ -0,0 +1,135 @@
+const require_ColdStorage = require('../ColdStorage.cjs');
+const require_Errors = require('../Errors.cjs');
+const require_HotStorage = require('../HotStorage.cjs');
+let effect = require("effect");
+
+//#region src/testing/FailingStorage.ts
+/**
+* @voidhash/mimic-effect/testing - FailingStorage
+*
+* Mock storage implementations that simulate failures for testing error handling.
+* Use these to verify that your application correctly handles storage unavailability.
+*
+* @example
+* ```typescript
+* import { FailingStorage } from "@voidhash/mimic-effect/testing";
+*
+* // Create a ColdStorage that fails on load
+* const failingCold = FailingStorage.makeColdStorage({ failLoad: true });
+*
+* // Create a HotStorage that fails after 3 successful appends
+* const failingHot = FailingStorage.makeHotStorage({ failAfterN: 3, failAppend: true });
+* ```
+*/
+/**
+* Create a ColdStorage layer that simulates failures.
+* Wraps an in-memory storage and fails according to configuration.
+*/
+const makeColdStorage = (config = {}) => effect.Layer.effect(require_ColdStorage.ColdStorageTag, effect.Effect.gen(function* () {
+	var _config$errorMessage;
+	const store = yield* effect.Ref.make(effect.HashMap.empty());
+	const operationCount = yield* effect.Ref.make(0);
+	const errorMessage = (_config$errorMessage = config.errorMessage) !== null && _config$errorMessage !== void 0 ? _config$errorMessage : "Simulated storage failure";
+	const shouldFail = (operation) => effect.Effect.gen(function* () {
+		const opFails = operation === "load" && config.failLoad || operation === "save" && config.failSave || operation === "delete" && config.failDelete;
+		if (config.failAfterN !== void 0) {
+			const count = yield* effect.Ref.get(operationCount);
+			yield* effect.Ref.update(operationCount, (n) => n + 1);
+			if (count < config.failAfterN) return false;
+			return opFails;
+		}
+		return opFails;
+	});
+	return {
+		load: (documentId) => effect.Effect.gen(function* () {
+			if (yield* shouldFail("load")) return yield* effect.Effect.fail(new require_Errors.ColdStorageError({
+				documentId,
+				operation: "load",
+				cause: new Error(errorMessage)
+			}));
+			const current = yield* effect.Ref.get(store);
+			const doc = effect.HashMap.get(current, documentId);
+			return doc._tag === "Some" ? doc.value : void 0;
+		}),
+		save: (documentId, document) => effect.Effect.gen(function* () {
+			if (yield* shouldFail("save")) return yield* effect.Effect.fail(new require_Errors.ColdStorageError({
+				documentId,
+				operation: "save",
+				cause: new Error(errorMessage)
+			}));
+			yield* effect.Ref.update(store, (map) => effect.HashMap.set(map, documentId, document));
+		}),
+		delete: (documentId) => effect.Effect.gen(function* () {
+			if (yield* shouldFail("delete")) return yield* effect.Effect.fail(new require_Errors.ColdStorageError({
+				documentId,
+				operation: "delete",
+				cause: new Error(errorMessage)
+			}));
+			yield* effect.Ref.update(store, (map) => effect.HashMap.remove(map, documentId));
+		})
+	};
+}));
+/**
+* Create a HotStorage layer that simulates failures.
+* Wraps an in-memory storage and fails according to configuration.
+*/
+const makeHotStorage = (config = {}) => effect.Layer.effect(require_HotStorage.HotStorageTag, effect.Effect.gen(function* () {
+	var _config$errorMessage2;
+	const store = yield* effect.Ref.make(effect.HashMap.empty());
+	const operationCount = yield* effect.Ref.make(0);
+	const errorMessage = (_config$errorMessage2 = config.errorMessage) !== null && _config$errorMessage2 !== void 0 ? _config$errorMessage2 : "Simulated storage failure";
+	const shouldFail = (operation) => effect.Effect.gen(function* () {
+		const opFails = operation === "append" && config.failAppend || operation === "getEntries" && config.failGetEntries || operation === "truncate" && config.failTruncate;
+		if (config.failAfterN !== void 0) {
+			const count = yield* effect.Ref.get(operationCount);
+			yield* effect.Ref.update(operationCount, (n) => n + 1);
+			if (count < config.failAfterN) return false;
+			return opFails;
+		}
+		return opFails;
+	});
+	return {
+		append: (documentId, entry) => effect.Effect.gen(function* () {
+			if (yield* shouldFail("append")) return yield* effect.Effect.fail(new require_Errors.HotStorageError({
+				documentId,
+				operation: "append",
+				cause: new Error(errorMessage)
+			}));
+			yield* effect.Ref.update(store, (map) => {
+				const current = effect.HashMap.get(map, documentId);
+				const entries = current._tag === "Some" ? current.value : [];
+				return effect.HashMap.set(map, documentId, [...entries, entry]);
+			});
+		}),
+		getEntries: (documentId, sinceVersion) => effect.Effect.gen(function* () {
+			if (yield* shouldFail("getEntries")) return yield* effect.Effect.fail(new require_Errors.HotStorageError({
+				documentId,
+				operation: "getEntries",
+				cause: new Error(errorMessage)
+			}));
+			const current = yield* effect.Ref.get(store);
+			const existing = effect.HashMap.get(current, documentId);
+			return (existing._tag === "Some" ? existing.value : []).filter((e) => e.version > sinceVersion).sort((a, b) => a.version - b.version);
+		}),
+		truncate: (documentId, upToVersion) => effect.Effect.gen(function* () {
+			if (yield* shouldFail("truncate")) return yield* effect.Effect.fail(new require_Errors.HotStorageError({
+				documentId,
+				operation: "truncate",
+				cause: new Error(errorMessage)
+			}));
+			yield* effect.Ref.update(store, (map) => {
+				const existing = effect.HashMap.get(map, documentId);
+				if (existing._tag === "None") return map;
+				const filtered = existing.value.filter((e) => e.version > upToVersion);
+				return effect.HashMap.set(map, documentId, filtered);
+			});
+		})
+	};
+}));
+const FailingStorage = {
+	makeColdStorage,
+	makeHotStorage
+};
+
+//#endregion
+exports.FailingStorage = FailingStorage;

package/dist/testing/FailingStorage.d.cts

@@ -0,0 +1,43 @@
+import { ColdStorageTag } from "../ColdStorage.cjs";
+import { HotStorageTag } from "../HotStorage.cjs";
+import { Layer } from "effect";
+
+//#region src/testing/FailingStorage.d.ts
+
+/**
+ * Configuration for failing ColdStorage
+ */
+interface FailingColdStorageConfig {
+  /** Fail load operations */
+  readonly failLoad?: boolean;
+  /** Fail save operations */
+  readonly failSave?: boolean;
+  /** Fail delete operations */
+  readonly failDelete?: boolean;
+  /** Fail after N successful operations (total across all operation types) */
+  readonly failAfterN?: number;
+  /** Custom error message */
+  readonly errorMessage?: string;
+}
+/**
+ * Configuration for failing HotStorage
+ */
+interface FailingHotStorageConfig {
+  /** Fail append operations */
+  readonly failAppend?: boolean;
+  /** Fail getEntries operations */
+  readonly failGetEntries?: boolean;
+  /** Fail truncate operations */
+  readonly failTruncate?: boolean;
+  /** Fail after N successful operations (total across all operation types) */
+  readonly failAfterN?: number;
+  /** Custom error message */
+  readonly errorMessage?: string;
+}
+declare const FailingStorage: {
+  makeColdStorage: (config?: FailingColdStorageConfig) => Layer.Layer<ColdStorageTag>;
+  makeHotStorage: (config?: FailingHotStorageConfig) => Layer.Layer<HotStorageTag>;
+};
+//#endregion
+export { FailingColdStorageConfig, FailingHotStorageConfig, FailingStorage };
+//# sourceMappingURL=FailingStorage.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FailingStorage.d.cts","names":[],"sources":["../../src/testing/FailingStorage.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UA8BiB,wBAAA;;;;;;;;;;;;;;;UAgBA,uBAAA;;;;;;;;;;;;cA4OJ;6BAtNH,6BACP,KAAA,CAAM,MAAM;4BAqGL,4BACP,KAAA,CAAM,MAAM"}

package/dist/testing/FailingStorage.d.mts

@@ -0,0 +1,43 @@
+import { ColdStorageTag } from "../ColdStorage.mjs";
+import { HotStorageTag } from "../HotStorage.mjs";
+import { Layer } from "effect";
+
+//#region src/testing/FailingStorage.d.ts
+
+/**
+ * Configuration for failing ColdStorage
+ */
+interface FailingColdStorageConfig {
+  /** Fail load operations */
+  readonly failLoad?: boolean;
+  /** Fail save operations */
+  readonly failSave?: boolean;
+  /** Fail delete operations */
+  readonly failDelete?: boolean;
+  /** Fail after N successful operations (total across all operation types) */
+  readonly failAfterN?: number;
+  /** Custom error message */
+  readonly errorMessage?: string;
+}
+/**
+ * Configuration for failing HotStorage
+ */
+interface FailingHotStorageConfig {
+  /** Fail append operations */
+  readonly failAppend?: boolean;
+  /** Fail getEntries operations */
+  readonly failGetEntries?: boolean;
+  /** Fail truncate operations */
+  readonly failTruncate?: boolean;
+  /** Fail after N successful operations (total across all operation types) */
+  readonly failAfterN?: number;
+  /** Custom error message */
+  readonly errorMessage?: string;
+}
+declare const FailingStorage: {
+  makeColdStorage: (config?: FailingColdStorageConfig) => Layer.Layer<ColdStorageTag>;
+  makeHotStorage: (config?: FailingHotStorageConfig) => Layer.Layer<HotStorageTag>;
+};
+//#endregion
+export { FailingColdStorageConfig, FailingHotStorageConfig, FailingStorage };
+//# sourceMappingURL=FailingStorage.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FailingStorage.d.mts","names":[],"sources":["../../src/testing/FailingStorage.ts"],"sourcesContent":[],"mappings":";;;;;;;;;UA8BiB,wBAAA;;;;;;;;;;;;;;;UAgBA,uBAAA;;;;;;;;;;;;cA4OJ;6BAtNH,6BACP,KAAA,CAAM,MAAM;4BAqGL,4BACP,KAAA,CAAM,MAAM"}

package/dist/testing/FailingStorage.mjs

@@ -0,0 +1,136 @@
+import { ColdStorageTag } from "../ColdStorage.mjs";
+import { ColdStorageError, HotStorageError } from "../Errors.mjs";
+import { HotStorageTag } from "../HotStorage.mjs";
+import { Effect, HashMap, Layer, Ref } from "effect";
+
+//#region src/testing/FailingStorage.ts
+/**
+* @voidhash/mimic-effect/testing - FailingStorage
+*
+* Mock storage implementations that simulate failures for testing error handling.
+* Use these to verify that your application correctly handles storage unavailability.
+*
+* @example
+* ```typescript
+* import { FailingStorage } from "@voidhash/mimic-effect/testing";
+*
+* // Create a ColdStorage that fails on load
+* const failingCold = FailingStorage.makeColdStorage({ failLoad: true });
+*
+* // Create a HotStorage that fails after 3 successful appends
+* const failingHot = FailingStorage.makeHotStorage({ failAfterN: 3, failAppend: true });
+* ```
+*/
+/**
+* Create a ColdStorage layer that simulates failures.
+* Wraps an in-memory storage and fails according to configuration.
+*/
+const makeColdStorage = (config = {}) => Layer.effect(ColdStorageTag, Effect.gen(function* () {
+	var _config$errorMessage;
+	const store = yield* Ref.make(HashMap.empty());
+	const operationCount = yield* Ref.make(0);
+	const errorMessage = (_config$errorMessage = config.errorMessage) !== null && _config$errorMessage !== void 0 ? _config$errorMessage : "Simulated storage failure";
+	const shouldFail = (operation) => Effect.gen(function* () {
+		const opFails = operation === "load" && config.failLoad || operation === "save" && config.failSave || operation === "delete" && config.failDelete;
+		if (config.failAfterN !== void 0) {
+			const count = yield* Ref.get(operationCount);
+			yield* Ref.update(operationCount, (n) => n + 1);
+			if (count < config.failAfterN) return false;
+			return opFails;
+		}
+		return opFails;
+	});
+	return {
+		load: (documentId) => Effect.gen(function* () {
+			if (yield* shouldFail("load")) return yield* Effect.fail(new ColdStorageError({
+				documentId,
+				operation: "load",
+				cause: new Error(errorMessage)
+			}));
+			const current = yield* Ref.get(store);
+			const doc = HashMap.get(current, documentId);
+			return doc._tag === "Some" ? doc.value : void 0;
+		}),
+		save: (documentId, document) => Effect.gen(function* () {
+			if (yield* shouldFail("save")) return yield* Effect.fail(new ColdStorageError({
+				documentId,
+				operation: "save",
+				cause: new Error(errorMessage)
+			}));
+			yield* Ref.update(store, (map) => HashMap.set(map, documentId, document));
+		}),
+		delete: (documentId) => Effect.gen(function* () {
+			if (yield* shouldFail("delete")) return yield* Effect.fail(new ColdStorageError({
+				documentId,
+				operation: "delete",
+				cause: new Error(errorMessage)
+			}));
+			yield* Ref.update(store, (map) => HashMap.remove(map, documentId));
+		})
+	};
+}));
+/**
+* Create a HotStorage layer that simulates failures.
+* Wraps an in-memory storage and fails according to configuration.
+*/
+const makeHotStorage = (config = {}) => Layer.effect(HotStorageTag, Effect.gen(function* () {
+	var _config$errorMessage2;
+	const store = yield* Ref.make(HashMap.empty());
+	const operationCount = yield* Ref.make(0);
+	const errorMessage = (_config$errorMessage2 = config.errorMessage) !== null && _config$errorMessage2 !== void 0 ? _config$errorMessage2 : "Simulated storage failure";
+	const shouldFail = (operation) => Effect.gen(function* () {
+		const opFails = operation === "append" && config.failAppend || operation === "getEntries" && config.failGetEntries || operation === "truncate" && config.failTruncate;
+		if (config.failAfterN !== void 0) {
+			const count = yield* Ref.get(operationCount);
+			yield* Ref.update(operationCount, (n) => n + 1);
+			if (count < config.failAfterN) return false;
+			return opFails;
+		}
+		return opFails;
+	});
+	return {
+		append: (documentId, entry) => Effect.gen(function* () {
+			if (yield* shouldFail("append")) return yield* Effect.fail(new HotStorageError({
+				documentId,
+				operation: "append",
+				cause: new Error(errorMessage)
+			}));
+			yield* Ref.update(store, (map) => {
+				const current = HashMap.get(map, documentId);
+				const entries = current._tag === "Some" ? current.value : [];
+				return HashMap.set(map, documentId, [...entries, entry]);
+			});
+		}),
+		getEntries: (documentId, sinceVersion) => Effect.gen(function* () {
+			if (yield* shouldFail("getEntries")) return yield* Effect.fail(new HotStorageError({
+				documentId,
+				operation: "getEntries",
+				cause: new Error(errorMessage)
+			}));
+			const current = yield* Ref.get(store);
+			const existing = HashMap.get(current, documentId);
+			return (existing._tag === "Some" ? existing.value : []).filter((e) => e.version > sinceVersion).sort((a, b) => a.version - b.version);
+		}),
+		truncate: (documentId, upToVersion) => Effect.gen(function* () {
+			if (yield* shouldFail("truncate")) return yield* Effect.fail(new HotStorageError({
+				documentId,
+				operation: "truncate",
+				cause: new Error(errorMessage)
+			}));
+			yield* Ref.update(store, (map) => {
+				const existing = HashMap.get(map, documentId);
+				if (existing._tag === "None") return map;
+				const filtered = existing.value.filter((e) => e.version > upToVersion);
+				return HashMap.set(map, documentId, filtered);
+			});
+		})
+	};
+}));
+const FailingStorage = {
+	makeColdStorage,
+	makeHotStorage
+};
+
+//#endregion
+export { FailingStorage };
+//# sourceMappingURL=FailingStorage.mjs.map

package/dist/testing/FailingStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"FailingStorage.mjs","names":[],"sources":["../../src/testing/FailingStorage.ts"],"sourcesContent":["/**\n * @voidhash/mimic-effect/testing - FailingStorage\n *\n * Mock storage implementations that simulate failures for testing error handling.\n * Use these to verify that your application correctly handles storage unavailability.\n *\n * @example\n * ```typescript\n * import { FailingStorage } from \"@voidhash/mimic-effect/testing\";\n *\n * // Create a ColdStorage that fails on load\n * const failingCold = FailingStorage.makeColdStorage({ failLoad: true });\n *\n * // Create a HotStorage that fails after 3 successful appends\n * const failingHot = FailingStorage.makeHotStorage({ failAfterN: 3, failAppend: true });\n * ```\n */\nimport { Effect, Layer, Ref, HashMap } from \"effect\";\nimport { ColdStorageTag, type ColdStorage } from \"../ColdStorage\";\nimport { HotStorageTag, type HotStorage } from \"../HotStorage\";\nimport { ColdStorageError, HotStorageError } from \"../Errors\";\nimport type { StoredDocument, WalEntry } from \"../Types\";\n\n// =============================================================================\n// Configuration Types\n// =============================================================================\n\n/**\n * Configuration for failing ColdStorage\n */\nexport interface FailingColdStorageConfig {\n  /** Fail load operations */\n  readonly failLoad?: boolean;\n  /** Fail save operations */\n  readonly failSave?: boolean;\n  /** Fail delete operations */\n  readonly failDelete?: boolean;\n  /** Fail after N successful operations (total across all operation types) */\n  readonly failAfterN?: number;\n  /** Custom error message */\n  readonly errorMessage?: string;\n}\n\n/**\n * Configuration for failing HotStorage\n */\nexport interface FailingHotStorageConfig {\n  /** Fail append operations */\n  readonly failAppend?: boolean;\n  /** Fail getEntries operations */\n  readonly failGetEntries?: boolean;\n  /** Fail truncate operations */\n  readonly failTruncate?: boolean;\n  /** Fail after N successful operations (total across all operation types) */\n  readonly failAfterN?: number;\n  /** Custom error message */\n  readonly errorMessage?: string;\n}\n\n// =============================================================================\n// Failing ColdStorage\n// =============================================================================\n\n/**\n * Create a ColdStorage layer that simulates failures.\n * Wraps an in-memory storage and fails according to configuration.\n */\nexport const makeColdStorage = (\n  config: FailingColdStorageConfig = {}\n): Layer.Layer<ColdStorageTag> =>\n  Layer.effect(\n    ColdStorageTag,\n    Effect.gen(function* () {\n      const store = yield* Ref.make(HashMap.empty<string, StoredDocument>());\n      const operationCount = yield* Ref.make(0);\n\n      const errorMessage = config.errorMessage ?? \"Simulated storage failure\";\n\n      const shouldFail = (operation: \"load\" | \"save\" | \"delete\") =>\n        Effect.gen(function* () {\n          // Check if this specific operation should fail\n          const opFails =\n            (operation === \"load\" && config.failLoad) ||\n            (operation === \"save\" && config.failSave) ||\n            (operation === \"delete\" && config.failDelete);\n\n          // If failAfterN is set, count operations first\n          if (config.failAfterN !== undefined) {\n            const count = yield* Ref.get(operationCount);\n            yield* Ref.update(operationCount, (n) => n + 1);\n\n            // Only start failing after N successful operations\n            if (count < config.failAfterN) {\n              return false;\n            }\n            // After N operations, fail if the specific op flag is set\n            return opFails;\n          }\n\n          // No failAfterN - fail immediately if op flag is set\n          return opFails;\n        });\n\n      const storage: ColdStorage = {\n        load: (documentId) =>\n          Effect.gen(function* () {\n            const fail = yield* shouldFail(\"load\");\n            if (fail) {\n              return yield* Effect.fail(\n                new ColdStorageError({\n                  documentId,\n                  operation: \"load\",\n                  cause: new Error(errorMessage),\n                })\n              );\n            }\n\n            const current = yield* Ref.get(store);\n            const doc = HashMap.get(current, documentId);\n            return doc._tag === \"Some\" ? doc.value : undefined;\n          }),\n\n        save: (documentId, document) =>\n          Effect.gen(function* () {\n            const fail = yield* shouldFail(\"save\");\n            if (fail) {\n              return yield* Effect.fail(\n                new ColdStorageError({\n                  documentId,\n                  operation: \"save\",\n                  cause: new Error(errorMessage),\n                })\n              );\n            }\n\n            yield* Ref.update(store, (map) =>\n              HashMap.set(map, documentId, document)\n            );\n          }),\n\n        delete: (documentId) =>\n          Effect.gen(function* () {\n            const fail = yield* shouldFail(\"delete\");\n            if (fail) {\n              return yield* Effect.fail(\n                new ColdStorageError({\n                  documentId,\n                  operation: \"delete\",\n                  cause: new Error(errorMessage),\n                })\n              );\n            }\n\n            yield* Ref.update(store, (map) => HashMap.remove(map, documentId));\n          }),\n      };\n\n      return storage;\n    })\n  );\n\n// =============================================================================\n// Failing HotStorage\n// =============================================================================\n\n/**\n * Create a HotStorage layer that simulates failures.\n * Wraps an in-memory storage and fails according to configuration.\n */\nexport const makeHotStorage = (\n  config: FailingHotStorageConfig = {}\n): Layer.Layer<HotStorageTag> =>\n  Layer.effect(\n    HotStorageTag,\n    Effect.gen(function* () {\n      const store = yield* Ref.make(HashMap.empty<string, WalEntry[]>());\n      const operationCount = yield* Ref.make(0);\n\n      const errorMessage = config.errorMessage ?? \"Simulated storage failure\";\n\n      const shouldFail = (operation: \"append\" | \"getEntries\" | \"truncate\") =>\n        Effect.gen(function* () {\n          // Check if this specific operation should fail\n          const opFails =\n            (operation === \"append\" && config.failAppend) ||\n            (operation === \"getEntries\" && config.failGetEntries) ||\n            (operation === \"truncate\" && config.failTruncate);\n\n          // If failAfterN is set, count operations first\n          if (config.failAfterN !== undefined) {\n            const count = yield* Ref.get(operationCount);\n            yield* Ref.update(operationCount, (n) => n + 1);\n\n            // Only start failing after N successful operations\n            if (count < config.failAfterN) {\n              return false;\n            }\n            // After N operations, fail if the specific op flag is set\n            return opFails;\n          }\n\n          // No failAfterN - fail immediately if op flag is set\n          return opFails;\n        });\n\n      const storage: HotStorage = {\n        append: (documentId, entry) =>\n          Effect.gen(function* () {\n            const fail = yield* shouldFail(\"append\");\n            if (fail) {\n              return yield* Effect.fail(\n                new HotStorageError({\n                  documentId,\n                  operation: \"append\",\n                  cause: new Error(errorMessage),\n                })\n              );\n            }\n\n            yield* Ref.update(store, (map) => {\n              const current = HashMap.get(map, documentId);\n              const entries = current._tag === \"Some\" ? current.value : [];\n              return HashMap.set(map, documentId, [...entries, entry]);\n            });\n          }),\n\n        getEntries: (documentId, sinceVersion) =>\n          Effect.gen(function* () {\n            const fail = yield* shouldFail(\"getEntries\");\n            if (fail) {\n              return yield* Effect.fail(\n                new HotStorageError({\n                  documentId,\n                  operation: \"getEntries\",\n                  cause: new Error(errorMessage),\n                })\n              );\n            }\n\n            const current = yield* Ref.get(store);\n            const existing = HashMap.get(current, documentId);\n            const entries = existing._tag === \"Some\" ? existing.value : [];\n\n            return entries\n              .filter((e) => e.version > sinceVersion)\n              .sort((a, b) => a.version - b.version);\n          }),\n\n        truncate: (documentId, upToVersion) =>\n          Effect.gen(function* () {\n            const fail = yield* shouldFail(\"truncate\");\n            if (fail) {\n              return yield* Effect.fail(\n                new HotStorageError({\n                  documentId,\n                  operation: \"truncate\",\n                  cause: new Error(errorMessage),\n                })\n              );\n            }\n\n            yield* Ref.update(store, (map) => {\n              const existing = HashMap.get(map, documentId);\n              if (existing._tag === \"None\") {\n                return map;\n              }\n              const filtered = existing.value.filter(\n                (e) => e.version > upToVersion\n              );\n              return HashMap.set(map, documentId, filtered);\n            });\n          }),\n      };\n\n      return storage;\n    })\n  );\n\n// =============================================================================\n// Export Namespace\n// =============================================================================\n\nexport const FailingStorage = {\n  makeColdStorage,\n  makeHotStorage,\n};\n"],"mappings":"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"}