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

package/dist/Errors.d.mts

@@ -0,0 +1,96 @@
+import * as effect_Types0 from "effect/Types";
+import * as effect_Cause0 from "effect/Cause";
+
+//#region src/Errors.d.ts
+declare const ColdStorageError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "ColdStorageError";
+} & Readonly<A>;
+/**
+ * Error when ColdStorage (snapshot storage) operations fail
+ */
+declare class ColdStorageError extends ColdStorageError_base<{
+  readonly documentId: string;
+  readonly operation: "load" | "save" | "delete";
+  readonly cause: unknown;
+}> {}
+declare const HotStorageError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "HotStorageError";
+} & Readonly<A>;
+/**
+ * Error when HotStorage (WAL storage) operations fail
+ */
+declare class HotStorageError extends HotStorageError_base<{
+  readonly documentId: string;
+  readonly operation: "append" | "getEntries" | "truncate" | "appendWithCheck";
+  readonly cause: unknown;
+}> {}
+declare const WalVersionGapError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "WalVersionGapError";
+} & Readonly<A>;
+/**
+ * Error when WAL append detects a version gap.
+ * This indicates either:
+ * - A bug in the application (skipped a version)
+ * - Concurrent writes to the same document
+ * - Data corruption in WAL storage
+ */
+declare class WalVersionGapError extends WalVersionGapError_base<{
+  readonly documentId: string;
+  readonly expectedVersion: number;
+  readonly actualPreviousVersion: number | undefined;
+}> {}
+declare const AuthenticationError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "AuthenticationError";
+} & Readonly<A>;
+/**
+ * Error when authentication fails (invalid token, expired, etc.)
+ */
+declare class AuthenticationError extends AuthenticationError_base<{
+  readonly reason: string;
+}> {}
+declare const AuthorizationError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "AuthorizationError";
+} & Readonly<A>;
+/**
+ * Error when authorization fails (user doesn't have required permission)
+ */
+declare class AuthorizationError extends AuthorizationError_base<{
+  readonly reason: string;
+  readonly required: "read" | "write";
+  readonly actual: "read" | "write";
+}> {}
+declare const MissingDocumentIdError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "MissingDocumentIdError";
+} & Readonly<A>;
+/**
+ * Error when document ID is missing from WebSocket request path
+ */
+declare class MissingDocumentIdError extends MissingDocumentIdError_base<{
+  readonly path: string;
+}> {}
+declare const MessageParseError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "MessageParseError";
+} & Readonly<A>;
+/**
+ * Error when WebSocket message cannot be parsed
+ */
+declare class MessageParseError extends MessageParseError_base<{
+  readonly cause: unknown;
+}> {}
+declare const TransactionRejectedError_base: new <A extends Record<string, any> = {}>(args: effect_Types0.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P] }) => effect_Cause0.YieldableError & {
+  readonly _tag: "TransactionRejectedError";
+} & Readonly<A>;
+/**
+ * Error when a transaction is rejected by the document
+ */
+declare class TransactionRejectedError extends TransactionRejectedError_base<{
+  readonly transactionId: string;
+  readonly reason: string;
+}> {}
+/**
+ * Union of all mimic-effect errors
+ */
+type MimicError = ColdStorageError | HotStorageError | WalVersionGapError | AuthenticationError | AuthorizationError | MissingDocumentIdError | MessageParseError | TransactionRejectedError;
+//#endregion
+export { AuthenticationError, AuthorizationError, ColdStorageError, HotStorageError, MessageParseError, MimicError, MissingDocumentIdError, TransactionRejectedError, WalVersionGapError };
+//# sourceMappingURL=Errors.d.mts.map

package/dist/Errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.mts","names":[],"sources":["../src/Errors.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;cAca,gBAAA,SAAyB;;;;;cAIjC;;;;;AAJL;AAIK,cAKQ,eAAA,SAAwB,oBALhC,CAAA;;;;;cASA;;;;;;;AAJL;AAIK;;cASQ,kBAAA,SAA2B;;;;;cAInC;;;;;AAJL;AAIK,cASQ,mBAAA,SAA4B,wBATpC,CAAA;;;cAaA;;;;;;cAKQ,kBAAA,SAA2B;;;EAT3B,SAAA,MAAA,EAAA,MAAoB,GAAA,OAAA;AAI5B,CAAA,CAAA,CAAA;cASA;;;;;;cASQ,sBAAA,SAA+B;;;cAIvC;EAjBQ,SAAA,IAAA,EAAA,mBAA2B;AAInC,CAAA,WAAA,EAAA,CAAA;;;;cAkBQ,iBAAA,SAA0B;;;cAElC;;;;;AAXL;AAIK,cAgBQ,wBAAA,SAAiC,6BAhBzC,CAAA;;;;;;;KA8BO,UAAA,GACR,mBACA,kBACA,qBACA,sBACA,qBACA,yBACA,oBACA"}

package/dist/Errors.mjs

@@ -0,0 +1,48 @@
+import { Data } from "effect";
+
+//#region src/Errors.ts
+/**
+* @voidhash/mimic-effect - Error Types
+*
+* All error types used throughout the mimic-effect package.
+*/
+/**
+* Error when ColdStorage (snapshot storage) operations fail
+*/
+var ColdStorageError = class extends Data.TaggedError("ColdStorageError") {};
+/**
+* Error when HotStorage (WAL storage) operations fail
+*/
+var HotStorageError = class extends Data.TaggedError("HotStorageError") {};
+/**
+* Error when WAL append detects a version gap.
+* This indicates either:
+* - A bug in the application (skipped a version)
+* - Concurrent writes to the same document
+* - Data corruption in WAL storage
+*/
+var WalVersionGapError = class extends Data.TaggedError("WalVersionGapError") {};
+/**
+* Error when authentication fails (invalid token, expired, etc.)
+*/
+var AuthenticationError = class extends Data.TaggedError("AuthenticationError") {};
+/**
+* Error when authorization fails (user doesn't have required permission)
+*/
+var AuthorizationError = class extends Data.TaggedError("AuthorizationError") {};
+/**
+* Error when document ID is missing from WebSocket request path
+*/
+var MissingDocumentIdError = class extends Data.TaggedError("MissingDocumentIdError") {};
+/**
+* Error when WebSocket message cannot be parsed
+*/
+var MessageParseError = class extends Data.TaggedError("MessageParseError") {};
+/**
+* Error when a transaction is rejected by the document
+*/
+var TransactionRejectedError = class extends Data.TaggedError("TransactionRejectedError") {};
+
+//#endregion
+export { AuthenticationError, AuthorizationError, ColdStorageError, HotStorageError, MessageParseError, MissingDocumentIdError, TransactionRejectedError, WalVersionGapError };
+//# sourceMappingURL=Errors.mjs.map

package/dist/Errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.mjs","names":[],"sources":["../src/Errors.ts"],"sourcesContent":["/**\n * @voidhash/mimic-effect - Error Types\n *\n * All error types used throughout the mimic-effect package.\n */\nimport { Data } from \"effect\";\n\n// =============================================================================\n// Storage Errors\n// =============================================================================\n\n/**\n * Error when ColdStorage (snapshot storage) operations fail\n */\nexport class ColdStorageError extends Data.TaggedError(\"ColdStorageError\")<{\n  readonly documentId: string;\n  readonly operation: \"load\" | \"save\" | \"delete\";\n  readonly cause: unknown;\n}> {}\n\n/**\n * Error when HotStorage (WAL storage) operations fail\n */\nexport class HotStorageError extends Data.TaggedError(\"HotStorageError\")<{\n  readonly documentId: string;\n  readonly operation: \"append\" | \"getEntries\" | \"truncate\" | \"appendWithCheck\";\n  readonly cause: unknown;\n}> {}\n\n/**\n * Error when WAL append detects a version gap.\n * This indicates either:\n * - A bug in the application (skipped a version)\n * - Concurrent writes to the same document\n * - Data corruption in WAL storage\n */\nexport class WalVersionGapError extends Data.TaggedError(\"WalVersionGapError\")<{\n  readonly documentId: string;\n  readonly expectedVersion: number;\n  readonly actualPreviousVersion: number | undefined;\n}> {}\n\n// =============================================================================\n// Auth Errors\n// =============================================================================\n\n/**\n * Error when authentication fails (invalid token, expired, etc.)\n */\nexport class AuthenticationError extends Data.TaggedError(\n  \"AuthenticationError\"\n)<{\n  readonly reason: string;\n}> {}\n\n/**\n * Error when authorization fails (user doesn't have required permission)\n */\nexport class AuthorizationError extends Data.TaggedError(\"AuthorizationError\")<{\n  readonly reason: string;\n  readonly required: \"read\" | \"write\";\n  readonly actual: \"read\" | \"write\";\n}> {}\n\n// =============================================================================\n// Connection Errors\n// =============================================================================\n\n/**\n * Error when document ID is missing from WebSocket request path\n */\nexport class MissingDocumentIdError extends Data.TaggedError(\n  \"MissingDocumentIdError\"\n)<{\n  readonly path: string;\n}> {}\n\n/**\n * Error when WebSocket message cannot be parsed\n */\nexport class MessageParseError extends Data.TaggedError(\"MessageParseError\")<{\n  readonly cause: unknown;\n}> {}\n\n// =============================================================================\n// Transaction Errors\n// =============================================================================\n\n/**\n * Error when a transaction is rejected by the document\n */\nexport class TransactionRejectedError extends Data.TaggedError(\n  \"TransactionRejectedError\"\n)<{\n  readonly transactionId: string;\n  readonly reason: string;\n}> {}\n\n// =============================================================================\n// Union Type\n// =============================================================================\n\n/**\n * Union of all mimic-effect errors\n */\nexport type MimicError =\n  | ColdStorageError\n  | HotStorageError\n  | WalVersionGapError\n  | AuthenticationError\n  | AuthorizationError\n  | MissingDocumentIdError\n  | MessageParseError\n  | TransactionRejectedError;\n"],"mappings":";;;;;;;;;;;AAcA,IAAa,mBAAb,cAAsC,KAAK,YAAY,mBAAmB,CAIvE;;;;AAKH,IAAa,kBAAb,cAAqC,KAAK,YAAY,kBAAkB,CAIrE;;;;;;;;AASH,IAAa,qBAAb,cAAwC,KAAK,YAAY,qBAAqB,CAI3E;;;;AASH,IAAa,sBAAb,cAAyC,KAAK,YAC5C,sBACD,CAEE;;;;AAKH,IAAa,qBAAb,cAAwC,KAAK,YAAY,qBAAqB,CAI3E;;;;AASH,IAAa,yBAAb,cAA4C,KAAK,YAC/C,yBACD,CAEE;;;;AAKH,IAAa,oBAAb,cAAuC,KAAK,YAAY,oBAAoB,CAEzE;;;;AASH,IAAa,2BAAb,cAA8C,KAAK,YACjD,2BACD,CAGE"}

package/dist/HotStorage.cjs

@@ -0,0 +1,100 @@
+const require_Errors = require('./Errors.cjs');
+let effect = require("effect");
+
+//#region src/HotStorage.ts
+/**
+* @voidhash/mimic-effect - HotStorage
+*
+* Interface and implementations for Write-Ahead Log (WAL) storage.
+*/
+/**
+* Context tag for HotStorage service
+*/
+var HotStorageTag = class extends effect.Context.Tag("@voidhash/mimic-effect/HotStorage")() {};
+/**
+* Create a HotStorage layer from an Effect that produces a HotStorage service.
+*
+* This allows you to access other Effect services when implementing custom storage.
+*
+* @example
+* ```typescript
+* const Hot = HotStorage.make(
+*   Effect.gen(function*() {
+*     const redis = yield* RedisService
+*
+*     return {
+*       append: (documentId, entry) =>
+*         redis.rpush(`wal:${documentId}`, JSON.stringify(entry)),
+*       getEntries: (documentId, sinceVersion) =>
+*         redis.lrange(`wal:${documentId}`, 0, -1).pipe(
+*           Effect.map(entries =>
+*             entries
+*               .map(e => JSON.parse(e))
+*               .filter(e => e.version > sinceVersion)
+*               .sort((a, b) => a.version - b.version)
+*           )
+*         ),
+*       truncate: (documentId, upToVersion) =>
+*         // Implementation depends on Redis data structure
+*         Effect.void,
+*     }
+*   })
+* )
+* ```
+*/
+const make = (effect$1) => effect.Layer.effect(HotStorageTag, effect$1);
+let InMemory;
+(function(_InMemory) {
+	_InMemory.make = () => effect.Layer.effect(HotStorageTag, effect.Effect.gen(function* () {
+		const store = yield* effect.Ref.make(effect.HashMap.empty());
+		return {
+			append: (documentId, entry) => effect.Ref.update(store, (map) => {
+				const existing = effect.HashMap.get(map, documentId);
+				const entries = existing._tag === "Some" ? existing.value : [];
+				return effect.HashMap.set(map, documentId, [...entries, entry]);
+			}),
+			appendWithCheck: (documentId, entry, expectedVersion) => effect.Effect.gen(function* () {
+				const result = yield* effect.Ref.modify(store, (map) => {
+					const existing = effect.HashMap.get(map, documentId);
+					const entries = existing._tag === "Some" ? existing.value : [];
+					const lastVersion = entries.length > 0 ? Math.max(...entries.map((e) => e.version)) : 0;
+					if (expectedVersion === 1) {
+						if (lastVersion >= 1) return [{
+							type: "gap",
+							lastVersion
+						}, map];
+					} else if (lastVersion !== expectedVersion - 1) return [{
+						type: "gap",
+						lastVersion: lastVersion > 0 ? lastVersion : void 0
+					}, map];
+					return [{ type: "ok" }, effect.HashMap.set(map, documentId, [...entries, entry])];
+				});
+				if (result.type === "gap") return yield* effect.Effect.fail(new require_Errors.WalVersionGapError({
+					documentId,
+					expectedVersion,
+					actualPreviousVersion: result.lastVersion
+				}));
+			}),
+			getEntries: (documentId, sinceVersion) => effect.Effect.gen(function* () {
+				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.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);
+			})
+		};
+	}));
+})(InMemory || (InMemory = {}));
+const HotStorage = {
+	Tag: HotStorageTag,
+	make,
+	InMemory
+};
+
+//#endregion
+exports.HotStorage = HotStorage;
+exports.HotStorageTag = HotStorageTag;

package/dist/HotStorage.d.cts

@@ -0,0 +1,70 @@
+import { WalEntry } from "./Types.cjs";
+import { HotStorageError, WalVersionGapError } from "./Errors.cjs";
+import { Context, Effect, Layer } from "effect";
+
+//#region src/HotStorage.d.ts
+
+/**
+ * HotStorage interface for storing Write-Ahead Log entries.
+ *
+ * This is the "hot" tier of the two-tier storage system.
+ * It stores every transaction as a WAL entry for durability between snapshots.
+ * WAL entries are small (just the transaction) and writes are append-only.
+ */
+interface HotStorage {
+  /**
+   * Append a WAL entry for a document.
+   */
+  readonly append: (documentId: string, entry: WalEntry) => Effect.Effect<void, HotStorageError>;
+  /**
+   * Append a WAL entry with version gap checking.
+   *
+   * This is an atomic operation that:
+   * 1. Verifies the previous entry has version = expectedVersion - 1
+   *    (or this is the first entry if expectedVersion === 1)
+   * 2. Appends the entry if check passes
+   *
+   * Use this for two-phase commit to guarantee WAL ordering at write time.
+   *
+   * @param documentId - Document ID
+   * @param entry - WAL entry to append
+   * @param expectedVersion - The version this entry should have (entry.version)
+   * @returns Effect that fails with WalVersionGapError if gap detected
+   */
+  readonly appendWithCheck: (documentId: string, entry: WalEntry, expectedVersion: number) => Effect.Effect<void, HotStorageError | WalVersionGapError>;
+  /**
+   * Get all WAL entries for a document since a given version.
+   * Returns entries with version > sinceVersion, ordered by version.
+   */
+  readonly getEntries: (documentId: string, sinceVersion: number) => Effect.Effect<WalEntry[], HotStorageError>;
+  /**
+   * Truncate WAL entries up to (and including) a given version.
+   * Called after a snapshot is saved to remove entries that are now in the snapshot.
+   */
+  readonly truncate: (documentId: string, upToVersion: number) => Effect.Effect<void, HotStorageError>;
+}
+declare const HotStorageTag_base: Context.TagClass<HotStorageTag, "@voidhash/mimic-effect/HotStorage", HotStorage>;
+/**
+ * Context tag for HotStorage service
+ */
+declare class HotStorageTag extends HotStorageTag_base {}
+/**
+ * In-memory HotStorage implementation.
+ *
+ * Useful for testing and development. Not suitable for production
+ * as data is lost when the process restarts.
+ */
+declare namespace InMemory {
+  /**
+   * Create an in-memory HotStorage layer.
+   */
+  const make: () => Layer.Layer<HotStorageTag>;
+}
+declare const HotStorage: {
+  Tag: typeof HotStorageTag;
+  make: <E, R>(effect: Effect.Effect<HotStorage, E, R>) => Layer.Layer<HotStorageTag, E, R>;
+  InMemory: typeof InMemory;
+};
+//#endregion
+export { HotStorage, HotStorageTag };
+//# sourceMappingURL=HotStorage.d.cts.map

package/dist/HotStorage.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HotStorage.d.cts","names":[],"sources":["../src/HotStorage.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;AAyDO,UArCU,UAAA,CAqCH;EASa;;;EAC1B,SAAA,MAAA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,KAAA,EAzCU,QAyCV,EAAA,GAxCM,MAAA,CAAO,MAwCb,CAAA,IAAA,EAxC0B,eAwC1B,CAAA;;;;;AASD;AAuDA;AAuGA;;;;;;;;;EApHG,SAAM,eAAA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,KAAA,EAxEE,QAwEF,EAAA,eAAA,EAAA,MAAA,EAAA,GAtEF,MAAA,CAAO,MAsEL,CAAA,IAAA,EAtEkB,eAsElB,GAtEoC,kBAsEpC,CAAA;;;;;qEA7DF,MAAA,CAAO,OAAO,YAAY;;;;;kEAS1B,MAAA,CAAO,aAAa;;cAC1B;;;;cASY,aAAA,SAAsB,kBAAA;;;;;;;kBAuDlB,QAAA;;;;oBAIS,KAAA,CAAM,MAAM;;cAmGzB;;uBArHH,MAAA,CAAO,OAAO,YAAY,GAAG,OACpC,KAAA,CAAM,MAAM,eAAe,GAAG"}

package/dist/HotStorage.d.mts

@@ -0,0 +1,70 @@
+import { WalEntry } from "./Types.mjs";
+import { HotStorageError, WalVersionGapError } from "./Errors.mjs";
+import { Context, Effect, Layer } from "effect";
+
+//#region src/HotStorage.d.ts
+
+/**
+ * HotStorage interface for storing Write-Ahead Log entries.
+ *
+ * This is the "hot" tier of the two-tier storage system.
+ * It stores every transaction as a WAL entry for durability between snapshots.
+ * WAL entries are small (just the transaction) and writes are append-only.
+ */
+interface HotStorage {
+  /**
+   * Append a WAL entry for a document.
+   */
+  readonly append: (documentId: string, entry: WalEntry) => Effect.Effect<void, HotStorageError>;
+  /**
+   * Append a WAL entry with version gap checking.
+   *
+   * This is an atomic operation that:
+   * 1. Verifies the previous entry has version = expectedVersion - 1
+   *    (or this is the first entry if expectedVersion === 1)
+   * 2. Appends the entry if check passes
+   *
+   * Use this for two-phase commit to guarantee WAL ordering at write time.
+   *
+   * @param documentId - Document ID
+   * @param entry - WAL entry to append
+   * @param expectedVersion - The version this entry should have (entry.version)
+   * @returns Effect that fails with WalVersionGapError if gap detected
+   */
+  readonly appendWithCheck: (documentId: string, entry: WalEntry, expectedVersion: number) => Effect.Effect<void, HotStorageError | WalVersionGapError>;
+  /**
+   * Get all WAL entries for a document since a given version.
+   * Returns entries with version > sinceVersion, ordered by version.
+   */
+  readonly getEntries: (documentId: string, sinceVersion: number) => Effect.Effect<WalEntry[], HotStorageError>;
+  /**
+   * Truncate WAL entries up to (and including) a given version.
+   * Called after a snapshot is saved to remove entries that are now in the snapshot.
+   */
+  readonly truncate: (documentId: string, upToVersion: number) => Effect.Effect<void, HotStorageError>;
+}
+declare const HotStorageTag_base: Context.TagClass<HotStorageTag, "@voidhash/mimic-effect/HotStorage", HotStorage>;
+/**
+ * Context tag for HotStorage service
+ */
+declare class HotStorageTag extends HotStorageTag_base {}
+/**
+ * In-memory HotStorage implementation.
+ *
+ * Useful for testing and development. Not suitable for production
+ * as data is lost when the process restarts.
+ */
+declare namespace InMemory {
+  /**
+   * Create an in-memory HotStorage layer.
+   */
+  const make: () => Layer.Layer<HotStorageTag>;
+}
+declare const HotStorage: {
+  Tag: typeof HotStorageTag;
+  make: <E, R>(effect: Effect.Effect<HotStorage, E, R>) => Layer.Layer<HotStorageTag, E, R>;
+  InMemory: typeof InMemory;
+};
+//#endregion
+export { HotStorage, HotStorageTag };
+//# sourceMappingURL=HotStorage.d.mts.map

package/dist/HotStorage.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HotStorage.d.mts","names":[],"sources":["../src/HotStorage.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;AAyDO,UArCU,UAAA,CAqCH;EASa;;;EAC1B,SAAA,MAAA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,KAAA,EAzCU,QAyCV,EAAA,GAxCM,MAAA,CAAO,MAwCb,CAAA,IAAA,EAxC0B,eAwC1B,CAAA;;;;;AASD;AAuDA;AAuGA;;;;;;;;;EApHG,SAAM,eAAA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,KAAA,EAxEE,QAwEF,EAAA,eAAA,EAAA,MAAA,EAAA,GAtEF,MAAA,CAAO,MAsEL,CAAA,IAAA,EAtEkB,eAsElB,GAtEoC,kBAsEpC,CAAA;;;;;qEA7DF,MAAA,CAAO,OAAO,YAAY;;;;;kEAS1B,MAAA,CAAO,aAAa;;cAC1B;;;;cASY,aAAA,SAAsB,kBAAA;;;;;;;kBAuDlB,QAAA;;;;oBAIS,KAAA,CAAM,MAAM;;cAmGzB;;uBArHH,MAAA,CAAO,OAAO,YAAY,GAAG,OACpC,KAAA,CAAM,MAAM,eAAe,GAAG"}

package/dist/HotStorage.mjs

@@ -0,0 +1,100 @@
+import { WalVersionGapError } from "./Errors.mjs";
+import { Context, Effect, HashMap, Layer, Ref } from "effect";
+
+//#region src/HotStorage.ts
+/**
+* @voidhash/mimic-effect - HotStorage
+*
+* Interface and implementations for Write-Ahead Log (WAL) storage.
+*/
+/**
+* Context tag for HotStorage service
+*/
+var HotStorageTag = class extends Context.Tag("@voidhash/mimic-effect/HotStorage")() {};
+/**
+* Create a HotStorage layer from an Effect that produces a HotStorage service.
+*
+* This allows you to access other Effect services when implementing custom storage.
+*
+* @example
+* ```typescript
+* const Hot = HotStorage.make(
+*   Effect.gen(function*() {
+*     const redis = yield* RedisService
+*
+*     return {
+*       append: (documentId, entry) =>
+*         redis.rpush(`wal:${documentId}`, JSON.stringify(entry)),
+*       getEntries: (documentId, sinceVersion) =>
+*         redis.lrange(`wal:${documentId}`, 0, -1).pipe(
+*           Effect.map(entries =>
+*             entries
+*               .map(e => JSON.parse(e))
+*               .filter(e => e.version > sinceVersion)
+*               .sort((a, b) => a.version - b.version)
+*           )
+*         ),
+*       truncate: (documentId, upToVersion) =>
+*         // Implementation depends on Redis data structure
+*         Effect.void,
+*     }
+*   })
+* )
+* ```
+*/
+const make = (effect) => Layer.effect(HotStorageTag, effect);
+let InMemory;
+(function(_InMemory) {
+	_InMemory.make = () => Layer.effect(HotStorageTag, Effect.gen(function* () {
+		const store = yield* Ref.make(HashMap.empty());
+		return {
+			append: (documentId, entry) => Ref.update(store, (map) => {
+				const existing = HashMap.get(map, documentId);
+				const entries = existing._tag === "Some" ? existing.value : [];
+				return HashMap.set(map, documentId, [...entries, entry]);
+			}),
+			appendWithCheck: (documentId, entry, expectedVersion) => Effect.gen(function* () {
+				const result = yield* Ref.modify(store, (map) => {
+					const existing = HashMap.get(map, documentId);
+					const entries = existing._tag === "Some" ? existing.value : [];
+					const lastVersion = entries.length > 0 ? Math.max(...entries.map((e) => e.version)) : 0;
+					if (expectedVersion === 1) {
+						if (lastVersion >= 1) return [{
+							type: "gap",
+							lastVersion
+						}, map];
+					} else if (lastVersion !== expectedVersion - 1) return [{
+						type: "gap",
+						lastVersion: lastVersion > 0 ? lastVersion : void 0
+					}, map];
+					return [{ type: "ok" }, HashMap.set(map, documentId, [...entries, entry])];
+				});
+				if (result.type === "gap") return yield* Effect.fail(new WalVersionGapError({
+					documentId,
+					expectedVersion,
+					actualPreviousVersion: result.lastVersion
+				}));
+			}),
+			getEntries: (documentId, sinceVersion) => Effect.gen(function* () {
+				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) => 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);
+			})
+		};
+	}));
+})(InMemory || (InMemory = {}));
+const HotStorage = {
+	Tag: HotStorageTag,
+	make,
+	InMemory
+};
+
+//#endregion
+export { HotStorage, HotStorageTag };
+//# sourceMappingURL=HotStorage.mjs.map

package/dist/HotStorage.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"HotStorage.mjs","names":["result: CheckResult"],"sources":["../src/HotStorage.ts"],"sourcesContent":["/**\n * @voidhash/mimic-effect - HotStorage\n *\n * Interface and implementations for Write-Ahead Log (WAL) storage.\n */\nimport { Context, Effect, HashMap, Layer, Ref } from \"effect\";\nimport type { WalEntry } from \"./Types\";\nimport { HotStorageError, WalVersionGapError } from \"./Errors\";\n\n// =============================================================================\n// HotStorage Interface\n// =============================================================================\n\n/**\n * HotStorage interface for storing Write-Ahead Log entries.\n *\n * This is the \"hot\" tier of the two-tier storage system.\n * It stores every transaction as a WAL entry for durability between snapshots.\n * WAL entries are small (just the transaction) and writes are append-only.\n */\nexport interface HotStorage {\n  /**\n   * Append a WAL entry for a document.\n   */\n  readonly append: (\n    documentId: string,\n    entry: WalEntry\n  ) => Effect.Effect<void, HotStorageError>;\n\n  /**\n   * Append a WAL entry with version gap checking.\n   *\n   * This is an atomic operation that:\n   * 1. Verifies the previous entry has version = expectedVersion - 1\n   *    (or this is the first entry if expectedVersion === 1)\n   * 2. Appends the entry if check passes\n   *\n   * Use this for two-phase commit to guarantee WAL ordering at write time.\n   *\n   * @param documentId - Document ID\n   * @param entry - WAL entry to append\n   * @param expectedVersion - The version this entry should have (entry.version)\n   * @returns Effect that fails with WalVersionGapError if gap detected\n   */\n  readonly appendWithCheck: (\n    documentId: string,\n    entry: WalEntry,\n    expectedVersion: number\n  ) => Effect.Effect<void, HotStorageError | WalVersionGapError>;\n\n  /**\n   * Get all WAL entries for a document since a given version.\n   * Returns entries with version > sinceVersion, ordered by version.\n   */\n  readonly getEntries: (\n    documentId: string,\n    sinceVersion: number\n  ) => Effect.Effect<WalEntry[], HotStorageError>;\n\n  /**\n   * Truncate WAL entries up to (and including) a given version.\n   * Called after a snapshot is saved to remove entries that are now in the snapshot.\n   */\n  readonly truncate: (\n    documentId: string,\n    upToVersion: number\n  ) => Effect.Effect<void, HotStorageError>;\n}\n\n// =============================================================================\n// Context Tag\n// =============================================================================\n\n/**\n * Context tag for HotStorage service\n */\nexport class HotStorageTag extends Context.Tag(\"@voidhash/mimic-effect/HotStorage\")<\n  HotStorageTag,\n  HotStorage\n>() {}\n\n// =============================================================================\n// Factory\n// =============================================================================\n\n/**\n * Create a HotStorage layer from an Effect that produces a HotStorage service.\n *\n * This allows you to access other Effect services when implementing custom storage.\n *\n * @example\n * ```typescript\n * const Hot = HotStorage.make(\n *   Effect.gen(function*() {\n *     const redis = yield* RedisService\n *\n *     return {\n *       append: (documentId, entry) =>\n *         redis.rpush(`wal:${documentId}`, JSON.stringify(entry)),\n *       getEntries: (documentId, sinceVersion) =>\n *         redis.lrange(`wal:${documentId}`, 0, -1).pipe(\n *           Effect.map(entries =>\n *             entries\n *               .map(e => JSON.parse(e))\n *               .filter(e => e.version > sinceVersion)\n *               .sort((a, b) => a.version - b.version)\n *           )\n *         ),\n *       truncate: (documentId, upToVersion) =>\n *         // Implementation depends on Redis data structure\n *         Effect.void,\n *     }\n *   })\n * )\n * ```\n */\nexport const make = <E, R>(\n  effect: Effect.Effect<HotStorage, E, R>\n): Layer.Layer<HotStorageTag, E, R> =>\n  Layer.effect(HotStorageTag, effect);\n\n// =============================================================================\n// InMemory Implementation\n// =============================================================================\n\n/**\n * In-memory HotStorage implementation.\n *\n * Useful for testing and development. Not suitable for production\n * as data is lost when the process restarts.\n */\nexport namespace InMemory {\n  /**\n   * Create an in-memory HotStorage layer.\n   */\n  export const make = (): Layer.Layer<HotStorageTag> =>\n    Layer.effect(\n      HotStorageTag,\n      Effect.gen(function* () {\n        const store = yield* Ref.make(HashMap.empty<string, WalEntry[]>());\n\n        return {\n          append: (documentId, entry) =>\n            Ref.update(store, (map) => {\n              const existing = HashMap.get(map, documentId);\n              const entries =\n                existing._tag === \"Some\" ? existing.value : [];\n              return HashMap.set(map, documentId, [...entries, entry]);\n            }),\n\n          appendWithCheck: (documentId, entry, expectedVersion) =>\n            Effect.gen(function* () {\n              type CheckResult =\n                | { type: \"ok\" }\n                | { type: \"gap\"; lastVersion: number | undefined };\n\n              // Use Ref.modify for atomic check + update\n              const result: CheckResult = yield* Ref.modify(store, (map): [CheckResult, HashMap.HashMap<string, WalEntry[]>] => {\n                const existing = HashMap.get(map, documentId);\n                const entries = existing._tag === \"Some\" ? existing.value : [];\n\n                // Find the highest version in existing entries\n                const lastVersion = entries.length > 0\n                  ? Math.max(...entries.map((e) => e.version))\n                  : 0;\n\n                // Gap check\n                if (expectedVersion === 1) {\n                  // First entry: should have no entries with version >= 1\n                  if (lastVersion >= 1) {\n                    return [\n                      { type: \"gap\", lastVersion },\n                      map,\n                    ];\n                  }\n                } else {\n                  // Not first: last entry should have version = expectedVersion - 1\n                  if (lastVersion !== expectedVersion - 1) {\n                    return [\n                      { type: \"gap\", lastVersion: lastVersion > 0 ? lastVersion : undefined },\n                      map,\n                    ];\n                  }\n                }\n\n                // No gap: append and return success\n                return [\n                  { type: \"ok\" },\n                  HashMap.set(map, documentId, [...entries, entry]),\n                ];\n              });\n\n              if (result.type === \"gap\") {\n                return yield* Effect.fail(\n                  new WalVersionGapError({\n                    documentId,\n                    expectedVersion,\n                    actualPreviousVersion: result.lastVersion,\n                  })\n                );\n              }\n            }),\n\n          getEntries: (documentId, sinceVersion) =>\n            Effect.gen(function* () {\n              const current = yield* Ref.get(store);\n              const existing = HashMap.get(current, documentId);\n              const entries =\n                existing._tag === \"Some\" ? existing.value : [];\n              return entries\n                .filter((e) => e.version > sinceVersion)\n                .sort((a, b) => a.version - b.version);\n            }),\n\n          truncate: (documentId, upToVersion) =>\n            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}\n\n// =============================================================================\n// Re-export namespace\n// =============================================================================\n\nexport const HotStorage = {\n  Tag: HotStorageTag,\n  make,\n  InMemory,\n};\n"],"mappings":";;;;;;;;;;;;AA4EA,IAAa,gBAAb,cAAmC,QAAQ,IAAI,oCAAoC,EAGhF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCJ,MAAa,QACX,WAEA,MAAM,OAAO,eAAe,OAAO;;;wBAiBjC,MAAM,OACJ,eACA,OAAO,IAAI,aAAa;EACtB,MAAM,QAAQ,OAAO,IAAI,KAAK,QAAQ,OAA2B,CAAC;AAElE,SAAO;GACL,SAAS,YAAY,UACnB,IAAI,OAAO,QAAQ,QAAQ;IACzB,MAAM,WAAW,QAAQ,IAAI,KAAK,WAAW;IAC7C,MAAM,UACJ,SAAS,SAAS,SAAS,SAAS,QAAQ,EAAE;AAChD,WAAO,QAAQ,IAAI,KAAK,YAAY,CAAC,GAAG,SAAS,MAAM,CAAC;KACxD;GAEJ,kBAAkB,YAAY,OAAO,oBACnC,OAAO,IAAI,aAAa;IAMtB,MAAMA,SAAsB,OAAO,IAAI,OAAO,QAAQ,QAA4D;KAChH,MAAM,WAAW,QAAQ,IAAI,KAAK,WAAW;KAC7C,MAAM,UAAU,SAAS,SAAS,SAAS,SAAS,QAAQ,EAAE;KAG9D,MAAM,cAAc,QAAQ,SAAS,IACjC,KAAK,IAAI,GAAG,QAAQ,KAAK,MAAM,EAAE,QAAQ,CAAC,GAC1C;AAGJ,SAAI,oBAAoB,GAEtB;UAAI,eAAe,EACjB,QAAO,CACL;OAAE,MAAM;OAAO;OAAa,EAC5B,IACD;gBAIC,gBAAgB,kBAAkB,EACpC,QAAO,CACL;MAAE,MAAM;MAAO,aAAa,cAAc,IAAI,cAAc;MAAW,EACvE,IACD;AAKL,YAAO,CACL,EAAE,MAAM,MAAM,EACd,QAAQ,IAAI,KAAK,YAAY,CAAC,GAAG,SAAS,MAAM,CAAC,CAClD;MACD;AAEF,QAAI,OAAO,SAAS,MAClB,QAAO,OAAO,OAAO,KACnB,IAAI,mBAAmB;KACrB;KACA;KACA,uBAAuB,OAAO;KAC/B,CAAC,CACH;KAEH;GAEJ,aAAa,YAAY,iBACvB,OAAO,IAAI,aAAa;IACtB,MAAM,UAAU,OAAO,IAAI,IAAI,MAAM;IACrC,MAAM,WAAW,QAAQ,IAAI,SAAS,WAAW;AAGjD,YADE,SAAS,SAAS,SAAS,SAAS,QAAQ,EAAE,EAE7C,QAAQ,MAAM,EAAE,UAAU,aAAa,CACvC,MAAM,GAAG,MAAM,EAAE,UAAU,EAAE,QAAQ;KACxC;GAEJ,WAAW,YAAY,gBACrB,IAAI,OAAO,QAAQ,QAAQ;IACzB,MAAM,WAAW,QAAQ,IAAI,KAAK,WAAW;AAC7C,QAAI,SAAS,SAAS,OACpB,QAAO;IAET,MAAM,WAAW,SAAS,MAAM,QAC7B,MAAM,EAAE,UAAU,YACpB;AACD,WAAO,QAAQ,IAAI,KAAK,YAAY,SAAS;KAC7C;GACL;GACD,CACH;;AAOL,MAAa,aAAa;CACxB,KAAK;CACL;CACA;CACD"}