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

package/dist/DocumentManager.cjs

@@ -1,118 +1,299 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
-const require_MimicConfig = require('./MimicConfig.cjs');
-const require_MimicDataStorage = require('./MimicDataStorage.cjs');
-let effect_Effect = require("effect/Effect");
-effect_Effect = require_rolldown_runtime.__toESM(effect_Effect);
-let effect_Layer = require("effect/Layer");
-effect_Layer = require_rolldown_runtime.__toESM(effect_Layer);
-let effect_PubSub = require("effect/PubSub");
-effect_PubSub = require_rolldown_runtime.__toESM(effect_PubSub);
-let effect_Ref = require("effect/Ref");
-effect_Ref = require_rolldown_runtime.__toESM(effect_Ref);
-let effect_HashMap = require("effect/HashMap");
-effect_HashMap = require_rolldown_runtime.__toESM(effect_HashMap);
-let effect_Context = require("effect/Context");
-effect_Context = require_rolldown_runtime.__toESM(effect_Context);
-let effect_Stream = require("effect/Stream");
-effect_Stream = require_rolldown_runtime.__toESM(effect_Stream);
+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 = require("@voidhash/mimic");
 let _voidhash_mimic_server = require("@voidhash/mimic/server");
 
 //#region src/DocumentManager.ts
 /**
-* @since 0.0.1
-* Document manager that handles multiple document instances.
+* @voidhash/mimic-effect - DocumentManager
+*
+* Internal service for managing document lifecycle, including:
+* - Document creation and restoration
+* - Transaction processing
+* - WAL management
+* - Snapshot scheduling
+* - Idle document GC
 */
-var DocumentManager_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
-	DocumentManagerTag: () => DocumentManagerTag,
-	layer: () => layer
-});
 /**
-* Context tag for DocumentManager.
+* Context tag for DocumentManager service
 */
-var DocumentManagerTag = class extends effect_Context.Tag("@voidhash/mimic-server-effect/DocumentManager")() {};
+var DocumentManagerTag = class extends effect.Context.Tag("@voidhash/mimic-effect/DocumentManager")() {};
 /**
-* Create the DocumentManager service.
+* Context tag for DocumentManager configuration
 */
-const makeDocumentManager = effect_Effect.gen(function* () {
-	const config = yield* require_MimicConfig.MimicServerConfigTag;
-	const storage = yield* require_MimicDataStorage.MimicDataStorageTag;
-	const documents = yield* effect_Ref.make(effect_HashMap.empty());
-	const getOrCreateDocument = (documentId) => effect_Effect.gen(function* () {
-		const current = yield* effect_Ref.get(documents);
-		const existing = effect_HashMap.get(current, documentId);
-		if (existing._tag === "Some") {
-			yield* effect_Ref.update(existing.value.refCount, (n) => n + 1);
-			return existing.value;
-		}
-		const rawState = yield* effect_Effect.catchAll(storage.load(documentId), () => effect_Effect.succeed(void 0));
-		const initialState = rawState !== void 0 ? yield* storage.onLoad(rawState) : config.initial !== void 0 ? yield* config.initial({ documentId }) : void 0;
-		const pubsub = yield* effect_PubSub.unbounded();
-		const serverDocument = _voidhash_mimic_server.ServerDocument.make({
+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* coldStorage.load(documentId);
+		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: (transactionMessage) => {
-				const currentState = serverDocument.get();
-				effect_Effect.runFork(effect_Effect.gen(function* () {
-					if (currentState !== void 0) {
-						const transformedState = yield* storage.onSave(currentState);
-						yield* effect_Effect.catchAll(storage.save(documentId, transformedState), (error) => effect_Effect.logError("Failed to save document", error));
-					}
-				}));
-				effect_Effect.runSync(effect_PubSub.publish(pubsub, {
+			onBroadcast: (message) => {
+				effect.Effect.runSync(effect.PubSub.publish(pubsub, {
 					type: "transaction",
-					transaction: transactionMessage.transaction,
-					version: transactionMessage.version
+					transaction: message.transaction,
+					version: message.version
 				}));
 			},
 			onRejection: (transactionId, reason) => {
-				effect_Effect.runSync(effect_PubSub.publish(pubsub, {
+				effect.Effect.runSync(effect.PubSub.publish(pubsub, {
 					type: "error",
 					transactionId,
 					reason
 				}));
 			}
 		});
+		const walEntries = yield* hotStorage.getEntries(documentId, initialVersion);
+		if (walEntries.length > 0) {
+			const firstWalVersion = walEntries[0].version;
+			const expectedFirst = initialVersion + 1;
+			if (firstWalVersion !== expectedFirst) {
+				yield* effect.Effect.logWarning("WAL version gap detected", {
+					documentId,
+					snapshotVersion: initialVersion,
+					firstWalVersion,
+					expectedFirst
+				});
+				yield* effect.Metric.increment(require_Metrics.storageVersionGaps);
+			}
+			for (let i = 1; i < walEntries.length; i++) {
+				const prev = walEntries[i - 1].version;
+				const curr = walEntries[i].version;
+				if (curr !== prev + 1) yield* effect.Effect.logWarning("WAL internal gap detected", {
+					documentId,
+					previousVersion: prev,
+					currentVersion: curr
+				});
+			}
+		}
+		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: serverDocument,
+			document,
 			pubsub,
-			refCount: yield* effect_Ref.make(1)
+			lastSnapshotVersion,
+			lastSnapshotTime,
+			transactionsSinceSnapshot,
+			lastActivityTime
 		};
-		yield* effect_Ref.update(documents, (map) => effect_HashMap.set(map, documentId, instance));
+		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;
 	});
-	const submit = (documentId, transaction) => effect_Effect.gen(function* () {
-		return (yield* getOrCreateDocument(documentId)).document.submit(transaction);
-	});
-	const getSnapshot = (documentId) => effect_Effect.gen(function* () {
-		return (yield* getOrCreateDocument(documentId)).document.getSnapshot();
+	/**
+	* 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;
 	});
-	const subscribe = (documentId) => effect_Effect.gen(function* () {
-		const instance = yield* getOrCreateDocument(documentId);
-		const queue = yield* effect_PubSub.subscribe(instance.pubsub);
-		yield* effect_Effect.addFinalizer(() => effect_Effect.gen(function* () {
-			yield* effect_Ref.updateAndGet(instance.refCount, (n) => n - 1);
+	/**
+	* Save a snapshot to ColdStorage derived from WAL entries.
+	* This ensures snapshots are always based on durable WAL data.
+	* Idempotent: skips save if already snapshotted at target version.
+	* Truncate failures are non-fatal and will be retried on next snapshot.
+	*/
+	const saveSnapshot = (documentId, instance, targetVersion) => effect.Effect.gen(function* () {
+		var _baseSnapshot$version;
+		if (targetVersion <= (yield* effect.Ref.get(instance.lastSnapshotVersion))) return;
+		const snapshotStartTime = Date.now();
+		const baseSnapshot = yield* coldStorage.load(documentId);
+		const baseVersion = (_baseSnapshot$version = baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.version) !== null && _baseSnapshot$version !== void 0 ? _baseSnapshot$version : 0;
+		const baseState = baseSnapshot === null || baseSnapshot === void 0 ? void 0 : baseSnapshot.state;
+		const relevantEntries = (yield* hotStorage.getEntries(documentId, baseVersion)).filter((e) => e.version <= targetVersion);
+		if (relevantEntries.length === 0 && !baseSnapshot) return;
+		let snapshotState = baseState;
+		for (const entry of relevantEntries) {
+			const tempDoc = _voidhash_mimic.Document.make(config.schema, { initialState: snapshotState });
+			tempDoc.apply(entry.transaction.ops);
+			snapshotState = tempDoc.get();
+		}
+		if (snapshotState === void 0) return;
+		const snapshotVersion = relevantEntries.length > 0 ? relevantEntries[relevantEntries.length - 1].version : baseVersion;
+		if (snapshotVersion <= (yield* effect.Ref.get(instance.lastSnapshotVersion))) return;
+		const storedDoc = {
+			state: snapshotState,
+			version: snapshotVersion,
+			schemaVersion: SCHEMA_VERSION,
+			savedAt: Date.now()
+		};
+		yield* coldStorage.save(documentId, storedDoc);
+		const snapshotDuration = Date.now() - snapshotStartTime;
+		yield* effect.Metric.increment(require_Metrics.storageSnapshots);
+		yield* effect.Metric.update(require_Metrics.storageSnapshotLatency, snapshotDuration);
+		yield* effect.Ref.set(instance.lastSnapshotVersion, snapshotVersion);
+		yield* effect.Ref.set(instance.lastSnapshotTime, Date.now());
+		yield* effect.Ref.set(instance.transactionsSinceSnapshot, 0);
+		yield* effect.Effect.catchAll(hotStorage.truncate(documentId, snapshotVersion), (e) => effect.Effect.logWarning("WAL truncate failed - will retry on next snapshot", {
+			documentId,
+			version: snapshotVersion,
+			error: e
 		}));
-		return effect_Stream.fromQueue(queue);
 	});
+	/**
+	* 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 currentVersion = instance.document.getVersion();
+		const intervalMs = effect.Duration.toMillis(config.snapshot.interval);
+		if (txCount >= config.snapshot.transactionThreshold) {
+			yield* saveSnapshot(documentId, instance, currentVersion);
+			return;
+		}
+		if (now - lastTime >= intervalMs) {
+			yield* saveSnapshot(documentId, instance, currentVersion);
+			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) {
+				const currentVersion = instance.document.getVersion();
+				yield* effect.Effect.catchAll(saveSnapshot(documentId, instance, currentVersion), (e) => effect.Effect.logError("Failed to save snapshot during eviction", {
+					documentId,
+					error: e
+				}));
+				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) {
+			const currentVersion = instance.document.getVersion();
+			yield* effect.Effect.catchAll(saveSnapshot(documentId, instance, currentVersion), (e) => effect.Effect.logError("Failed to save snapshot during shutdown", {
+				documentId,
+				error: e
+			}));
+		}
+		yield* effect.Effect.logInfo("DocumentManager shutdown complete");
+	}));
 	return {
-		submit,
-		getSnapshot,
-		subscribe
+		submit: (documentId, transaction) => effect.Effect.gen(function* () {
+			const instance = yield* getOrCreateDocument(documentId);
+			const submitStartTime = Date.now();
+			const validation = instance.document.validate(transaction);
+			if (!validation.valid) {
+				yield* effect.Metric.increment(require_Metrics.transactionsRejected);
+				const latency$1 = Date.now() - submitStartTime;
+				yield* effect.Metric.update(require_Metrics.transactionsLatency, latency$1);
+				return {
+					success: false,
+					reason: validation.reason
+				};
+			}
+			const walEntry = {
+				transaction,
+				version: validation.nextVersion,
+				timestamp: Date.now()
+			};
+			const appendResult = yield* effect.Effect.either(hotStorage.appendWithCheck(documentId, walEntry, validation.nextVersion));
+			if (appendResult._tag === "Left") {
+				yield* effect.Effect.logError("WAL append failed", {
+					documentId,
+					version: validation.nextVersion,
+					error: appendResult.left
+				});
+				yield* effect.Metric.increment(require_Metrics.walAppendFailures);
+				const latency$1 = Date.now() - submitStartTime;
+				yield* effect.Metric.update(require_Metrics.transactionsLatency, latency$1);
+				return {
+					success: false,
+					reason: "Storage unavailable. Please retry."
+				};
+			}
+			instance.document.apply(transaction);
+			const latency = Date.now() - submitStartTime;
+			yield* effect.Metric.update(require_Metrics.transactionsLatency, latency);
+			yield* effect.Metric.increment(require_Metrics.transactionsProcessed);
+			yield* effect.Metric.increment(require_Metrics.storageWalAppends);
+			yield* effect.Ref.update(instance.transactionsSinceSnapshot, (n) => n + 1);
+			yield* checkSnapshotTriggers(documentId, instance);
+			return {
+				success: true,
+				version: validation.nextVersion
+			};
+		}),
+		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());
+		})
 	};
-});
-/**
-* Layer that provides DocumentManager.
-* Requires MimicServerConfigTag and MimicDataStorageTag.
-*/
-const layer = effect_Layer.effect(DocumentManagerTag, makeDocumentManager);
+}));
+const DocumentManager = {
+	Tag: DocumentManagerTag,
+	ConfigTag: DocumentManagerConfigTag,
+	layer
+};
 
 //#endregion
+exports.DocumentManager = DocumentManager;
+exports.DocumentManagerConfigTag = DocumentManagerConfigTag;
 exports.DocumentManagerTag = DocumentManagerTag;
-Object.defineProperty(exports, 'DocumentManager_exports', {
-  enumerable: true,
-  get: function () {
-    return DocumentManager_exports;
-  }
-});
 exports.layer = layer;

package/dist/DocumentManager.d.cts

@@ -1,45 +1,67 @@
-import { ServerBroadcast, SnapshotMessage, SubmitResult } from "./DocumentProtocol.cjs";
-import { MimicServerConfigTag } from "./MimicConfig.cjs";
-import { MimicDataStorageTag } from "./MimicDataStorage.cjs";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
+import { ResolvedConfig } from "./Types.cjs";
+import { ColdStorageError, HotStorageError } from "./Errors.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";
-import * as Context from "effect/Context";
-import * as Scope from "effect/Scope";
-import * as Stream from "effect/Stream";
 
 //#region src/DocumentManager.d.ts
-declare namespace DocumentManager_d_exports {
-  export { DocumentManager, DocumentManagerTag, layer };
-}
+
+/**
+ * Result of submitting a transaction
+ */
+type SubmitResult = {
+  readonly success: true;
+  readonly version: number;
+} | {
+  readonly success: false;
+  readonly reason: string;
+};
 /**
- * Service interface for the DocumentManager.
+ * Error type for DocumentManager operations
+ */
+type DocumentManagerError = ColdStorageError | HotStorageError;
+/**
+ * Internal service for managing document lifecycle.
  */
 interface DocumentManager {
   /**
    * Submit a transaction to a document.
+   * May fail with ColdStorageError or HotStorageError if storage is unavailable.
    */
-  readonly submit: (documentId: string, transaction: Transaction.Transaction) => Effect.Effect<SubmitResult>;
+  readonly submit: (documentId: string, transaction: Transaction.Transaction) => Effect.Effect<SubmitResult, DocumentManagerError>;
   /**
    * Get a snapshot of a document.
+   * May fail with ColdStorageError or HotStorageError if storage is unavailable.
    */
-  readonly getSnapshot: (documentId: string) => Effect.Effect<SnapshotMessage>;
+  readonly getSnapshot: (documentId: string) => Effect.Effect<SnapshotMessage, DocumentManagerError>;
   /**
    * Subscribe to broadcasts for a document.
-   * Returns a Stream of server broadcasts.
+   * May fail with ColdStorageError or HotStorageError if storage is unavailable.
+   */
+  readonly subscribe: (documentId: string) => Effect.Effect<Stream.Stream<ServerBroadcast>, DocumentManagerError, Scope.Scope>;
+  /**
+   * Touch a document to update its last activity time.
+   * Call this on any client activity to prevent idle GC.
    */
-  readonly subscribe: (documentId: string) => Effect.Effect<Stream.Stream<ServerBroadcast>, never, Scope.Scope>;
+  readonly touch: (documentId: string) => Effect.Effect<void>;
 }
-declare const DocumentManagerTag_base: Context.TagClass<DocumentManagerTag, "@voidhash/mimic-server-effect/DocumentManager", DocumentManager>;
+declare const DocumentManagerTag_base: Context.TagClass<DocumentManagerTag, "@voidhash/mimic-effect/DocumentManager", DocumentManager>;
 /**
- * Context tag for 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>>;
 /**
- * Layer that provides DocumentManager.
- * Requires MimicServerConfigTag and MimicDataStorageTag.
+ * Context tag for DocumentManager configuration
  */
-declare const layer: Layer.Layer<DocumentManagerTag, never, MimicServerConfigTag | MimicDataStorageTag>;
+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 { DocumentManagerTag, DocumentManager_d_exports };
+export { DocumentManager, DocumentManagerConfigTag, DocumentManagerError, DocumentManagerTag, SubmitResult };
 //# sourceMappingURL=DocumentManager.d.cts.map

package/dist/DocumentManager.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"DocumentManager.d.cts","names":[],"sources":["../src/DocumentManager.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;UA2CiB,eAAA;EAAA;;;EAOV,SAAO,MAAA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,WAAA,EADG,WAAA,CAAY,WACf,EAAA,GAAP,MAAA,CAAO,MAAA,CAAO,YAAP,CAAA;EAOO;;;EASjB,SAAO,WAAA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,GATJ,MAAA,CAAO,MASH,CATU,eASV,CAAA;EAEP;;;AAEH;8CALM,MAAA,CAAO,OACV,MAAA,CAAO,OAAO,yBAEd,KAAA,CAAM;;cAET;;AAKD;AA8KA;AACE,cA/KW,kBAAA,SAA2B,uBAAA,CA+KtC;;;;;cADW,OAAO,KAAA,CAAM,MACxB,2BAEA,uBAAuB"}
+{"version":3,"file":"DocumentManager.d.cts","names":[],"sources":["../src/DocumentManager.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;AAiFqB,KAtCT,YAAA,GAsCgB;EAAyB,SAAA,OAAA,EAAA,IAAA;EAAsB,SAAM,OAAA,EAAA,MAAA;CAA1E,GAAA;EAMmC,SAAO,OAAA,EAAA,KAAA;EAAM,SAAA,MAAA,EAAA,MAAA;AACtD,CAAA;;;;KAlCW,oBAAA,GAAuB,mBAAmB;AA2CtD;AAE2C;;UAxC1B,eAAA;;;;AAuEjB;EA+da,SAAA,MAAA,EAAA,CAIZ,UAAA,EAAA,MAAA,EAAA,WAAA,EAniBgB,WAAA,CAAY,WAmiB5B,EAAA,GAliBM,MAAA,CAAO,MAkiBb,CAliBoB,YAkiBpB,EAliBkC,oBAkiBlC,CAAA;;;;;gDA5hB+C,MAAA,CAAO,OAAO,iBAAiB;;;;;8CAQxE,MAAA,CAAO,OAAO,MAAA,CAAO,OAAO,kBAAkB,sBAAsB,KAAA,CAAM;;;;;0CAMvC,MAAA,CAAO;;cAChD;;;;cASY,kBAAA,SAA2B,uBAAA;cAEG;;;;cA+B9B,wBAAA,SAAiC,6BAAA;cA+djC"}

package/dist/DocumentManager.d.mts

@@ -1,45 +1,67 @@
-import { ServerBroadcast, SnapshotMessage, SubmitResult } from "./DocumentProtocol.mjs";
-import { MimicServerConfigTag } from "./MimicConfig.mjs";
-import { MimicDataStorageTag } from "./MimicDataStorage.mjs";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as Context from "effect/Context";
-import * as Stream from "effect/Stream";
+import { ResolvedConfig } from "./Types.mjs";
+import { ColdStorageError, HotStorageError } from "./Errors.mjs";
+import { ServerBroadcast, SnapshotMessage } from "./Protocol.mjs";
+import { ColdStorageTag } from "./ColdStorage.mjs";
+import { HotStorageTag } from "./HotStorage.mjs";
+import { Context, Effect, Layer, Scope, Stream } from "effect";
 import { Transaction } from "@voidhash/mimic";
-import * as Scope from "effect/Scope";
 
 //#region src/DocumentManager.d.ts
-declare namespace DocumentManager_d_exports {
-  export { DocumentManager, DocumentManagerTag, layer };
-}
+
+/**
+ * Result of submitting a transaction
+ */
+type SubmitResult = {
+  readonly success: true;
+  readonly version: number;
+} | {
+  readonly success: false;
+  readonly reason: string;
+};
 /**
- * Service interface for the DocumentManager.
+ * Error type for DocumentManager operations
+ */
+type DocumentManagerError = ColdStorageError | HotStorageError;
+/**
+ * Internal service for managing document lifecycle.
  */
 interface DocumentManager {
   /**
    * Submit a transaction to a document.
+   * May fail with ColdStorageError or HotStorageError if storage is unavailable.
    */
-  readonly submit: (documentId: string, transaction: Transaction.Transaction) => Effect.Effect<SubmitResult>;
+  readonly submit: (documentId: string, transaction: Transaction.Transaction) => Effect.Effect<SubmitResult, DocumentManagerError>;
   /**
    * Get a snapshot of a document.
+   * May fail with ColdStorageError or HotStorageError if storage is unavailable.
    */
-  readonly getSnapshot: (documentId: string) => Effect.Effect<SnapshotMessage>;
+  readonly getSnapshot: (documentId: string) => Effect.Effect<SnapshotMessage, DocumentManagerError>;
   /**
    * Subscribe to broadcasts for a document.
-   * Returns a Stream of server broadcasts.
+   * May fail with ColdStorageError or HotStorageError if storage is unavailable.
+   */
+  readonly subscribe: (documentId: string) => Effect.Effect<Stream.Stream<ServerBroadcast>, DocumentManagerError, Scope.Scope>;
+  /**
+   * Touch a document to update its last activity time.
+   * Call this on any client activity to prevent idle GC.
    */
-  readonly subscribe: (documentId: string) => Effect.Effect<Stream.Stream<ServerBroadcast>, never, Scope.Scope>;
+  readonly touch: (documentId: string) => Effect.Effect<void>;
 }
-declare const DocumentManagerTag_base: Context.TagClass<DocumentManagerTag, "@voidhash/mimic-server-effect/DocumentManager", DocumentManager>;
+declare const DocumentManagerTag_base: Context.TagClass<DocumentManagerTag, "@voidhash/mimic-effect/DocumentManager", DocumentManager>;
 /**
- * Context tag for 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>>;
 /**
- * Layer that provides DocumentManager.
- * Requires MimicServerConfigTag and MimicDataStorageTag.
+ * Context tag for DocumentManager configuration
  */
-declare const layer: Layer.Layer<DocumentManagerTag, never, MimicServerConfigTag | MimicDataStorageTag>;
+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 { DocumentManagerTag, DocumentManager_d_exports };
+export { DocumentManager, DocumentManagerConfigTag, DocumentManagerError, DocumentManagerTag, SubmitResult };
 //# sourceMappingURL=DocumentManager.d.mts.map

package/dist/DocumentManager.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"DocumentManager.d.mts","names":[],"sources":["../src/DocumentManager.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;UA2CiB,eAAA;EAAA;;;EAOV,SAAO,MAAA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,WAAA,EADG,WAAA,CAAY,WACf,EAAA,GAAP,MAAA,CAAO,MAAA,CAAO,YAAP,CAAA;EAOO;;;EASjB,SAAO,WAAA,EAAA,CAAA,UAAA,EAAA,MAAA,EAAA,GATJ,MAAA,CAAO,MASH,CATU,eASV,CAAA;EAEP;;;AAEH;8CALM,MAAA,CAAO,OACV,MAAA,CAAO,OAAO,yBAEd,KAAA,CAAM;;cAET;;AAKD;AA8KA;AACE,cA/KW,kBAAA,SAA2B,uBAAA,CA+KtC;;;;;cADW,OAAO,KAAA,CAAM,MACxB,2BAEA,uBAAuB"}
+{"version":3,"file":"DocumentManager.d.mts","names":[],"sources":["../src/DocumentManager.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;AAiFqB,KAtCT,YAAA,GAsCgB;EAAyB,SAAA,OAAA,EAAA,IAAA;EAAsB,SAAM,OAAA,EAAA,MAAA;CAA1E,GAAA;EAMmC,SAAO,OAAA,EAAA,KAAA;EAAM,SAAA,MAAA,EAAA,MAAA;AACtD,CAAA;;;;KAlCW,oBAAA,GAAuB,mBAAmB;AA2CtD;AAE2C;;UAxC1B,eAAA;;;;AAuEjB;EA+da,SAAA,MAAA,EAAA,CAIZ,UAAA,EAAA,MAAA,EAAA,WAAA,EAniBgB,WAAA,CAAY,WAmiB5B,EAAA,GAliBM,MAAA,CAAO,MAkiBb,CAliBoB,YAkiBpB,EAliBkC,oBAkiBlC,CAAA;;;;;gDA5hB+C,MAAA,CAAO,OAAO,iBAAiB;;;;;8CAQxE,MAAA,CAAO,OAAO,MAAA,CAAO,OAAO,kBAAkB,sBAAsB,KAAA,CAAM;;;;;0CAMvC,MAAA,CAAO;;cAChD;;;;cASY,kBAAA,SAA2B,uBAAA;cAEG;;;;cA+B9B,wBAAA,SAAiC,6BAAA;cA+djC"}