@voidhash/mimic-effect 0.0.1-alpha.1 → 0.0.1-alpha.3

package/dist/index.mjs

@@ -0,0 +1,1162 @@
+import { t as __export } from "./chunk-C6wwvPpM.mjs";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Context from "effect/Context";
+import { SocketServer } from "@effect/platform/SocketServer";
+import * as PubSub from "effect/PubSub";
+import * as Ref from "effect/Ref";
+import * as HashMap from "effect/HashMap";
+import * as Stream from "effect/Stream";
+import { ServerDocument } from "@voidhash/mimic/server";
+import * as Duration from "effect/Duration";
+import * as Data from "effect/Data";
+import * as Fiber from "effect/Fiber";
+import { Presence, Transaction } from "@voidhash/mimic";
+import { HttpLayerRouter, HttpServerRequest, HttpServerResponse } from "@effect/platform";
+import * as Schema from "effect/Schema";
+
+//#region src/MimicConfig.ts
+/**
+* @since 0.0.1
+* Configuration types for the Mimic server.
+*/
+var MimicConfig_exports = /* @__PURE__ */ __export({
+	MimicServerConfigTag: () => MimicServerConfigTag,
+	layer: () => layer$7,
+	make: () => make$2
+});
+/**
+* Create a MimicServerConfig from options.
+*/
+const make$2 = (options) => {
+	var _options$maxIdleTime, _options$maxTransacti, _options$heartbeatInt, _options$heartbeatTim;
+	return {
+		schema: options.schema,
+		maxIdleTime: Duration.decode((_options$maxIdleTime = options.maxIdleTime) !== null && _options$maxIdleTime !== void 0 ? _options$maxIdleTime : "5 minutes"),
+		maxTransactionHistory: (_options$maxTransacti = options.maxTransactionHistory) !== null && _options$maxTransacti !== void 0 ? _options$maxTransacti : 1e3,
+		heartbeatInterval: Duration.decode((_options$heartbeatInt = options.heartbeatInterval) !== null && _options$heartbeatInt !== void 0 ? _options$heartbeatInt : "30 seconds"),
+		heartbeatTimeout: Duration.decode((_options$heartbeatTim = options.heartbeatTimeout) !== null && _options$heartbeatTim !== void 0 ? _options$heartbeatTim : "10 seconds"),
+		presence: options.presence
+	};
+};
+/**
+* Context tag for MimicServerConfig.
+*/
+var MimicServerConfigTag = class extends Context.Tag("@voidhash/mimic-server-effect/MimicServerConfig")() {};
+/**
+* Create a Layer that provides MimicServerConfig.
+*/
+const layer$7 = (options) => Layer.succeed(MimicServerConfigTag, make$2(options));
+
+//#endregion
+//#region src/MimicDataStorage.ts
+/**
+* @since 0.0.1
+* Data storage service interface for Mimic documents.
+* Provides pluggable storage adapters with load/save hooks for data transformation.
+*/
+var MimicDataStorage_exports = /* @__PURE__ */ __export({
+	MimicDataStorageTag: () => MimicDataStorageTag,
+	StorageDeleteError: () => StorageDeleteError,
+	StorageLoadError: () => StorageLoadError,
+	StorageSaveError: () => StorageSaveError,
+	layer: () => layer$6,
+	layerEffect: () => layerEffect$1,
+	make: () => make$1
+});
+/**
+* Error when loading a document from storage fails.
+*/
+var StorageLoadError = class extends Data.TaggedError("StorageLoadError") {
+	get message() {
+		return `Failed to load document ${this.documentId}: ${String(this.cause)}`;
+	}
+};
+/**
+* Error when saving a document to storage fails.
+*/
+var StorageSaveError = class extends Data.TaggedError("StorageSaveError") {
+	get message() {
+		return `Failed to save document ${this.documentId}: ${String(this.cause)}`;
+	}
+};
+/**
+* Error when deleting a document from storage fails.
+*/
+var StorageDeleteError = class extends Data.TaggedError("StorageDeleteError") {
+	get message() {
+		return `Failed to delete document ${this.documentId}: ${String(this.cause)}`;
+	}
+};
+/**
+* Context tag for MimicDataStorage service.
+*/
+var MimicDataStorageTag = class extends Context.Tag("@voidhash/mimic-server-effect/MimicDataStorage")() {};
+/**
+* Create a MimicDataStorage layer from a storage implementation.
+*/
+const layer$6 = (storage) => Layer.succeed(MimicDataStorageTag, storage);
+/**
+* Create a MimicDataStorage layer from an Effect that produces a storage implementation.
+*/
+const layerEffect$1 = (effect) => Layer.effect(MimicDataStorageTag, effect);
+/**
+* Create a simple storage implementation with minimal configuration.
+*/
+const make$1 = (options) => {
+	var _options$delete, _options$onLoad, _options$onSave;
+	return {
+		load: options.load,
+		save: options.save,
+		delete: (_options$delete = options.delete) !== null && _options$delete !== void 0 ? _options$delete : (() => Effect.void),
+		onLoad: (_options$onLoad = options.onLoad) !== null && _options$onLoad !== void 0 ? _options$onLoad : ((state) => Effect.succeed(state)),
+		onSave: (_options$onSave = options.onSave) !== null && _options$onSave !== void 0 ? _options$onSave : ((state) => Effect.succeed(state))
+	};
+};
+
+//#endregion
+//#region src/DocumentManager.ts
+/**
+* @since 0.0.1
+* Document manager that handles multiple document instances.
+*/
+var DocumentManager_exports = /* @__PURE__ */ __export({
+	DocumentManagerTag: () => DocumentManagerTag,
+	layer: () => layer$5
+});
+/**
+* Context tag for DocumentManager.
+*/
+var DocumentManagerTag = class extends Context.Tag("@voidhash/mimic-server-effect/DocumentManager")() {};
+/**
+* Create the DocumentManager service.
+*/
+const makeDocumentManager = Effect.gen(function* () {
+	const config = yield* MimicServerConfigTag;
+	const storage = yield* MimicDataStorageTag;
+	const documents = yield* Ref.make(HashMap.empty());
+	const getOrCreateDocument = (documentId) => Effect.gen(function* () {
+		const current = yield* Ref.get(documents);
+		const existing = HashMap.get(current, documentId);
+		if (existing._tag === "Some") {
+			yield* Ref.update(existing.value.refCount, (n) => n + 1);
+			return existing.value;
+		}
+		const rawState = yield* Effect.catchAll(storage.load(documentId), () => Effect.succeed(void 0));
+		const initialState = rawState !== void 0 ? yield* storage.onLoad(rawState) : void 0;
+		const pubsub = yield* PubSub.unbounded();
+		const serverDocument = ServerDocument.make({
+			schema: config.schema,
+			initialState,
+			maxTransactionHistory: config.maxTransactionHistory,
+			onBroadcast: (transactionMessage) => {
+				const currentState = serverDocument.get();
+				Effect.runFork(Effect.gen(function* () {
+					if (currentState !== void 0) {
+						const transformedState = yield* storage.onSave(currentState);
+						yield* Effect.catchAll(storage.save(documentId, transformedState), (error) => Effect.logError("Failed to save document", error));
+					}
+				}));
+				Effect.runSync(PubSub.publish(pubsub, {
+					type: "transaction",
+					transaction: transactionMessage.transaction,
+					version: transactionMessage.version
+				}));
+			},
+			onRejection: (transactionId, reason) => {
+				Effect.runSync(PubSub.publish(pubsub, {
+					type: "error",
+					transactionId,
+					reason
+				}));
+			}
+		});
+		const instance = {
+			document: serverDocument,
+			pubsub,
+			refCount: yield* Ref.make(1)
+		};
+		yield* Ref.update(documents, (map) => HashMap.set(map, documentId, instance));
+		return instance;
+	});
+	const submit = (documentId, transaction) => Effect.gen(function* () {
+		return (yield* getOrCreateDocument(documentId)).document.submit(transaction);
+	});
+	const getSnapshot = (documentId) => Effect.gen(function* () {
+		return (yield* getOrCreateDocument(documentId)).document.getSnapshot();
+	});
+	const subscribe = (documentId) => Effect.gen(function* () {
+		const instance = yield* getOrCreateDocument(documentId);
+		const queue = yield* PubSub.subscribe(instance.pubsub);
+		yield* Effect.addFinalizer(() => Effect.gen(function* () {
+			yield* Ref.updateAndGet(instance.refCount, (n) => n - 1);
+		}));
+		return Stream.fromQueue(queue);
+	});
+	return {
+		submit,
+		getSnapshot,
+		subscribe
+	};
+});
+/**
+* Layer that provides DocumentManager.
+* Requires MimicServerConfigTag and MimicDataStorageTag.
+*/
+const layer$5 = Layer.effect(DocumentManagerTag, makeDocumentManager);
+
+//#endregion
+//#region src/MimicAuthService.ts
+/**
+* @since 0.0.1
+* Authentication service interface for Mimic connections.
+* Provides pluggable authentication adapters.
+*/
+var MimicAuthService_exports = /* @__PURE__ */ __export({
+	MimicAuthServiceTag: () => MimicAuthServiceTag,
+	layer: () => layer$4,
+	layerEffect: () => layerEffect,
+	layerService: () => layerService,
+	make: () => make,
+	makeEffect: () => makeEffect
+});
+/**
+* Context tag for MimicAuthService service.
+*/
+var MimicAuthServiceTag = class extends Context.Tag("@voidhash/mimic-server-effect/MimicAuthService")() {};
+/**
+* Create a MimicAuthService layer from an auth handler function.
+*/
+const layer$4 = (options) => Layer.succeed(MimicAuthServiceTag, { authenticate: (token) => Effect.promise(() => Promise.resolve(options.authHandler(token))) });
+/**
+* Create a MimicAuthService layer from an auth service implementation.
+*/
+const layerService = (service) => Layer.succeed(MimicAuthServiceTag, service);
+/**
+* Create a MimicAuthService layer from an Effect that produces an auth service.
+*/
+const layerEffect = (effect) => Layer.effect(MimicAuthServiceTag, effect);
+/**
+* Create an auth service from an auth handler function.
+*/
+const make = (authHandler) => ({ authenticate: (token) => Effect.promise(() => Promise.resolve(authHandler(token))) });
+/**
+* Create an auth service from an Effect-based authenticate function.
+*/
+const makeEffect = (authenticate) => ({ authenticate });
+
+//#endregion
+//#region src/PresenceManager.ts
+/**
+* @since 0.0.1
+* Presence manager for ephemeral per-connection state.
+* Handles in-memory storage and broadcasting of presence updates.
+*/
+var PresenceManager_exports = /* @__PURE__ */ __export({
+	PresenceManagerTag: () => PresenceManagerTag,
+	layer: () => layer$3,
+	layerDefault: () => layerDefault$2
+});
+/**
+* Context tag for PresenceManager.
+*/
+var PresenceManagerTag = class extends Context.Tag("@voidhash/mimic-server-effect/PresenceManager")() {};
+/**
+* Create the PresenceManager service.
+*/
+const makePresenceManager = Effect.gen(function* () {
+	const documents = yield* Ref.make(HashMap.empty());
+	const getOrCreateDocument = (documentId) => Effect.gen(function* () {
+		const current = yield* Ref.get(documents);
+		const existing = HashMap.get(current, documentId);
+		if (existing._tag === "Some") return existing.value;
+		const docPresence = {
+			entries: yield* Ref.make(HashMap.empty()),
+			pubsub: yield* PubSub.unbounded()
+		};
+		yield* Ref.update(documents, (map) => HashMap.set(map, documentId, docPresence));
+		return docPresence;
+	});
+	const getSnapshot = (documentId) => Effect.gen(function* () {
+		const docPresence = yield* getOrCreateDocument(documentId);
+		const entriesMap = yield* Ref.get(docPresence.entries);
+		const presences = {};
+		for (const [id, entry] of entriesMap) presences[id] = entry;
+		return { presences };
+	});
+	const set = (documentId, connectionId, entry) => Effect.gen(function* () {
+		const docPresence = yield* getOrCreateDocument(documentId);
+		yield* Ref.update(docPresence.entries, (map) => HashMap.set(map, connectionId, entry));
+		yield* PubSub.publish(docPresence.pubsub, {
+			type: "presence_update",
+			id: connectionId,
+			data: entry.data,
+			userId: entry.userId
+		});
+	});
+	const remove = (documentId, connectionId) => Effect.gen(function* () {
+		const current = yield* Ref.get(documents);
+		const existing = HashMap.get(current, documentId);
+		if (existing._tag === "None") return;
+		const docPresence = existing.value;
+		const entries = yield* Ref.get(docPresence.entries);
+		if (!HashMap.has(entries, connectionId)) return;
+		yield* Ref.update(docPresence.entries, (map) => HashMap.remove(map, connectionId));
+		yield* PubSub.publish(docPresence.pubsub, {
+			type: "presence_remove",
+			id: connectionId
+		});
+	});
+	const subscribe = (documentId) => Effect.gen(function* () {
+		const docPresence = yield* getOrCreateDocument(documentId);
+		const queue = yield* PubSub.subscribe(docPresence.pubsub);
+		return Stream.fromQueue(queue);
+	});
+	return {
+		getSnapshot,
+		set,
+		remove,
+		subscribe
+	};
+});
+/**
+* Layer that provides PresenceManager.
+*/
+const layer$3 = Layer.effect(PresenceManagerTag, makePresenceManager);
+/**
+* Default layer that provides PresenceManager.
+* Uses the default priority for layer composition.
+*/
+const layerDefault$2 = Layer.effectDiscard(Effect.succeed(void 0)).pipe(Layer.provideMerge(layer$3));
+
+//#endregion
+//#region src/errors.ts
+/**
+* @since 0.0.1
+* Error types for the Mimic server.
+*/
+/**
+* Error when a document type is not found in the schema registry.
+*/
+var DocumentTypeNotFoundError = class extends Data.TaggedError("DocumentTypeNotFoundError") {
+	get message() {
+		return `Document type not found: ${this.documentType}`;
+	}
+};
+/**
+* Error when a document is not found.
+*/
+var DocumentNotFoundError = class extends Data.TaggedError("DocumentNotFoundError") {
+	get message() {
+		return `Document not found: ${this.documentId}`;
+	}
+};
+/**
+* Error when authentication fails.
+*/
+var AuthenticationError = class extends Data.TaggedError("AuthenticationError") {
+	get message() {
+		return `Authentication failed: ${this.reason}`;
+	}
+};
+/**
+* Error when a transaction is rejected.
+*/
+var TransactionRejectedError = class extends Data.TaggedError("TransactionRejectedError") {
+	get message() {
+		return `Transaction ${this.transactionId} rejected: ${this.reason}`;
+	}
+};
+/**
+* Error when parsing a client message fails.
+*/
+var MessageParseError = class extends Data.TaggedError("MessageParseError") {
+	get message() {
+		return `Failed to parse message: ${String(this.cause)}`;
+	}
+};
+/**
+* Error when the WebSocket connection is invalid.
+*/
+var InvalidConnectionError = class extends Data.TaggedError("InvalidConnectionError") {
+	get message() {
+		return `Invalid connection: ${this.reason}`;
+	}
+};
+/**
+* Error when the document ID is missing from the URL path.
+*/
+var MissingDocumentIdError = class extends Data.TaggedError("MissingDocumentIdError") {
+	get message() {
+		return this.path ? `Document ID is required in the URL path: ${this.path}` : "Document ID is required in the URL path";
+	}
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r$1) {
+			return Object.getOwnPropertyDescriptor(e, r$1).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r$1) {
+			_defineProperty(e, r$1, t[r$1]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r$1) {
+			Object.defineProperty(e, r$1, Object.getOwnPropertyDescriptor(t, r$1));
+		});
+	}
+	return e;
+}
+
+//#endregion
+//#region src/WebSocketHandler.ts
+/**
+* @since 0.0.1
+* WebSocket connection handler using Effect Platform Socket API.
+*/
+var WebSocketHandler_exports = /* @__PURE__ */ __export({
+	extractDocumentId: () => extractDocumentId,
+	handleConnection: () => handleConnection,
+	makeHandler: () => makeHandler
+});
+/**
+* Extract document ID from URL path.
+* Expected format: /doc/{documentId}
+*/
+const extractDocumentId = (path) => {
+	const parts = path.replace(/^\/+/, "").split("/");
+	const docIndex = parts.lastIndexOf("doc");
+	const part = parts[docIndex + 1];
+	if (docIndex !== -1 && part) return Effect.succeed(decodeURIComponent(part));
+	return Effect.fail(new MissingDocumentIdError({}));
+};
+/**
+* Decodes an encoded client message from the wire format.
+*/
+const decodeClientMessage = (encoded) => {
+	if (encoded.type === "submit") return {
+		type: "submit",
+		transaction: Transaction.decode(encoded.transaction)
+	};
+	return encoded;
+};
+/**
+* Encodes a server message for the wire format.
+*/
+const encodeServerMessageForWire = (message) => {
+	if (message.type === "transaction") return {
+		type: "transaction",
+		transaction: Transaction.encode(message.transaction),
+		version: message.version
+	};
+	return message;
+};
+const parseClientMessage = (data) => Effect.try({
+	try: () => {
+		const text = typeof data === "string" ? data : new TextDecoder().decode(data);
+		return decodeClientMessage(JSON.parse(text));
+	},
+	catch: (cause) => new MessageParseError({ cause })
+});
+const encodeServerMessage = (message) => JSON.stringify(encodeServerMessageForWire(message));
+/**
+* Handle a WebSocket connection for a document.
+*
+* @param socket - The Effect Platform Socket
+* @param path - The URL path (e.g., "/doc/my-document-id")
+* @returns An Effect that handles the connection lifecycle
+*/
+const handleConnection = (socket, path) => Effect.gen(function* () {
+	const config = yield* MimicServerConfigTag;
+	const authService = yield* MimicAuthServiceTag;
+	const documentManager = yield* DocumentManagerTag;
+	const presenceManager = yield* PresenceManagerTag;
+	const documentId = yield* extractDocumentId(path);
+	const connectionId = crypto.randomUUID();
+	let state = {
+		documentId,
+		connectionId,
+		authenticated: false
+	};
+	let hasPresence = false;
+	const write = yield* socket.writer;
+	const sendMessage = (message) => write(encodeServerMessage(message));
+	const sendPresenceSnapshot = Effect.gen(function* () {
+		if (!config.presence) return;
+		yield* sendMessage({
+			type: "presence_snapshot",
+			selfId: connectionId,
+			presences: (yield* presenceManager.getSnapshot(documentId)).presences
+		});
+	});
+	const handleAuth = (token) => Effect.gen(function* () {
+		const result = yield* authService.authenticate(token);
+		if (result.success) {
+			state = _objectSpread2(_objectSpread2({}, state), {}, {
+				authenticated: true,
+				userId: result.userId
+			});
+			yield* sendMessage({
+				type: "auth_result",
+				success: true
+			});
+			yield* sendPresenceSnapshot;
+		} else yield* sendMessage({
+			type: "auth_result",
+			success: false,
+			error: result.error
+		});
+	});
+	const handlePresenceSet = (data) => Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!config.presence) return;
+		const validated = Presence.validateSafe(config.presence, data);
+		if (validated === void 0) {
+			yield* Effect.logWarning("Invalid presence data received", {
+				connectionId,
+				data
+			});
+			return;
+		}
+		yield* presenceManager.set(documentId, connectionId, {
+			data: validated,
+			userId: state.userId
+		});
+		hasPresence = true;
+	});
+	const handlePresenceClear = Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!config.presence) return;
+		yield* presenceManager.remove(documentId, connectionId);
+		hasPresence = false;
+	});
+	const handleMessage = (message) => Effect.gen(function* () {
+		switch (message.type) {
+			case "auth":
+				yield* handleAuth(message.token);
+				break;
+			case "ping":
+				yield* sendMessage({ type: "pong" });
+				break;
+			case "submit":
+				if (!state.authenticated) {
+					yield* sendMessage({
+						type: "error",
+						transactionId: message.transaction.id,
+						reason: "Not authenticated"
+					});
+					return;
+				}
+				const submitResult = yield* documentManager.submit(documentId, message.transaction);
+				if (!submitResult.success) yield* sendMessage({
+					type: "error",
+					transactionId: message.transaction.id,
+					reason: submitResult.reason
+				});
+				break;
+			case "request_snapshot":
+				if (!state.authenticated) return;
+				yield* sendMessage(yield* Effect.catchAll(documentManager.getSnapshot(documentId), () => Effect.succeed({
+					type: "snapshot",
+					state: null,
+					version: 0
+				})));
+				break;
+			case "presence_set":
+				yield* handlePresenceSet(message.data);
+				break;
+			case "presence_clear":
+				yield* handlePresenceClear;
+				break;
+		}
+	});
+	const subscribeFiber = yield* Effect.fork(Effect.gen(function* () {
+		while (!state.authenticated) yield* Effect.sleep(Duration.millis(100));
+		const broadcastStream = yield* Effect.catchAll(documentManager.subscribe(documentId), () => Effect.succeed(Stream.empty));
+		yield* Stream.runForEach(broadcastStream, (broadcast) => sendMessage(broadcast));
+	}).pipe(Effect.scoped));
+	const presenceFiber = yield* Effect.fork(Effect.gen(function* () {
+		if (!config.presence) return;
+		while (!state.authenticated) yield* Effect.sleep(Duration.millis(100));
+		const presenceStream = yield* presenceManager.subscribe(documentId);
+		yield* Stream.runForEach(presenceStream, (event) => Effect.gen(function* () {
+			if (event.id === connectionId) return;
+			if (event.type === "presence_update") yield* sendMessage({
+				type: "presence_update",
+				id: event.id,
+				data: event.data,
+				userId: event.userId
+			});
+			else if (event.type === "presence_remove") yield* sendMessage({
+				type: "presence_remove",
+				id: event.id
+			});
+		}));
+	}).pipe(Effect.scoped));
+	yield* Effect.addFinalizer(() => Effect.gen(function* () {
+		yield* Fiber.interrupt(subscribeFiber);
+		yield* Fiber.interrupt(presenceFiber);
+		if (hasPresence && config.presence) yield* presenceManager.remove(documentId, connectionId);
+	}));
+	yield* socket.runRaw((data) => Effect.gen(function* () {
+		yield* handleMessage(yield* parseClientMessage(data));
+	}).pipe(Effect.catchAll((error) => Effect.logError("Message handling error", error))));
+});
+/**
+* Create a handler function for the WebSocket server.
+* Returns a function that takes a socket and document ID.
+*/
+const makeHandler = Effect.gen(function* () {
+	const config = yield* MimicServerConfigTag;
+	const authService = yield* MimicAuthServiceTag;
+	const documentManager = yield* DocumentManagerTag;
+	const presenceManager = yield* PresenceManagerTag;
+	return (socket, documentId) => handleConnectionWithDocumentId(socket, documentId).pipe(Effect.provideService(MimicServerConfigTag, config), Effect.provideService(MimicAuthServiceTag, authService), Effect.provideService(DocumentManagerTag, documentManager), Effect.provideService(PresenceManagerTag, presenceManager), Effect.scoped);
+});
+/**
+* Handle a WebSocket connection for a document (using document ID directly).
+*/
+const handleConnectionWithDocumentId = (socket, documentId) => Effect.gen(function* () {
+	const config = yield* MimicServerConfigTag;
+	const authService = yield* MimicAuthServiceTag;
+	const documentManager = yield* DocumentManagerTag;
+	const presenceManager = yield* PresenceManagerTag;
+	const connectionId = crypto.randomUUID();
+	let state = {
+		documentId,
+		connectionId,
+		authenticated: false
+	};
+	let hasPresence = false;
+	const write = yield* socket.writer;
+	const sendMessage = (message) => write(encodeServerMessage(message));
+	const sendPresenceSnapshot = Effect.gen(function* () {
+		if (!config.presence) return;
+		yield* sendMessage({
+			type: "presence_snapshot",
+			selfId: connectionId,
+			presences: (yield* presenceManager.getSnapshot(documentId)).presences
+		});
+	});
+	const handleAuth = (token) => Effect.gen(function* () {
+		const result = yield* authService.authenticate(token);
+		if (result.success) {
+			state = _objectSpread2(_objectSpread2({}, state), {}, {
+				authenticated: true,
+				userId: result.userId
+			});
+			yield* sendMessage({
+				type: "auth_result",
+				success: true
+			});
+			yield* sendPresenceSnapshot;
+		} else yield* sendMessage({
+			type: "auth_result",
+			success: false,
+			error: result.error
+		});
+	});
+	const handlePresenceSet = (data) => Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!config.presence) return;
+		const validated = Presence.validateSafe(config.presence, data);
+		if (validated === void 0) {
+			yield* Effect.logWarning("Invalid presence data received", {
+				connectionId,
+				data
+			});
+			return;
+		}
+		yield* presenceManager.set(documentId, connectionId, {
+			data: validated,
+			userId: state.userId
+		});
+		hasPresence = true;
+	});
+	const handlePresenceClear = Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!config.presence) return;
+		yield* presenceManager.remove(documentId, connectionId);
+		hasPresence = false;
+	});
+	const handleMessage = (message) => Effect.gen(function* () {
+		switch (message.type) {
+			case "auth":
+				yield* handleAuth(message.token);
+				break;
+			case "ping":
+				yield* sendMessage({ type: "pong" });
+				break;
+			case "submit":
+				if (!state.authenticated) {
+					yield* sendMessage({
+						type: "error",
+						transactionId: message.transaction.id,
+						reason: "Not authenticated"
+					});
+					return;
+				}
+				const submitResult = yield* documentManager.submit(documentId, message.transaction);
+				if (!submitResult.success) yield* sendMessage({
+					type: "error",
+					transactionId: message.transaction.id,
+					reason: submitResult.reason
+				});
+				break;
+			case "request_snapshot":
+				if (!state.authenticated) return;
+				yield* sendMessage(yield* documentManager.getSnapshot(documentId));
+				break;
+			case "presence_set":
+				yield* handlePresenceSet(message.data);
+				break;
+			case "presence_clear":
+				yield* handlePresenceClear;
+				break;
+		}
+	});
+	const subscribeFiber = yield* Effect.fork(Effect.gen(function* () {
+		while (!state.authenticated) yield* Effect.sleep(Duration.millis(100));
+		const broadcastStream = yield* documentManager.subscribe(documentId);
+		yield* Stream.runForEach(broadcastStream, (broadcast) => sendMessage(broadcast));
+	}).pipe(Effect.scoped));
+	const presenceFiber = yield* Effect.fork(Effect.gen(function* () {
+		if (!config.presence) return;
+		while (!state.authenticated) yield* Effect.sleep(Duration.millis(100));
+		const presenceStream = yield* presenceManager.subscribe(documentId);
+		yield* Stream.runForEach(presenceStream, (event) => Effect.gen(function* () {
+			if (event.id === connectionId) return;
+			if (event.type === "presence_update") yield* sendMessage({
+				type: "presence_update",
+				id: event.id,
+				data: event.data,
+				userId: event.userId
+			});
+			else if (event.type === "presence_remove") yield* sendMessage({
+				type: "presence_remove",
+				id: event.id
+			});
+		}));
+	}).pipe(Effect.scoped));
+	yield* Effect.addFinalizer(() => Effect.gen(function* () {
+		yield* Fiber.interrupt(subscribeFiber);
+		yield* Fiber.interrupt(presenceFiber);
+		if (hasPresence && config.presence) yield* presenceManager.remove(documentId, connectionId);
+	}));
+	yield* socket.runRaw((data) => Effect.gen(function* () {
+		yield* handleMessage(yield* parseClientMessage(data));
+	}).pipe(Effect.catchAll((error) => Effect.logError("Message handling error", error))));
+});
+
+//#endregion
+//#region src/storage/InMemoryDataStorage.ts
+/**
+* @since 0.0.1
+* In-memory data storage implementation for Mimic documents.
+* Provides ephemeral storage - data is lost when the server restarts.
+*/
+var InMemoryDataStorage_exports = /* @__PURE__ */ __export({
+	layer: () => layer$2,
+	layerDefault: () => layerDefault$1
+});
+/**
+* Create an in-memory storage service.
+* Uses a HashMap to store documents in memory.
+*/
+const makeInMemoryStorage = Effect.gen(function* () {
+	const store = yield* Ref.make(HashMap.empty());
+	return {
+		load: (documentId) => Effect.gen(function* () {
+			const current = yield* Ref.get(store);
+			const result = HashMap.get(current, documentId);
+			return result._tag === "Some" ? result.value : void 0;
+		}),
+		save: (documentId, state) => Ref.update(store, (map) => HashMap.set(map, documentId, state)),
+		delete: (documentId) => Ref.update(store, (map) => HashMap.remove(map, documentId)),
+		onLoad: (state) => Effect.succeed(state),
+		onSave: (state) => Effect.succeed(state)
+	};
+});
+/**
+* Layer that provides in-memory data storage.
+* This is the default storage implementation - ephemeral and non-persistent.
+*/
+const layer$2 = Layer.effect(MimicDataStorageTag, makeInMemoryStorage);
+/**
+* Default layer alias for convenience.
+*/
+const layerDefault$1 = layer$2;
+
+//#endregion
+//#region src/auth/NoAuth.ts
+/**
+* @since 0.0.1
+* No authentication implementation for Mimic connections.
+* All connections are automatically authenticated (open access).
+*/
+var NoAuth_exports = /* @__PURE__ */ __export({
+	layer: () => layer$1,
+	layerDefault: () => layerDefault
+});
+/**
+* Authentication service that auto-succeeds all authentication requests.
+* Use this for development or when authentication is handled externally.
+*/
+const noAuthService = { authenticate: (_token) => Effect.succeed({ success: true }) };
+/**
+* Layer that provides no authentication (open access).
+* All connections are automatically authenticated.
+* 
+* WARNING: Only use this for development or when authentication
+* is handled at a different layer (e.g., API gateway, reverse proxy).
+*/
+const layer$1 = Layer.succeed(MimicAuthServiceTag, noAuthService);
+/**
+* Default layer alias for convenience.
+*/
+const layerDefault = layer$1;
+
+//#endregion
+//#region src/MimicServer.ts
+/**
+* @since 0.0.1
+* Mimic server layer composition.
+*/
+var MimicServer_exports = /* @__PURE__ */ __export({
+	MimicWebSocketHandler: () => MimicWebSocketHandler,
+	documentManagerLayer: () => documentManagerLayer,
+	handlerLayer: () => handlerLayer,
+	layer: () => layer,
+	layerHttpLayerRouter: () => layerHttpLayerRouter,
+	run: () => run
+});
+/**
+* Tag for the WebSocket handler function.
+*/
+var MimicWebSocketHandler = class extends Context.Tag("@voidhash/mimic-server-effect/MimicWebSocketHandler")() {};
+/**
+* Create a Mimic WebSocket handler layer.
+* 
+* This layer provides a handler function that can be used with any WebSocket server
+* implementation. The handler takes a socket and document ID and manages the
+* document synchronization.
+* 
+* By default, uses in-memory storage and no authentication.
+* Override these by providing MimicDataStorage and MimicAuthService layers.
+* 
+* @example
+* ```typescript
+* import { MimicServer, MimicAuthService } from "@voidhash/mimic-effect";
+* import { Primitive } from "@voidhash/mimic";
+* 
+* const TodoSchema = Primitive.Struct({
+*   title: Primitive.String(),
+*   completed: Primitive.Boolean(),
+* });
+* 
+* // Create the handler layer with defaults
+* const HandlerLayer = MimicServer.layer({
+*   basePath: "/mimic/todo",
+*   schema: TodoSchema
+* });
+* 
+* // Or with custom auth
+* const HandlerLayerWithAuth = MimicServer.layer({
+*   basePath: "/mimic/todo",
+*   schema: TodoSchema
+* }).pipe(
+*   Layer.provideMerge(MimicAuthService.layer({
+*     authHandler: (token) => ({ success: true, userId: "user-123" })
+*   }))
+* );
+* ```
+*/
+const layer = (options) => {
+	const configLayer = layer$7({
+		schema: options.schema,
+		maxTransactionHistory: options.maxTransactionHistory,
+		presence: options.presence
+	});
+	return Layer.merge(Layer.effect(MimicWebSocketHandler, makeHandler).pipe(Layer.provide(layer$5), Layer.provide(layer$3), Layer.provide(configLayer)), layer$5.pipe(Layer.provide(configLayer))).pipe(Layer.provide(layerDefault$1), Layer.provide(layerDefault));
+};
+/**
+* Create the Mimic server handler layer.
+* This layer provides the WebSocket handler that can be used with any WebSocket server.
+*
+* @example
+* ```typescript
+* import { MimicServer } from "@voidhash/mimic-server-effect";
+* import { SocketServer } from "@effect/platform/SocketServer";
+* import { Primitive } from "@voidhash/mimic";
+*
+* // Define your document schema
+* const TodoSchema = Primitive.Struct({
+*   title: Primitive.String(),
+*   completed: Primitive.Boolean(),
+* });
+*
+* // Create the server layer
+* const serverLayer = MimicServer.handlerLayer({
+*   schema: TodoSchema,
+* });
+*
+* // Run with your socket server
+* Effect.gen(function* () {
+*   const handler = yield* MimicServer.MimicWebSocketHandler;
+*   const server = yield* SocketServer;
+*
+*   yield* server.run((socket) =>
+*     // Extract document ID from request and call handler
+*     handler(socket, "my-document-id")
+*   );
+* }).pipe(
+*   Effect.provide(serverLayer),
+*   Effect.provide(YourSocketServerLayer),
+* );
+* ```
+*/
+const handlerLayer = (options) => Layer.effect(MimicWebSocketHandler, makeHandler).pipe(Layer.provide(layer$5), Layer.provide(layer$3), Layer.provide(layer$7(options)), Layer.provide(layerDefault$1), Layer.provide(layerDefault));
+/**
+* Create the document manager layer.
+*/
+const documentManagerLayer = (options) => layer$5.pipe(Layer.provide(layer$7(options)), Layer.provide(layerDefault$1), Layer.provide(layerDefault));
+/**
+* Run a Mimic WebSocket server with the provided handler.
+*
+* This is a helper that:
+* 1. Gets the WebSocket handler from context
+* 2. Runs the socket server with the handler
+*
+* Note: The document ID extraction from socket is implementation-specific.
+* You may need to customize this based on your socket server.
+*/
+const run = (extractDocumentId$1) => Effect.gen(function* () {
+	const handler = yield* MimicWebSocketHandler;
+	yield* (yield* SocketServer).run((socket) => Effect.gen(function* () {
+		yield* handler(socket, yield* extractDocumentId$1(socket));
+	}).pipe(Effect.catchAll((error) => Effect.logError("Connection error", error))));
+});
+/**
+* Create the HTTP handler effect for WebSocket upgrade.
+* This handler:
+* 1. Extracts the document ID from the URL path
+* 2. Upgrades the HTTP connection to WebSocket
+* 3. Delegates to the WebSocketHandler for document sync
+*/
+const makeMimicHandler = Effect.gen(function* () {
+	const config = yield* MimicServerConfigTag;
+	const authService = yield* MimicAuthServiceTag;
+	const documentManager = yield* DocumentManagerTag;
+	const presenceManager = yield* PresenceManagerTag;
+	return Effect.gen(function* () {
+		const request = yield* HttpServerRequest.HttpServerRequest;
+		yield* extractDocumentId(request.url);
+		const socket = yield* request.upgrade;
+		yield* handleConnection(socket, request.url).pipe(Effect.provideService(MimicServerConfigTag, config), Effect.provideService(MimicAuthServiceTag, authService), Effect.provideService(DocumentManagerTag, documentManager), Effect.provideService(PresenceManagerTag, presenceManager), Effect.scoped, Effect.catchAll((error) => Effect.logError("WebSocket connection error", error)));
+		return HttpServerResponse.empty();
+	}).pipe(Effect.catchAll((error) => Effect.gen(function* () {
+		yield* Effect.logWarning("WebSocket upgrade failed", error);
+		return HttpServerResponse.text("WebSocket upgrade failed", { status: 400 });
+	})));
+});
+/**
+* Create a Mimic server layer that integrates with HttpLayerRouter.
+*
+* This function creates a layer that:
+* 1. Registers a WebSocket route at the specified base path
+* 2. Handles WebSocket upgrades for document sync
+* 3. Provides all required dependencies (config, auth, storage, document manager)
+*
+* By default, uses in-memory storage and no authentication.
+* To override these defaults, provide custom layers before the defaults:
+*
+* @example
+* ```typescript
+* import { MimicServer, MimicAuthService } from "@voidhash/mimic-effect";
+* import { HttpLayerRouter } from "@effect/platform";
+* import { Primitive } from "@voidhash/mimic";
+*
+* const TodoSchema = Primitive.Struct({
+*   title: Primitive.String(),
+*   completed: Primitive.Boolean(),
+* });
+*
+* // Create the Mimic route layer with defaults
+* const MimicRoute = MimicServer.layerHttpLayerRouter({
+*   basePath: "/mimic/todo",
+*   schema: TodoSchema
+* });
+*
+* // Or with custom auth - use Layer.provide to inject before defaults
+* const MimicRouteWithAuth = MimicServer.layerHttpLayerRouter({
+*   basePath: "/mimic/todo",
+*   schema: TodoSchema,
+*   authLayer: MimicAuthService.layer({
+*     authHandler: (token) => ({ success: true, userId: token })
+*   })
+* });
+*
+* // Merge with other routes and serve
+* const AllRoutes = Layer.mergeAll(MimicRoute, OtherRoutes);
+* HttpLayerRouter.serve(AllRoutes).pipe(
+*   Layer.provide(BunHttpServer.layer({ port: 3000 })),
+*   Layer.launch,
+*   BunRuntime.runMain
+* );
+* ```
+*/
+const layerHttpLayerRouter = (options) => {
+	var _options$basePath, _options$authLayer, _options$storageLayer;
+	const wsPath = `${(_options$basePath = options.basePath) !== null && _options$basePath !== void 0 ? _options$basePath : "/mimic"}/doc/*`;
+	const configLayer = layer$7({
+		schema: options.schema,
+		maxTransactionHistory: options.maxTransactionHistory,
+		presence: options.presence
+	});
+	const authLayer = (_options$authLayer = options.authLayer) !== null && _options$authLayer !== void 0 ? _options$authLayer : layerDefault;
+	const storageLayer = (_options$storageLayer = options.storageLayer) !== null && _options$storageLayer !== void 0 ? _options$storageLayer : layerDefault$1;
+	const registerRoute = Effect.gen(function* () {
+		const router = yield* HttpLayerRouter.HttpRouter;
+		const handler = yield* makeMimicHandler;
+		yield* router.add("GET", wsPath, handler);
+	});
+	return Layer.scopedDiscard(registerRoute).pipe(Layer.provide(layer$5), Layer.provide(layer$3), Layer.provide(configLayer), Layer.provide(storageLayer), Layer.provide(authLayer));
+};
+
+//#endregion
+//#region src/DocumentProtocol.ts
+/**
+* @since 0.0.1
+* Protocol and schema definitions for document communication.
+*/
+var DocumentProtocol_exports = /* @__PURE__ */ __export({
+	AuthResultMessageSchema: () => AuthResultMessageSchema,
+	ErrorMessageSchema: () => ErrorMessageSchema,
+	OperationSchema: () => OperationSchema,
+	PongMessageSchema: () => PongMessageSchema,
+	ServerBroadcastSchema: () => ServerBroadcastSchema,
+	SnapshotMessageSchema: () => SnapshotMessageSchema,
+	SubmitResultSchema: () => SubmitResultSchema,
+	TransactionMessageSchema: () => TransactionMessageSchema,
+	TransactionSchema: () => TransactionSchema
+});
+/**
+* Schema for a transaction operation.
+*/
+const OperationSchema = Schema.Struct({
+	kind: Schema.String,
+	path: Schema.Unknown,
+	payload: Schema.Unknown
+});
+/**
+* Schema for a transaction.
+*/
+const TransactionSchema = Schema.Struct({
+	id: Schema.String,
+	ops: Schema.Array(OperationSchema),
+	timestamp: Schema.Number
+});
+/**
+* Schema for a server message that broadcasts a committed transaction.
+*/
+const TransactionMessageSchema = Schema.Struct({
+	type: Schema.Literal("transaction"),
+	transaction: TransactionSchema,
+	version: Schema.Number
+});
+/**
+* Schema for a server message containing a snapshot.
+*/
+const SnapshotMessageSchema = Schema.Struct({
+	type: Schema.Literal("snapshot"),
+	state: Schema.Unknown,
+	version: Schema.Number
+});
+/**
+* Schema for a server error message.
+*/
+const ErrorMessageSchema = Schema.Struct({
+	type: Schema.Literal("error"),
+	transactionId: Schema.String,
+	reason: Schema.String
+});
+/**
+* Schema for a pong message.
+*/
+const PongMessageSchema = Schema.Struct({ type: Schema.Literal("pong") });
+/**
+* Schema for authentication result message.
+*/
+const AuthResultMessageSchema = Schema.Struct({
+	type: Schema.Literal("auth_result"),
+	success: Schema.Boolean,
+	error: Schema.optional(Schema.String)
+});
+/**
+* Union of all server broadcast messages.
+*/
+const ServerBroadcastSchema = Schema.Union(TransactionMessageSchema, ErrorMessageSchema);
+/**
+* Result of submitting a transaction.
+*/
+const SubmitResultSchema = Schema.Union(Schema.Struct({
+	success: Schema.Literal(true),
+	version: Schema.Number
+}), Schema.Struct({
+	success: Schema.Literal(false),
+	reason: Schema.String
+}));
+
+//#endregion
+export { AuthenticationError, DocumentManager_exports as DocumentManager, DocumentNotFoundError, DocumentProtocol_exports as DocumentProtocol, DocumentTypeNotFoundError, InvalidConnectionError, MessageParseError, MimicAuthService_exports as MimicAuthService, MimicConfig_exports as MimicConfig, MimicDataStorage_exports as MimicDataStorage, InMemoryDataStorage_exports as MimicInMemoryDataStorage, NoAuth_exports as MimicNoAuth, MimicServer_exports as MimicServer, MissingDocumentIdError, PresenceManager_exports as PresenceManager, TransactionRejectedError, WebSocketHandler_exports as WebSocketHandler };
+//# sourceMappingURL=index.mjs.map