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

package/dist/MimicAuthService.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"MimicAuthService.mjs","names":[],"sources":["../src/MimicAuthService.ts"],"sourcesContent":["/**\n * @since 0.0.1\n * Authentication service interface for Mimic connections.\n * Provides pluggable authentication adapters.\n */\nimport * as Effect from \"effect/Effect\";\nimport * as Context from \"effect/Context\";\nimport * as Layer from \"effect/Layer\";\n\n// =============================================================================\n// Authentication Types\n// =============================================================================\n\n/**\n * Result of an authentication attempt.\n */\nexport type AuthResult =\n  | { readonly success: true; readonly userId?: string }\n  | { readonly success: false; readonly error: string };\n\n/**\n * Authentication handler function type.\n * Can be synchronous or return a Promise.\n */\nexport type AuthHandler = (token: string) => Promise<AuthResult> | AuthResult;\n\n// =============================================================================\n// Auth Service Interface\n// =============================================================================\n\n/**\n * Authentication service interface.\n * Implementations can authenticate connections using various methods (JWT, API keys, etc.)\n */\nexport interface MimicAuthService {\n  /**\n   * Authenticate a connection using the provided token.\n   * @param token - The authentication token provided by the client\n   * @returns The authentication result\n   */\n  readonly authenticate: (token: string) => Effect.Effect<AuthResult>;\n}\n\n// =============================================================================\n// Context Tag\n// =============================================================================\n\n/**\n * Context tag for MimicAuthService service.\n */\nexport class MimicAuthServiceTag extends Context.Tag(\n  \"@voidhash/mimic-server-effect/MimicAuthService\"\n)<MimicAuthServiceTag, MimicAuthService>() {}\n\n// =============================================================================\n// Layer Constructors\n// =============================================================================\n\n/**\n * Create a MimicAuthService layer from an auth handler function.\n */\nexport const layer = (options: {\n  readonly authHandler: AuthHandler;\n}): Layer.Layer<MimicAuthServiceTag> =>\n  Layer.succeed(MimicAuthServiceTag, {\n    authenticate: (token: string) =>\n      Effect.promise(() => Promise.resolve(options.authHandler(token))),\n  });\n\n/**\n * Create a MimicAuthService layer from an auth service implementation.\n */\nexport const layerService = (service: MimicAuthService): Layer.Layer<MimicAuthServiceTag> =>\n  Layer.succeed(MimicAuthServiceTag, service);\n\n/**\n * Create a MimicAuthService layer from an Effect that produces an auth service.\n */\nexport const layerEffect = <E, R>(\n  effect: Effect.Effect<MimicAuthService, E, R>\n): Layer.Layer<MimicAuthServiceTag, E, R> =>\n  Layer.effect(MimicAuthServiceTag, effect);\n\n// =============================================================================\n// Helper Functions\n// =============================================================================\n\n/**\n * Create an auth service from an auth handler function.\n */\nexport const make = (authHandler: AuthHandler): MimicAuthService => ({\n  authenticate: (token: string) =>\n    Effect.promise(() => Promise.resolve(authHandler(token))),\n});\n\n/**\n * Create an auth service from an Effect-based authenticate function.\n */\nexport const makeEffect = (\n  authenticate: (token: string) => Effect.Effect<AuthResult>\n): MimicAuthService => ({\n  authenticate,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAkDA,IAAa,sBAAb,cAAyC,QAAQ,IAC/C,iDACD,EAAyC,CAAC;;;;AAS3C,MAAa,SAAS,YAGpB,MAAM,QAAQ,qBAAqB,EACjC,eAAe,UACb,OAAO,cAAc,QAAQ,QAAQ,QAAQ,YAAY,MAAM,CAAC,CAAC,EACpE,CAAC;;;;AAKJ,MAAa,gBAAgB,YAC3B,MAAM,QAAQ,qBAAqB,QAAQ;;;;AAK7C,MAAa,eACX,WAEA,MAAM,OAAO,qBAAqB,OAAO;;;;AAS3C,MAAa,QAAQ,iBAAgD,EACnE,eAAe,UACb,OAAO,cAAc,QAAQ,QAAQ,YAAY,MAAM,CAAC,CAAC,EAC5D;;;;AAKD,MAAa,cACX,kBACsB,EACtB,cACD"}
+{"version":3,"file":"MimicAuthService.mjs","names":[],"sources":["../src/MimicAuthService.ts"],"sourcesContent":["/**\n * @voidhash/mimic-effect - MimicAuthService\n *\n * Authentication and authorization service interface and implementations.\n */\nimport { Context, Effect, Layer } from \"effect\";\nimport type { AuthContext, Permission } from \"./Types\";\nimport { AuthenticationError } from \"./Errors\";\n\n// =============================================================================\n// MimicAuthService Interface\n// =============================================================================\n\n/**\n * MimicAuthService interface for authentication and authorization.\n *\n * The `authenticate` method receives the token from the client's auth message\n * and the document ID being accessed. It should return an AuthContext on success\n * or fail with AuthenticationError on failure.\n *\n * The permission in AuthContext determines what the user can do:\n * - \"read\": Can subscribe, receive transactions, get snapshots\n * - \"write\": All of the above, plus can submit transactions and set presence\n */\nexport interface MimicAuthService {\n  /**\n   * Authenticate a connection and return authorization context.\n   *\n   * @param token - The token provided by the client\n   * @param documentId - The document ID being accessed\n   * @returns AuthContext with userId and permission level\n   */\n  readonly authenticate: (\n    token: string,\n    documentId: string\n  ) => Effect.Effect<AuthContext, AuthenticationError>;\n}\n\n// =============================================================================\n// Context Tag\n// =============================================================================\n\n/**\n * Context tag for MimicAuthService\n */\nexport class MimicAuthServiceTag extends Context.Tag(\n  \"@voidhash/mimic-effect/MimicAuthService\"\n)<MimicAuthServiceTag, MimicAuthService>() {}\n\n// =============================================================================\n// Factory\n// =============================================================================\n\n/**\n * Create a MimicAuthService layer from an Effect that produces the service.\n *\n * This allows you to access other Effect services when implementing authentication.\n *\n * @example\n * ```typescript\n * const Auth = MimicAuthService.make(\n *   Effect.gen(function*() {\n *     const db = yield* DatabaseService\n *     const jwt = yield* JwtService\n *\n *     return {\n *       authenticate: (token, documentId) =>\n *         Effect.gen(function*() {\n *           const payload = yield* jwt.verify(token).pipe(\n *             Effect.mapError(() => new AuthenticationError({ reason: \"Invalid token\" }))\n *           )\n *\n *           const permission = yield* db.getDocumentPermission(payload.userId, documentId)\n *\n *           return { userId: payload.userId, permission }\n *         })\n *     }\n *   })\n * )\n * ```\n */\nexport const make = <E, R>(\n  effect: Effect.Effect<MimicAuthService, E, R>\n): Layer.Layer<MimicAuthServiceTag, E, R> =>\n  Layer.effect(MimicAuthServiceTag, effect);\n\n// =============================================================================\n// NoAuth Implementation\n// =============================================================================\n\n/**\n * No-authentication implementation.\n *\n * Everyone gets write access with userId \"anonymous\".\n * ONLY USE FOR DEVELOPMENT/TESTING.\n */\nexport namespace NoAuth {\n  /**\n   * Create a NoAuth layer.\n   * All connections are authenticated with write permission.\n   */\n  export const make = (): Layer.Layer<MimicAuthServiceTag> =>\n    Layer.succeed(MimicAuthServiceTag, {\n      authenticate: (_token, _documentId) =>\n        Effect.succeed({\n          userId: \"anonymous\",\n          permission: \"write\" as const,\n        }),\n    });\n}\n\n// =============================================================================\n// Static Implementation\n// =============================================================================\n\n/**\n * Static permissions implementation.\n *\n * Permissions are defined at configuration time.\n * The token is treated as the userId.\n */\nexport namespace Static {\n  export interface Options {\n    /**\n     * Map of userId (token) to permission level\n     */\n    readonly permissions: Record<string, Permission>;\n    /**\n     * Default permission for users not in the permissions map.\n     * If undefined, unknown users will fail authentication.\n     */\n    readonly defaultPermission?: Permission;\n  }\n\n  /**\n   * Create a Static auth layer.\n   * The token is treated as the userId, and permissions are looked up from the config.\n   */\n  export const make = (options: Options): Layer.Layer<MimicAuthServiceTag> =>\n    Layer.succeed(MimicAuthServiceTag, {\n      authenticate: (token, _documentId) => {\n        const permission = options.permissions[token] ?? options.defaultPermission;\n        if (permission === undefined) {\n          return Effect.fail(\n            new AuthenticationError({ reason: \"Unknown user\" })\n          );\n        }\n        return Effect.succeed({\n          userId: token,\n          permission,\n        });\n      },\n    });\n}\n\n// =============================================================================\n// Re-export namespace\n// =============================================================================\n\nexport const MimicAuthService = {\n  Tag: MimicAuthServiceTag,\n  make,\n  NoAuth,\n  Static,\n};\n"],"mappings":";;;;;;;;;;;;AA6CA,IAAa,sBAAb,cAAyC,QAAQ,IAC/C,0CACD,EAAyC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkC3C,MAAa,QACX,WAEA,MAAM,OAAO,qBAAqB,OAAO;;;sBAkBvC,MAAM,QAAQ,qBAAqB,EACjC,eAAe,QAAQ,gBACrB,OAAO,QAAQ;EACb,QAAQ;EACR,YAAY;EACb,CAAC,EACL,CAAC;;;;iBA8BiB,YACnB,MAAM,QAAQ,qBAAqB,EACjC,eAAe,OAAO,gBAAgB;;EACpC,MAAM,sCAAa,QAAQ,YAAY,+EAAU,QAAQ;AACzD,MAAI,eAAe,OACjB,QAAO,OAAO,KACZ,IAAI,oBAAoB,EAAE,QAAQ,gBAAgB,CAAC,CACpD;AAEH,SAAO,OAAO,QAAQ;GACpB,QAAQ;GACR;GACD,CAAC;IAEL,CAAC;;AAON,MAAa,mBAAmB;CAC9B,KAAK;CACL;CACA;CACA;CACD"}

package/dist/MimicClusterServerEngine.cjs

@@ -0,0 +1,443 @@
+const require_ColdStorage = require('./ColdStorage.cjs');
+const require_HotStorage = require('./HotStorage.cjs');
+const require_Metrics = require('./Metrics.cjs');
+const require_objectSpread2 = require('./_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.cjs');
+const require_MimicServerEngine = require('./MimicServerEngine.cjs');
+let effect = require("effect");
+let _voidhash_mimic_server = require("@voidhash/mimic/server");
+let _effect_cluster = require("@effect/cluster");
+let _effect_rpc = require("@effect/rpc");
+
+//#region src/MimicClusterServerEngine.ts
+/**
+* @voidhash/mimic-effect - MimicClusterServerEngine
+*
+* Clustered document management service using Effect Cluster for horizontal scaling.
+* Each document becomes a cluster Entity with automatic sharding, failover, and location-transparent routing.
+*
+* This is an alternative to MimicServerEngine for distributed deployments.
+*/
+const DEFAULT_MAX_IDLE_TIME = effect.Duration.minutes(5);
+const DEFAULT_MAX_TRANSACTION_HISTORY = 1e3;
+const DEFAULT_SNAPSHOT_INTERVAL = effect.Duration.minutes(5);
+const DEFAULT_SNAPSHOT_THRESHOLD = 100;
+const DEFAULT_SHARD_GROUP = "mimic-documents";
+/**
+* Schema for encoded transaction (wire format)
+*/
+const EncodedTransactionSchema = effect.Schema.Struct({
+	id: effect.Schema.String,
+	ops: effect.Schema.Array(effect.Schema.Unknown)
+});
+/**
+* Schema for submit result
+*/
+const SubmitResultSchema = effect.Schema.Union(effect.Schema.Struct({
+	success: effect.Schema.Literal(true),
+	version: effect.Schema.Number
+}), effect.Schema.Struct({
+	success: effect.Schema.Literal(false),
+	reason: effect.Schema.String
+}));
+/**
+* Schema for snapshot response
+*/
+const SnapshotResponseSchema = effect.Schema.Struct({
+	state: effect.Schema.Unknown,
+	version: effect.Schema.Number
+});
+/**
+* Schema for presence entry
+*/
+const PresenceEntrySchema = effect.Schema.Struct({
+	data: effect.Schema.Unknown,
+	userId: effect.Schema.optional(effect.Schema.String)
+});
+/**
+* Schema for presence snapshot response
+*/
+const PresenceSnapshotResponseSchema = effect.Schema.Struct({ presences: effect.Schema.Record({
+	key: effect.Schema.String,
+	value: PresenceEntrySchema
+}) });
+effect.Schema.Union(effect.Schema.Struct({
+	type: effect.Schema.Literal("presence_update"),
+	id: effect.Schema.String,
+	data: effect.Schema.Unknown,
+	userId: effect.Schema.optional(effect.Schema.String)
+}), effect.Schema.Struct({
+	type: effect.Schema.Literal("presence_remove"),
+	id: effect.Schema.String
+}));
+effect.Schema.Unknown;
+/**
+* Define the Mimic Document Entity with its RPC protocol.
+* This entity handles document operations for a single documentId.
+*/
+const MimicDocumentEntity = _effect_cluster.Entity.make("MimicDocument", [
+	_effect_rpc.Rpc.make("Submit", {
+		payload: { transaction: EncodedTransactionSchema },
+		success: SubmitResultSchema
+	}),
+	_effect_rpc.Rpc.make("GetSnapshot", { success: SnapshotResponseSchema }),
+	_effect_rpc.Rpc.make("Touch", { success: effect.Schema.Void }),
+	_effect_rpc.Rpc.make("SetPresence", {
+		payload: {
+			connectionId: effect.Schema.String,
+			entry: PresenceEntrySchema
+		},
+		success: effect.Schema.Void
+	}),
+	_effect_rpc.Rpc.make("RemovePresence", {
+		payload: { connectionId: effect.Schema.String },
+		success: effect.Schema.Void
+	}),
+	_effect_rpc.Rpc.make("GetPresenceSnapshot", { success: PresenceSnapshotResponseSchema })
+]);
+/**
+* Context tag for cluster engine configuration
+*/
+var MimicClusterConfigTag = class extends effect.Context.Tag("@voidhash/mimic-effect/MimicClusterConfig")() {};
+const resolveClusterConfig = (config) => {
+	var _config$maxTransactio, _config$snapshot, _config$snapshot$tran, _config$snapshot2, _config$shardGroup;
+	return {
+		schema: config.schema,
+		initial: config.initial,
+		presence: config.presence,
+		maxIdleTime: config.maxIdleTime ? effect.Duration.decode(config.maxIdleTime) : DEFAULT_MAX_IDLE_TIME,
+		maxTransactionHistory: (_config$maxTransactio = config.maxTransactionHistory) !== null && _config$maxTransactio !== void 0 ? _config$maxTransactio : DEFAULT_MAX_TRANSACTION_HISTORY,
+		snapshot: {
+			interval: ((_config$snapshot = config.snapshot) === null || _config$snapshot === void 0 ? void 0 : _config$snapshot.interval) ? effect.Duration.decode(config.snapshot.interval) : DEFAULT_SNAPSHOT_INTERVAL,
+			transactionThreshold: (_config$snapshot$tran = (_config$snapshot2 = config.snapshot) === null || _config$snapshot2 === void 0 ? void 0 : _config$snapshot2.transactionThreshold) !== null && _config$snapshot$tran !== void 0 ? _config$snapshot$tran : DEFAULT_SNAPSHOT_THRESHOLD
+		},
+		shardGroup: (_config$shardGroup = config.shardGroup) !== null && _config$shardGroup !== void 0 ? _config$shardGroup : DEFAULT_SHARD_GROUP
+	};
+};
+/**
+* Decode an encoded transaction to a Transaction object
+*/
+const decodeTransaction = (encoded) => {
+	const { Transaction } = require("@voidhash/mimic");
+	return Transaction.decode(encoded);
+};
+/**
+* Encode a Transaction to wire format
+*/
+const encodeTransaction = (tx) => {
+	const { Transaction } = require("@voidhash/mimic");
+	return Transaction.encode(tx);
+};
+/**
+* Create the entity handler for MimicDocument
+*/
+const createEntityHandler = (config, coldStorage, hotStorage) => effect.Effect.gen(function* () {
+	const documentId = (yield* _effect_cluster.Entity.CurrentAddress).entityId;
+	const SCHEMA_VERSION = 1;
+	const computeInitialState = () => {
+		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);
+	};
+	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();
+	const broadcastPubSub = yield* effect.PubSub.unbounded();
+	const presencePubSub = yield* effect.PubSub.unbounded();
+	const stateRef = yield* effect.Ref.make({
+		document: void 0,
+		broadcastPubSub,
+		presences: effect.HashMap.empty(),
+		presencePubSub,
+		lastSnapshotVersion: initialVersion,
+		lastSnapshotTime: Date.now(),
+		transactionsSinceSnapshot: 0
+	});
+	const document = _voidhash_mimic_server.ServerDocument.make({
+		schema: config.schema,
+		initialState,
+		initialVersion,
+		maxTransactionHistory: config.maxTransactionHistory,
+		onBroadcast: (message) => {
+			effect.Effect.runSync(effect.PubSub.publish(broadcastPubSub, {
+				type: "transaction",
+				transaction: message.transaction,
+				version: message.version
+			}));
+		},
+		onRejection: (transactionId, reason) => {
+			effect.Effect.runSync(effect.PubSub.publish(broadcastPubSub, {
+				type: "error",
+				transactionId,
+				reason
+			}));
+		}
+	});
+	yield* effect.Ref.update(stateRef, (s) => require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, s), {}, { document }));
+	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
+		});
+	}
+	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);
+	/**
+	* Save snapshot to ColdStorage
+	*/
+	const saveSnapshot = effect.Effect.gen(function* () {
+		const state = yield* effect.Ref.get(stateRef);
+		const docState = state.document.get();
+		const version = state.document.getVersion();
+		if (docState === void 0) return;
+		const storedDocument = {
+			state: docState,
+			version,
+			schemaVersion: SCHEMA_VERSION,
+			savedAt: Date.now()
+		};
+		const snapshotStartTime = Date.now();
+		yield* effect.Effect.catchAll(coldStorage.save(documentId, storedDocument), (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.update(stateRef, (s) => require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, s), {}, {
+			lastSnapshotVersion: version,
+			lastSnapshotTime: Date.now(),
+			transactionsSinceSnapshot: 0
+		}));
+	});
+	/**
+	* Check if snapshot should be triggered
+	*/
+	const checkSnapshotTriggers = effect.Effect.gen(function* () {
+		const state = yield* effect.Ref.get(stateRef);
+		const now = Date.now();
+		const intervalMs = effect.Duration.toMillis(config.snapshot.interval);
+		const threshold = config.snapshot.transactionThreshold;
+		if (state.transactionsSinceSnapshot >= threshold) {
+			yield* saveSnapshot;
+			return;
+		}
+		if (now - state.lastSnapshotTime >= intervalMs) {
+			yield* saveSnapshot;
+			return;
+		}
+	});
+	yield* effect.Effect.addFinalizer(() => effect.Effect.gen(function* () {
+		yield* saveSnapshot;
+		yield* effect.Metric.incrementBy(require_Metrics.documentsActive, -1);
+		yield* effect.Metric.increment(require_Metrics.documentsEvicted);
+		yield* effect.Effect.logDebug("Entity finalized", { documentId });
+	}));
+	return {
+		Submit: effect.Effect.fnUntraced(function* ({ payload }) {
+			const submitStartTime = Date.now();
+			const state = yield* effect.Ref.get(stateRef);
+			const transaction = decodeTransaction(payload.transaction);
+			const result = state.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(stateRef, (s) => require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, s), {}, { transactionsSinceSnapshot: s.transactionsSinceSnapshot + 1 }));
+				yield* checkSnapshotTriggers;
+			} else yield* effect.Metric.increment(require_Metrics.transactionsRejected);
+			return result;
+		}),
+		GetSnapshot: effect.Effect.fnUntraced(function* () {
+			return (yield* effect.Ref.get(stateRef)).document.getSnapshot();
+		}),
+		Touch: effect.Effect.fnUntraced(function* () {}),
+		SetPresence: effect.Effect.fnUntraced(function* ({ payload }) {
+			const { connectionId, entry } = payload;
+			yield* effect.Ref.update(stateRef, (s) => require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, s), {}, { presences: effect.HashMap.set(s.presences, connectionId, entry) }));
+			yield* effect.Metric.increment(require_Metrics.presenceUpdates);
+			yield* effect.Metric.incrementBy(require_Metrics.presenceActive, 1);
+			const state = yield* effect.Ref.get(stateRef);
+			const event = {
+				type: "presence_update",
+				id: connectionId,
+				data: entry.data,
+				userId: entry.userId
+			};
+			yield* effect.PubSub.publish(state.presencePubSub, event);
+		}),
+		RemovePresence: effect.Effect.fnUntraced(function* ({ payload }) {
+			const { connectionId } = payload;
+			const state = yield* effect.Ref.get(stateRef);
+			if (!effect.HashMap.has(state.presences, connectionId)) return;
+			yield* effect.Ref.update(stateRef, (s) => require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, s), {}, { presences: effect.HashMap.remove(s.presences, connectionId) }));
+			yield* effect.Metric.incrementBy(require_Metrics.presenceActive, -1);
+			const event = {
+				type: "presence_remove",
+				id: connectionId
+			};
+			yield* effect.PubSub.publish(state.presencePubSub, event);
+		}),
+		GetPresenceSnapshot: effect.Effect.fnUntraced(function* () {
+			const state = yield* effect.Ref.get(stateRef);
+			const presences = {};
+			for (const [id, entry] of state.presences) presences[id] = entry;
+			return { presences };
+		})
+	};
+});
+var SubscriptionStoreTag = class extends effect.Context.Tag("@voidhash/mimic-effect/SubscriptionStore")() {};
+const subscriptionStoreLayer = effect.Layer.effect(SubscriptionStoreTag, effect.Effect.gen(function* () {
+	const documentPubSubs = yield* effect.Ref.make(effect.HashMap.empty());
+	const presencePubSubs = yield* effect.Ref.make(effect.HashMap.empty());
+	return {
+		getOrCreatePubSub: (documentId) => effect.Effect.gen(function* () {
+			const current = yield* effect.Ref.get(documentPubSubs);
+			const existing = effect.HashMap.get(current, documentId);
+			if (existing._tag === "Some") return existing.value;
+			const pubsub = yield* effect.PubSub.unbounded();
+			yield* effect.Ref.update(documentPubSubs, (map) => effect.HashMap.set(map, documentId, pubsub));
+			return pubsub;
+		}),
+		getOrCreatePresencePubSub: (documentId) => effect.Effect.gen(function* () {
+			const current = yield* effect.Ref.get(presencePubSubs);
+			const existing = effect.HashMap.get(current, documentId);
+			if (existing._tag === "Some") return existing.value;
+			const pubsub = yield* effect.PubSub.unbounded();
+			yield* effect.Ref.update(presencePubSubs, (map) => effect.HashMap.set(map, documentId, pubsub));
+			return pubsub;
+		})
+	};
+}));
+/**
+* Create a MimicClusterServerEngine layer.
+*
+* This creates a clustered document management service using Effect Cluster.
+* Each document becomes a cluster Entity with automatic sharding and failover.
+*
+* @example
+* ```typescript
+* // 1. Create the engine
+* const Engine = MimicClusterServerEngine.make({
+*   schema: DocSchema,
+*   initial: { title: "Untitled" },
+*   presence: CursorPresence,
+*   maxIdleTime: "5 minutes",
+*   snapshot: { interval: "5 minutes", transactionThreshold: 100 },
+*   shardGroup: "documents",
+* })
+*
+* // 2. Create the WebSocket route
+* const MimicRoute = MimicServer.layerHttpLayerRouter({
+*   path: "/mimic",
+* })
+*
+* // 3. Wire together with cluster infrastructure
+* const MimicLive = MimicRoute.pipe(
+*   Layer.provide(Engine),
+*   Layer.provide(ColdStorage.S3.make(...)),
+*   Layer.provide(HotStorage.Redis.make(...)),
+*   Layer.provide(MimicAuthService.make(...)),
+*   Layer.provide(ClusterInfrastructure),
+* )
+* ```
+*/
+const make = (config) => {
+	const resolvedConfig = resolveClusterConfig(config);
+	const configLayer = effect.Layer.succeed(MimicClusterConfigTag, resolvedConfig);
+	const entityLayer = MimicDocumentEntity.toLayer(effect.Effect.gen(function* () {
+		return yield* createEntityHandler(yield* MimicClusterConfigTag, yield* require_ColdStorage.ColdStorageTag, yield* require_HotStorage.HotStorageTag);
+	}), {
+		maxIdleTime: resolvedConfig.maxIdleTime,
+		concurrency: 1,
+		mailboxCapacity: 4096
+	});
+	const engineLayer = effect.Layer.scoped(require_MimicServerEngine.MimicServerEngineTag, effect.Effect.gen(function* () {
+		const makeClient = yield* MimicDocumentEntity.client;
+		const subscriptionStore = yield* SubscriptionStoreTag;
+		return {
+			submit: (documentId, transaction) => effect.Effect.gen(function* () {
+				const client = makeClient(documentId);
+				const encodedTx = encodeTransaction(transaction);
+				const result = yield* client.Submit({ transaction: encodedTx }).pipe(effect.Effect.catchAll((error) => effect.Effect.succeed({
+					success: false,
+					reason: `Cluster error: ${String(error)}`
+				})));
+				if (result.success) {
+					const pubsub = yield* subscriptionStore.getOrCreatePubSub(documentId);
+					yield* effect.PubSub.publish(pubsub, {
+						type: "transaction",
+						transaction,
+						version: result.version
+					});
+				}
+				return result;
+			}),
+			getSnapshot: (documentId) => effect.Effect.gen(function* () {
+				return yield* makeClient(documentId).GetSnapshot(void 0).pipe(effect.Effect.orDie);
+			}),
+			subscribe: (documentId) => effect.Effect.gen(function* () {
+				const pubsub = yield* subscriptionStore.getOrCreatePubSub(documentId);
+				return effect.Stream.fromPubSub(pubsub);
+			}),
+			touch: (documentId) => effect.Effect.gen(function* () {
+				yield* makeClient(documentId).Touch(void 0).pipe(effect.Effect.orDie);
+			}),
+			getPresenceSnapshot: (documentId) => effect.Effect.gen(function* () {
+				return yield* makeClient(documentId).GetPresenceSnapshot(void 0).pipe(effect.Effect.orDie);
+			}),
+			setPresence: (documentId, connectionId, entry) => effect.Effect.gen(function* () {
+				yield* makeClient(documentId).SetPresence({
+					connectionId,
+					entry
+				}).pipe(effect.Effect.orDie);
+				const pubsub = yield* subscriptionStore.getOrCreatePresencePubSub(documentId);
+				yield* effect.PubSub.publish(pubsub, {
+					type: "presence_update",
+					id: connectionId,
+					data: entry.data,
+					userId: entry.userId
+				});
+			}),
+			removePresence: (documentId, connectionId) => effect.Effect.gen(function* () {
+				yield* makeClient(documentId).RemovePresence({ connectionId }).pipe(effect.Effect.orDie);
+				const pubsub = yield* subscriptionStore.getOrCreatePresencePubSub(documentId);
+				yield* effect.PubSub.publish(pubsub, {
+					type: "presence_remove",
+					id: connectionId
+				});
+			}),
+			subscribePresence: (documentId) => effect.Effect.gen(function* () {
+				const pubsub = yield* subscriptionStore.getOrCreatePresencePubSub(documentId);
+				return effect.Stream.fromPubSub(pubsub);
+			}),
+			config: resolvedConfig
+		};
+	}));
+	return effect.Layer.mergeAll(entityLayer, engineLayer).pipe(effect.Layer.provideMerge(subscriptionStoreLayer), effect.Layer.provideMerge(configLayer));
+};
+const MimicClusterServerEngine = { make };
+
+//#endregion
+exports.MimicClusterServerEngine = MimicClusterServerEngine;

package/dist/MimicClusterServerEngine.d.cts

@@ -0,0 +1,17 @@
+import { MimicClusterServerEngineConfig } from "./Types.cjs";
+import { ColdStorageTag } from "./ColdStorage.cjs";
+import { HotStorageTag } from "./HotStorage.cjs";
+import { MimicAuthServiceTag } from "./MimicAuthService.cjs";
+import { MimicServerEngineTag } from "./MimicServerEngine.cjs";
+import { Layer } from "effect";
+import { Primitive } from "@voidhash/mimic";
+import { Sharding } from "@effect/cluster";
+
+//#region src/MimicClusterServerEngine.d.ts
+
+declare const MimicClusterServerEngine: {
+  make: <TSchema extends Primitive.AnyPrimitive>(config: MimicClusterServerEngineConfig<TSchema>) => Layer.Layer<MimicServerEngineTag, never, ColdStorageTag | HotStorageTag | MimicAuthServiceTag | Sharding.Sharding>;
+};
+//#endregion
+export { MimicClusterServerEngine };
+//# sourceMappingURL=MimicClusterServerEngine.d.cts.map

package/dist/MimicClusterServerEngine.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MimicClusterServerEngine.d.cts","names":[],"sources":["../src/MimicClusterServerEngine.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;cAqzBa;yBA3JwB,SAAA,CAAU,sBACrC,+BAA+B,aACtC,KAAA,CAAM,MACP,6BAEA,iBAAiB,gBAAgB,sBAAsB,QAAA,CAAS"}

package/dist/MimicClusterServerEngine.d.mts

@@ -0,0 +1,17 @@
+import { MimicClusterServerEngineConfig } from "./Types.mjs";
+import { ColdStorageTag } from "./ColdStorage.mjs";
+import { HotStorageTag } from "./HotStorage.mjs";
+import { MimicAuthServiceTag } from "./MimicAuthService.mjs";
+import { MimicServerEngineTag } from "./MimicServerEngine.mjs";
+import { Layer } from "effect";
+import { Sharding } from "@effect/cluster";
+import { Primitive } from "@voidhash/mimic";
+
+//#region src/MimicClusterServerEngine.d.ts
+
+declare const MimicClusterServerEngine: {
+  make: <TSchema extends Primitive.AnyPrimitive>(config: MimicClusterServerEngineConfig<TSchema>) => Layer.Layer<MimicServerEngineTag, never, ColdStorageTag | HotStorageTag | MimicAuthServiceTag | Sharding.Sharding>;
+};
+//#endregion
+export { MimicClusterServerEngine };
+//# sourceMappingURL=MimicClusterServerEngine.d.mts.map

package/dist/MimicClusterServerEngine.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MimicClusterServerEngine.d.mts","names":[],"sources":["../src/MimicClusterServerEngine.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;cAqzBa;yBA3JwB,SAAA,CAAU,sBACrC,+BAA+B,aACtC,KAAA,CAAM,MACP,6BAEA,iBAAiB,gBAAgB,sBAAsB,QAAA,CAAS"}