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

package/tests/HotStorage.test.ts

@@ -1,138 +1,19 @@
 import { describe, it, expect } from "vitest";
 import { Effect } from "effect";
 import { HotStorage, HotStorageTag } from "../src/HotStorage";
-import type { WalEntry } from "../src/Types";
-import { Transaction } from "@voidhash/mimic";
+import { HotStorageTestSuite } from "../src/testing";
 
 describe("HotStorage", () => {
   describe("InMemory", () => {
+    // Use the test suite utilities for comprehensive testing
     const layer = HotStorage.InMemory.make();
 
-    const makeEntry = (version: number): WalEntry => ({
-      transaction: Transaction.make([]),
-      version,
-      timestamp: Date.now(),
-    });
-
-    it("should return empty array for missing document", async () => {
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const storage = yield* HotStorageTag;
-          return yield* storage.getEntries("non-existent", 0);
-        }).pipe(Effect.provide(layer))
-      );
-
-      expect(result).toEqual([]);
-    });
-
-    it("should append and retrieve entries", async () => {
-      const entry1 = makeEntry(1);
-      const entry2 = makeEntry(2);
-
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const storage = yield* HotStorageTag;
-          yield* storage.append("doc-1", entry1);
-          yield* storage.append("doc-1", entry2);
-          return yield* storage.getEntries("doc-1", 0);
-        }).pipe(Effect.provide(layer))
-      );
-
-      expect(result.length).toBe(2);
-      expect(result[0]!.version).toBe(1);
-      expect(result[1]!.version).toBe(2);
-    });
-
-    it("should filter entries by sinceVersion", async () => {
-      const entries = [makeEntry(1), makeEntry(2), makeEntry(3), makeEntry(4)];
-
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const storage = yield* HotStorageTag;
-          for (const entry of entries) {
-            yield* storage.append("doc-1", entry);
-          }
-          return yield* storage.getEntries("doc-1", 2);
-        }).pipe(Effect.provide(layer))
-      );
-
-      expect(result.length).toBe(2);
-      expect(result[0]!.version).toBe(3);
-      expect(result[1]!.version).toBe(4);
-    });
-
-    it("should truncate entries up to version", async () => {
-      const entries = [makeEntry(1), makeEntry(2), makeEntry(3), makeEntry(4)];
-
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const storage = yield* HotStorageTag;
-          for (const entry of entries) {
-            yield* storage.append("doc-1", entry);
-          }
-          yield* storage.truncate("doc-1", 2);
-          return yield* storage.getEntries("doc-1", 0);
-        }).pipe(Effect.provide(layer))
+    // Run all test suite tests
+    for (const test of HotStorageTestSuite.makeTests()) {
+      it(`[${test.category}] ${test.name}`, () =>
+        Effect.runPromise(test.run.pipe(Effect.provide(layer)))
       );
-
-      expect(result.length).toBe(2);
-      expect(result[0]!.version).toBe(3);
-      expect(result[1]!.version).toBe(4);
-    });
-
-    it("should maintain order after append", async () => {
-      const entries = [makeEntry(3), makeEntry(1), makeEntry(2)];
-
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const storage = yield* HotStorageTag;
-          for (const entry of entries) {
-            yield* storage.append("doc-1", entry);
-          }
-          return yield* storage.getEntries("doc-1", 0);
-        }).pipe(Effect.provide(layer))
-      );
-
-      // Should be sorted by version
-      expect(result.length).toBe(3);
-      expect(result[0]!.version).toBe(1);
-      expect(result[1]!.version).toBe(2);
-      expect(result[2]!.version).toBe(3);
-    });
-
-    it("should isolate documents", async () => {
-      const entry1 = makeEntry(1);
-      const entry2 = makeEntry(2);
-
-      const result = await Effect.runPromise(
-        Effect.gen(function* () {
-          const storage = yield* HotStorageTag;
-          yield* storage.append("doc-1", entry1);
-          yield* storage.append("doc-2", entry2);
-
-          const entries1 = yield* storage.getEntries("doc-1", 0);
-          const entries2 = yield* storage.getEntries("doc-2", 0);
-
-          return { entries1, entries2 };
-        }).pipe(Effect.provide(layer))
-      );
-
-      expect(result.entries1.length).toBe(1);
-      expect(result.entries1[0]!.version).toBe(1);
-      expect(result.entries2.length).toBe(1);
-      expect(result.entries2[0]!.version).toBe(2);
-    });
-
-    it("should not error when truncating non-existent document", async () => {
-      await expect(
-        Effect.runPromise(
-          Effect.gen(function* () {
-            const storage = yield* HotStorageTag;
-            yield* storage.truncate("non-existent", 5);
-          }).pipe(Effect.provide(layer))
-        )
-      ).resolves.toBeUndefined();
-    });
+    }
   });
 
   describe("Tag", () => {

package/tests/StorageIntegration.test.ts

@@ -0,0 +1,259 @@
+import { describe, it, expect } from "vitest";
+import { Effect, Layer } from "effect";
+import { StorageIntegrationTestSuite } from "../src/testing/StorageIntegrationTestSuite";
+import { FailingStorage } from "../src/testing/FailingStorage";
+import { ColdStorage, ColdStorageTag } from "../src/ColdStorage";
+import { HotStorage, HotStorageTag } from "../src/HotStorage";
+
+// =============================================================================
+// Storage Integration Tests
+// =============================================================================
+
+describe("Storage Integration", () => {
+  const layer = Layer.mergeAll(
+    ColdStorage.InMemory.make(),
+    HotStorage.InMemory.make()
+  );
+
+  for (const test of StorageIntegrationTestSuite.makeTests()) {
+    it(test.name, () =>
+      Effect.runPromise(test.run.pipe(Effect.provide(layer)))
+    );
+  }
+});
+
+// =============================================================================
+// Failure Scenario Tests
+// =============================================================================
+
+describe("Storage Failure Scenarios", () => {
+  describe("ColdStorage Failures", () => {
+    it("load failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        FailingStorage.makeColdStorage({ failLoad: true }),
+        HotStorage.InMemory.make()
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const cold = yield* ColdStorageTag;
+          return yield* Effect.either(cold.load("test-doc"));
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("ColdStorageError");
+      }
+    });
+
+    it("save failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        FailingStorage.makeColdStorage({ failSave: true }),
+        HotStorage.InMemory.make()
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const cold = yield* ColdStorageTag;
+          return yield* Effect.either(
+            cold.save("test-doc", {
+              state: { data: "test" },
+              version: 1,
+              schemaVersion: 1,
+              savedAt: Date.now(),
+            })
+          );
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("ColdStorageError");
+      }
+    });
+
+    it("failAfterN allows first N operations then fails", async () => {
+      const failingLayer = Layer.mergeAll(
+        FailingStorage.makeColdStorage({ failAfterN: 2, failLoad: true }),
+        HotStorage.InMemory.make()
+      );
+
+      const results = await Effect.runPromise(
+        Effect.gen(function* () {
+          const cold = yield* ColdStorageTag;
+
+          // First 2 operations succeed
+          const r1 = yield* Effect.either(cold.load("doc-1"));
+          const r2 = yield* Effect.either(cold.load("doc-2"));
+
+          // Third operation fails
+          const r3 = yield* Effect.either(cold.load("doc-3"));
+
+          return { r1, r2, r3 };
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(results.r1._tag).toBe("Right");
+      expect(results.r2._tag).toBe("Right");
+      expect(results.r3._tag).toBe("Left");
+    });
+  });
+
+  describe("HotStorage Failures", () => {
+    it("append failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({ failAppend: true })
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+          return yield* Effect.either(
+            hot.append("test-doc", {
+              transaction: { id: "tx-1", ops: [], timestamp: Date.now() },
+              version: 1,
+              timestamp: Date.now(),
+            })
+          );
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("HotStorageError");
+      }
+    });
+
+    it("getEntries failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({ failGetEntries: true })
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+          return yield* Effect.either(hot.getEntries("test-doc", 0));
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("HotStorageError");
+      }
+    });
+
+    it("truncate failure propagates error", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({ failTruncate: true })
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+          return yield* Effect.either(hot.truncate("test-doc", 5));
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left._tag).toBe("HotStorageError");
+      }
+    });
+
+    it("failAfterN allows first N operations then fails", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({ failAfterN: 3, failAppend: true })
+      );
+
+      const results = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+
+          const makeEntry = (v: number) => ({
+            transaction: { id: `tx-${v}`, ops: [], timestamp: Date.now() },
+            version: v,
+            timestamp: Date.now(),
+          });
+
+          // First 3 appends succeed
+          const r1 = yield* Effect.either(hot.append("doc", makeEntry(1)));
+          const r2 = yield* Effect.either(hot.append("doc", makeEntry(2)));
+          const r3 = yield* Effect.either(hot.append("doc", makeEntry(3)));
+
+          // Fourth append fails
+          const r4 = yield* Effect.either(hot.append("doc", makeEntry(4)));
+
+          return { r1, r2, r3, r4 };
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(results.r1._tag).toBe("Right");
+      expect(results.r2._tag).toBe("Right");
+      expect(results.r3._tag).toBe("Right");
+      expect(results.r4._tag).toBe("Left");
+    });
+  });
+
+  describe("Custom Error Messages", () => {
+    it("ColdStorage uses custom error message", async () => {
+      const failingLayer = Layer.mergeAll(
+        FailingStorage.makeColdStorage({
+          failLoad: true,
+          errorMessage: "Database connection timeout",
+        }),
+        HotStorage.InMemory.make()
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const cold = yield* ColdStorageTag;
+          return yield* Effect.either(cold.load("test-doc"));
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left.cause).toBeInstanceOf(Error);
+        expect((result.left.cause as Error).message).toBe(
+          "Database connection timeout"
+        );
+      }
+    });
+
+    it("HotStorage uses custom error message", async () => {
+      const failingLayer = Layer.mergeAll(
+        ColdStorage.InMemory.make(),
+        FailingStorage.makeHotStorage({
+          failAppend: true,
+          errorMessage: "Redis cluster unavailable",
+        })
+      );
+
+      const result = await Effect.runPromise(
+        Effect.gen(function* () {
+          const hot = yield* HotStorageTag;
+          return yield* Effect.either(
+            hot.append("test-doc", {
+              transaction: { id: "tx", ops: [], timestamp: Date.now() },
+              version: 1,
+              timestamp: Date.now(),
+            })
+          );
+        }).pipe(Effect.provide(failingLayer))
+      );
+
+      expect(result._tag).toBe("Left");
+      if (result._tag === "Left") {
+        expect(result.left.cause).toBeInstanceOf(Error);
+        expect((result.left.cause as Error).message).toBe(
+          "Redis cluster unavailable"
+        );
+      }
+    });
+  });
+});

package/tsdown.config.ts

@@ -1,6 +1,6 @@
 import { defineConfig } from "tsdown";
 
-export const input = ["./src/index.ts"];
+export const input = ["./src/index.ts", "./src/testing/index.ts"];
 
 export default defineConfig({
 	target: ["es2017"],

package/dist/DocumentManager.cjs

@@ -1,229 +0,0 @@
-const require_ColdStorage = require('./ColdStorage.cjs');
-const require_HotStorage = require('./HotStorage.cjs');
-const require_Metrics = require('./Metrics.cjs');
-let effect = require("effect");
-let _voidhash_mimic_server = require("@voidhash/mimic/server");
-
-//#region src/DocumentManager.ts
-/**
-* @voidhash/mimic-effect - DocumentManager
-*
-* Internal service for managing document lifecycle, including:
-* - Document creation and restoration
-* - Transaction processing
-* - WAL management
-* - Snapshot scheduling
-* - Idle document GC
-*/
-/**
-* Context tag for DocumentManager service
-*/
-var DocumentManagerTag = class extends effect.Context.Tag("@voidhash/mimic-effect/DocumentManager")() {};
-/**
-* Context tag for DocumentManager configuration
-*/
-var DocumentManagerConfigTag = class extends effect.Context.Tag("@voidhash/mimic-effect/DocumentManagerConfig")() {};
-/**
-* Create the DocumentManager layer.
-* Requires ColdStorage, HotStorage, and DocumentManagerConfig.
-*/
-const layer = effect.Layer.scoped(DocumentManagerTag, effect.Effect.gen(function* () {
-	const coldStorage = yield* require_ColdStorage.ColdStorageTag;
-	const hotStorage = yield* require_HotStorage.HotStorageTag;
-	const config = yield* DocumentManagerConfigTag;
-	const store = yield* effect.Ref.make(effect.HashMap.empty());
-	const SCHEMA_VERSION = 1;
-	/**
-	* Compute initial state for a new document
-	*/
-	const computeInitialState = (documentId) => {
-		if (config.initial === void 0) return effect.Effect.succeed(void 0);
-		if (typeof config.initial === "function") return config.initial({ documentId });
-		return effect.Effect.succeed(config.initial);
-	};
-	/**
-	* Restore a document from storage
-	*/
-	const restoreDocument = (documentId) => effect.Effect.gen(function* () {
-		const storedDoc = yield* effect.Effect.catchAll(coldStorage.load(documentId), () => effect.Effect.succeed(void 0));
-		let initialState;
-		let initialVersion = 0;
-		if (storedDoc) {
-			initialState = storedDoc.state;
-			initialVersion = storedDoc.version;
-		} else initialState = yield* computeInitialState(documentId);
-		const pubsub = yield* effect.PubSub.unbounded();
-		const lastSnapshotVersion = yield* effect.Ref.make(initialVersion);
-		const lastSnapshotTime = yield* effect.Ref.make(Date.now());
-		const transactionsSinceSnapshot = yield* effect.Ref.make(0);
-		const lastActivityTime = yield* effect.Ref.make(Date.now());
-		const document = _voidhash_mimic_server.ServerDocument.make({
-			schema: config.schema,
-			initialState,
-			initialVersion,
-			maxTransactionHistory: config.maxTransactionHistory,
-			onBroadcast: (message) => {
-				effect.Effect.runSync(effect.PubSub.publish(pubsub, {
-					type: "transaction",
-					transaction: message.transaction,
-					version: message.version
-				}));
-			},
-			onRejection: (transactionId, reason) => {
-				effect.Effect.runSync(effect.PubSub.publish(pubsub, {
-					type: "error",
-					transactionId,
-					reason
-				}));
-			}
-		});
-		const walEntries = yield* effect.Effect.catchAll(hotStorage.getEntries(documentId, initialVersion), () => effect.Effect.succeed([]));
-		for (const entry of walEntries) {
-			const result = document.submit(entry.transaction);
-			if (!result.success) yield* effect.Effect.logWarning("Skipping corrupted WAL entry", {
-				documentId,
-				version: entry.version,
-				reason: result.reason
-			});
-		}
-		const instance = {
-			document,
-			pubsub,
-			lastSnapshotVersion,
-			lastSnapshotTime,
-			transactionsSinceSnapshot,
-			lastActivityTime
-		};
-		if (storedDoc) yield* effect.Metric.increment(require_Metrics.documentsRestored);
-		else yield* effect.Metric.increment(require_Metrics.documentsCreated);
-		yield* effect.Metric.incrementBy(require_Metrics.documentsActive, 1);
-		return instance;
-	});
-	/**
-	* Get or create a document instance
-	*/
-	const getOrCreateDocument = (documentId) => effect.Effect.gen(function* () {
-		const current = yield* effect.Ref.get(store);
-		const existing = effect.HashMap.get(current, documentId);
-		if (existing._tag === "Some") {
-			yield* effect.Ref.set(existing.value.lastActivityTime, Date.now());
-			return existing.value;
-		}
-		const instance = yield* restoreDocument(documentId);
-		yield* effect.Ref.update(store, (map) => effect.HashMap.set(map, documentId, instance));
-		return instance;
-	});
-	/**
-	* Save a snapshot to ColdStorage and truncate WAL
-	*/
-	const saveSnapshot = (documentId, instance) => effect.Effect.gen(function* () {
-		const state = instance.document.get();
-		const version = instance.document.getVersion();
-		if (state === void 0) return;
-		const storedDoc = {
-			state,
-			version,
-			schemaVersion: SCHEMA_VERSION,
-			savedAt: Date.now()
-		};
-		const snapshotStartTime = Date.now();
-		yield* effect.Effect.catchAll(coldStorage.save(documentId, storedDoc), (e) => effect.Effect.logError("Failed to save snapshot", {
-			documentId,
-			error: e
-		}));
-		const snapshotDuration = Date.now() - snapshotStartTime;
-		yield* effect.Metric.increment(require_Metrics.storageSnapshots);
-		yield* effect.Metric.update(require_Metrics.storageSnapshotLatency, snapshotDuration);
-		yield* effect.Effect.catchAll(hotStorage.truncate(documentId, version), (e) => effect.Effect.logError("Failed to truncate WAL", {
-			documentId,
-			error: e
-		}));
-		yield* effect.Ref.set(instance.lastSnapshotVersion, version);
-		yield* effect.Ref.set(instance.lastSnapshotTime, Date.now());
-		yield* effect.Ref.set(instance.transactionsSinceSnapshot, 0);
-	});
-	/**
-	* Check if snapshot should be triggered
-	*/
-	const checkSnapshotTriggers = (documentId, instance) => effect.Effect.gen(function* () {
-		const txCount = yield* effect.Ref.get(instance.transactionsSinceSnapshot);
-		const lastTime = yield* effect.Ref.get(instance.lastSnapshotTime);
-		const now = Date.now();
-		const intervalMs = effect.Duration.toMillis(config.snapshot.interval);
-		if (txCount >= config.snapshot.transactionThreshold) {
-			yield* saveSnapshot(documentId, instance);
-			return;
-		}
-		if (now - lastTime >= intervalMs) {
-			yield* saveSnapshot(documentId, instance);
-			return;
-		}
-	});
-	yield* effect.Effect.gen(function* () {
-		yield* effect.Effect.gen(function* () {
-			const current = yield* effect.Ref.get(store);
-			const now = Date.now();
-			const maxIdleMs = effect.Duration.toMillis(config.maxIdleTime);
-			for (const [documentId, instance] of current) if (now - (yield* effect.Ref.get(instance.lastActivityTime)) >= maxIdleMs) {
-				yield* saveSnapshot(documentId, instance);
-				yield* effect.Ref.update(store, (map) => effect.HashMap.remove(map, documentId));
-				yield* effect.Metric.increment(require_Metrics.documentsEvicted);
-				yield* effect.Metric.incrementBy(require_Metrics.documentsActive, -1);
-				yield* effect.Effect.logInfo("Document evicted due to idle timeout", { documentId });
-			}
-		}).pipe(effect.Effect.repeat(effect.Schedule.spaced("1 minute")), effect.Effect.fork);
-	});
-	yield* effect.Effect.addFinalizer(() => effect.Effect.gen(function* () {
-		const current = yield* effect.Ref.get(store);
-		for (const [documentId, instance] of current) yield* saveSnapshot(documentId, instance);
-		yield* effect.Effect.logInfo("DocumentManager shutdown complete");
-	}));
-	return {
-		submit: (documentId, transaction) => effect.Effect.gen(function* () {
-			const instance = yield* getOrCreateDocument(documentId);
-			const submitStartTime = Date.now();
-			const result = instance.document.submit(transaction);
-			const latency = Date.now() - submitStartTime;
-			yield* effect.Metric.update(require_Metrics.transactionsLatency, latency);
-			if (result.success) {
-				yield* effect.Metric.increment(require_Metrics.transactionsProcessed);
-				const walEntry = {
-					transaction,
-					version: result.version,
-					timestamp: Date.now()
-				};
-				yield* effect.Effect.catchAll(hotStorage.append(documentId, walEntry), (e) => effect.Effect.logError("Failed to append to WAL", {
-					documentId,
-					error: e
-				}));
-				yield* effect.Metric.increment(require_Metrics.storageWalAppends);
-				yield* effect.Ref.update(instance.transactionsSinceSnapshot, (n) => n + 1);
-				yield* checkSnapshotTriggers(documentId, instance);
-			} else yield* effect.Metric.increment(require_Metrics.transactionsRejected);
-			return result;
-		}),
-		getSnapshot: (documentId) => effect.Effect.gen(function* () {
-			return (yield* getOrCreateDocument(documentId)).document.getSnapshot();
-		}),
-		subscribe: (documentId) => effect.Effect.gen(function* () {
-			const instance = yield* getOrCreateDocument(documentId);
-			return effect.Stream.fromPubSub(instance.pubsub);
-		}),
-		touch: (documentId) => effect.Effect.gen(function* () {
-			const current = yield* effect.Ref.get(store);
-			const existing = effect.HashMap.get(current, documentId);
-			if (existing._tag === "Some") yield* effect.Ref.set(existing.value.lastActivityTime, Date.now());
-		})
-	};
-}));
-const DocumentManager = {
-	Tag: DocumentManagerTag,
-	ConfigTag: DocumentManagerConfigTag,
-	layer
-};
-
-//#endregion
-exports.DocumentManager = DocumentManager;
-exports.DocumentManagerConfigTag = DocumentManagerConfigTag;
-exports.DocumentManagerTag = DocumentManagerTag;
-exports.layer = layer;

package/dist/DocumentManager.d.cts

@@ -1,59 +0,0 @@
-import { ResolvedConfig } from "./Types.cjs";
-import { ServerBroadcast, SnapshotMessage } from "./Protocol.cjs";
-import { ColdStorageTag } from "./ColdStorage.cjs";
-import { HotStorageTag } from "./HotStorage.cjs";
-import { Context, Effect, Layer, Scope, Stream } from "effect";
-import { Transaction } from "@voidhash/mimic";
-
-//#region src/DocumentManager.d.ts
-
-/**
- * Result of submitting a transaction
- */
-type SubmitResult = {
-  readonly success: true;
-  readonly version: number;
-} | {
-  readonly success: false;
-  readonly reason: string;
-};
-/**
- * Internal service for managing document lifecycle.
- */
-interface DocumentManager {
-  /**
-   * Submit a transaction to a document.
-   */
-  readonly submit: (documentId: string, transaction: Transaction.Transaction) => Effect.Effect<SubmitResult>;
-  /**
-   * Get a snapshot of a document.
-   */
-  readonly getSnapshot: (documentId: string) => Effect.Effect<SnapshotMessage>;
-  /**
-   * Subscribe to broadcasts for a document.
-   */
-  readonly subscribe: (documentId: string) => Effect.Effect<Stream.Stream<ServerBroadcast>, never, Scope.Scope>;
-  /**
-   * Touch a document to update its last activity time.
-   * Call this on any client activity to prevent idle GC.
-   */
-  readonly touch: (documentId: string) => Effect.Effect<void>;
-}
-declare const DocumentManagerTag_base: Context.TagClass<DocumentManagerTag, "@voidhash/mimic-effect/DocumentManager", DocumentManager>;
-/**
- * Context tag for DocumentManager service
- */
-declare class DocumentManagerTag extends DocumentManagerTag_base {}
-declare const DocumentManagerConfigTag_base: Context.TagClass<DocumentManagerConfigTag, "@voidhash/mimic-effect/DocumentManagerConfig", ResolvedConfig<Primitive.AnyPrimitive>>;
-/**
- * Context tag for DocumentManager configuration
- */
-declare class DocumentManagerConfigTag extends DocumentManagerConfigTag_base {}
-declare const DocumentManager: {
-  Tag: typeof DocumentManagerTag;
-  ConfigTag: typeof DocumentManagerConfigTag;
-  layer: Layer.Layer<DocumentManagerTag, never, ColdStorageTag | HotStorageTag | DocumentManagerConfigTag>;
-};
-//#endregion
-export { DocumentManager, DocumentManagerConfigTag, DocumentManagerTag, SubmitResult };
-//# sourceMappingURL=DocumentManager.d.cts.map