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

package/dist/index.cjs

@@ -0,0 +1,1277 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let effect_Effect = require("effect/Effect");
+effect_Effect = __toESM(effect_Effect);
+let effect_Layer = require("effect/Layer");
+effect_Layer = __toESM(effect_Layer);
+let effect_Context = require("effect/Context");
+effect_Context = __toESM(effect_Context);
+let _effect_platform_SocketServer = require("@effect/platform/SocketServer");
+let effect_PubSub = require("effect/PubSub");
+effect_PubSub = __toESM(effect_PubSub);
+let effect_Ref = require("effect/Ref");
+effect_Ref = __toESM(effect_Ref);
+let effect_HashMap = require("effect/HashMap");
+effect_HashMap = __toESM(effect_HashMap);
+let effect_Stream = require("effect/Stream");
+effect_Stream = __toESM(effect_Stream);
+let _voidhash_mimic_server = require("@voidhash/mimic/server");
+let effect_Duration = require("effect/Duration");
+effect_Duration = __toESM(effect_Duration);
+let effect_Data = require("effect/Data");
+effect_Data = __toESM(effect_Data);
+let effect_Fiber = require("effect/Fiber");
+effect_Fiber = __toESM(effect_Fiber);
+let _voidhash_mimic = require("@voidhash/mimic");
+let _effect_platform = require("@effect/platform");
+let effect_Schema = require("effect/Schema");
+effect_Schema = __toESM(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: effect_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: effect_Duration.decode((_options$heartbeatInt = options.heartbeatInterval) !== null && _options$heartbeatInt !== void 0 ? _options$heartbeatInt : "30 seconds"),
+		heartbeatTimeout: effect_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 effect_Context.Tag("@voidhash/mimic-server-effect/MimicServerConfig")() {};
+/**
+* Create a Layer that provides MimicServerConfig.
+*/
+const layer$7 = (options) => effect_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 effect_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 effect_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 effect_Data.TaggedError("StorageDeleteError") {
+	get message() {
+		return `Failed to delete document ${this.documentId}: ${String(this.cause)}`;
+	}
+};
+/**
+* Context tag for MimicDataStorage service.
+*/
+var MimicDataStorageTag = class extends effect_Context.Tag("@voidhash/mimic-server-effect/MimicDataStorage")() {};
+/**
+* Create a MimicDataStorage layer from a storage implementation.
+*/
+const layer$6 = (storage) => effect_Layer.succeed(MimicDataStorageTag, storage);
+/**
+* Create a MimicDataStorage layer from an Effect that produces a storage implementation.
+*/
+const layerEffect$1 = (effect) => 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_Effect.void),
+		onLoad: (_options$onLoad = options.onLoad) !== null && _options$onLoad !== void 0 ? _options$onLoad : ((state) => effect_Effect.succeed(state)),
+		onSave: (_options$onSave = options.onSave) !== null && _options$onSave !== void 0 ? _options$onSave : ((state) => effect_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 effect_Context.Tag("@voidhash/mimic-server-effect/DocumentManager")() {};
+/**
+* Create the DocumentManager service.
+*/
+const makeDocumentManager = effect_Effect.gen(function* () {
+	const config = yield* MimicServerConfigTag;
+	const storage = yield* 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) : void 0;
+		const pubsub = yield* effect_PubSub.unbounded();
+		const serverDocument = _voidhash_mimic_server.ServerDocument.make({
+			schema: config.schema,
+			initialState,
+			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, {
+					type: "transaction",
+					transaction: transactionMessage.transaction,
+					version: transactionMessage.version
+				}));
+			},
+			onRejection: (transactionId, reason) => {
+				effect_Effect.runSync(effect_PubSub.publish(pubsub, {
+					type: "error",
+					transactionId,
+					reason
+				}));
+			}
+		});
+		const instance = {
+			document: serverDocument,
+			pubsub,
+			refCount: yield* effect_Ref.make(1)
+		};
+		yield* effect_Ref.update(documents, (map) => effect_HashMap.set(map, documentId, instance));
+		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();
+	});
+	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);
+		}));
+		return effect_Stream.fromQueue(queue);
+	});
+	return {
+		submit,
+		getSnapshot,
+		subscribe
+	};
+});
+/**
+* Layer that provides DocumentManager.
+* Requires MimicServerConfigTag and MimicDataStorageTag.
+*/
+const layer$5 = effect_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 effect_Context.Tag("@voidhash/mimic-server-effect/MimicAuthService")() {};
+/**
+* Create a MimicAuthService layer from an auth handler function.
+*/
+const layer$4 = (options) => effect_Layer.succeed(MimicAuthServiceTag, { authenticate: (token) => effect_Effect.promise(() => Promise.resolve(options.authHandler(token))) });
+/**
+* Create a MimicAuthService layer from an auth service implementation.
+*/
+const layerService = (service) => effect_Layer.succeed(MimicAuthServiceTag, service);
+/**
+* Create a MimicAuthService layer from an Effect that produces an auth service.
+*/
+const layerEffect = (effect) => effect_Layer.effect(MimicAuthServiceTag, effect);
+/**
+* Create an auth service from an auth handler function.
+*/
+const make = (authHandler) => ({ authenticate: (token) => effect_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 effect_Context.Tag("@voidhash/mimic-server-effect/PresenceManager")() {};
+/**
+* Create the PresenceManager service.
+*/
+const makePresenceManager = effect_Effect.gen(function* () {
+	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") return existing.value;
+		const docPresence = {
+			entries: yield* effect_Ref.make(effect_HashMap.empty()),
+			pubsub: yield* effect_PubSub.unbounded()
+		};
+		yield* effect_Ref.update(documents, (map) => effect_HashMap.set(map, documentId, docPresence));
+		return docPresence;
+	});
+	const getSnapshot = (documentId) => effect_Effect.gen(function* () {
+		const docPresence = yield* getOrCreateDocument(documentId);
+		const entriesMap = yield* effect_Ref.get(docPresence.entries);
+		const presences = {};
+		for (const [id, entry] of entriesMap) presences[id] = entry;
+		return { presences };
+	});
+	const set = (documentId, connectionId, entry) => effect_Effect.gen(function* () {
+		const docPresence = yield* getOrCreateDocument(documentId);
+		yield* effect_Ref.update(docPresence.entries, (map) => effect_HashMap.set(map, connectionId, entry));
+		yield* effect_PubSub.publish(docPresence.pubsub, {
+			type: "presence_update",
+			id: connectionId,
+			data: entry.data,
+			userId: entry.userId
+		});
+	});
+	const remove = (documentId, connectionId) => effect_Effect.gen(function* () {
+		const current = yield* effect_Ref.get(documents);
+		const existing = effect_HashMap.get(current, documentId);
+		if (existing._tag === "None") return;
+		const docPresence = existing.value;
+		const entries = yield* effect_Ref.get(docPresence.entries);
+		if (!effect_HashMap.has(entries, connectionId)) return;
+		yield* effect_Ref.update(docPresence.entries, (map) => effect_HashMap.remove(map, connectionId));
+		yield* effect_PubSub.publish(docPresence.pubsub, {
+			type: "presence_remove",
+			id: connectionId
+		});
+	});
+	const subscribe = (documentId) => effect_Effect.gen(function* () {
+		const docPresence = yield* getOrCreateDocument(documentId);
+		const queue = yield* effect_PubSub.subscribe(docPresence.pubsub);
+		return effect_Stream.fromQueue(queue);
+	});
+	return {
+		getSnapshot,
+		set,
+		remove,
+		subscribe
+	};
+});
+/**
+* Layer that provides PresenceManager.
+*/
+const layer$3 = effect_Layer.effect(PresenceManagerTag, makePresenceManager);
+/**
+* Default layer that provides PresenceManager.
+* Uses the default priority for layer composition.
+*/
+const layerDefault$2 = effect_Layer.effectDiscard(effect_Effect.succeed(void 0)).pipe(effect_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 effect_Data.TaggedError("DocumentTypeNotFoundError") {
+	get message() {
+		return `Document type not found: ${this.documentType}`;
+	}
+};
+/**
+* Error when a document is not found.
+*/
+var DocumentNotFoundError = class extends effect_Data.TaggedError("DocumentNotFoundError") {
+	get message() {
+		return `Document not found: ${this.documentId}`;
+	}
+};
+/**
+* Error when authentication fails.
+*/
+var AuthenticationError = class extends effect_Data.TaggedError("AuthenticationError") {
+	get message() {
+		return `Authentication failed: ${this.reason}`;
+	}
+};
+/**
+* Error when a transaction is rejected.
+*/
+var TransactionRejectedError = class extends effect_Data.TaggedError("TransactionRejectedError") {
+	get message() {
+		return `Transaction ${this.transactionId} rejected: ${this.reason}`;
+	}
+};
+/**
+* Error when parsing a client message fails.
+*/
+var MessageParseError = class extends effect_Data.TaggedError("MessageParseError") {
+	get message() {
+		return `Failed to parse message: ${String(this.cause)}`;
+	}
+};
+/**
+* Error when the WebSocket connection is invalid.
+*/
+var InvalidConnectionError = class extends effect_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 effect_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_Effect.succeed(decodeURIComponent(part));
+	return effect_Effect.fail(new MissingDocumentIdError({}));
+};
+/**
+* Decodes an encoded client message from the wire format.
+*/
+const decodeClientMessage = (encoded) => {
+	if (encoded.type === "submit") return {
+		type: "submit",
+		transaction: _voidhash_mimic.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: _voidhash_mimic.Transaction.encode(message.transaction),
+		version: message.version
+	};
+	return message;
+};
+const parseClientMessage = (data) => effect_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_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_Effect.gen(function* () {
+		if (!config.presence) return;
+		yield* sendMessage({
+			type: "presence_snapshot",
+			selfId: connectionId,
+			presences: (yield* presenceManager.getSnapshot(documentId)).presences
+		});
+	});
+	const handleAuth = (token) => effect_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_Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!config.presence) return;
+		const validated = _voidhash_mimic.Presence.validateSafe(config.presence, data);
+		if (validated === void 0) {
+			yield* effect_Effect.logWarning("Invalid presence data received", {
+				connectionId,
+				data
+			});
+			return;
+		}
+		yield* presenceManager.set(documentId, connectionId, {
+			data: validated,
+			userId: state.userId
+		});
+		hasPresence = true;
+	});
+	const handlePresenceClear = effect_Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!config.presence) return;
+		yield* presenceManager.remove(documentId, connectionId);
+		hasPresence = false;
+	});
+	const handleMessage = (message) => effect_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_Effect.catchAll(documentManager.getSnapshot(documentId), () => effect_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_Effect.fork(effect_Effect.gen(function* () {
+		while (!state.authenticated) yield* effect_Effect.sleep(effect_Duration.millis(100));
+		const broadcastStream = yield* effect_Effect.catchAll(documentManager.subscribe(documentId), () => effect_Effect.succeed(effect_Stream.empty));
+		yield* effect_Stream.runForEach(broadcastStream, (broadcast) => sendMessage(broadcast));
+	}).pipe(effect_Effect.scoped));
+	const presenceFiber = yield* effect_Effect.fork(effect_Effect.gen(function* () {
+		if (!config.presence) return;
+		while (!state.authenticated) yield* effect_Effect.sleep(effect_Duration.millis(100));
+		const presenceStream = yield* presenceManager.subscribe(documentId);
+		yield* effect_Stream.runForEach(presenceStream, (event) => effect_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_Effect.scoped));
+	yield* effect_Effect.addFinalizer(() => effect_Effect.gen(function* () {
+		yield* effect_Fiber.interrupt(subscribeFiber);
+		yield* effect_Fiber.interrupt(presenceFiber);
+		if (hasPresence && config.presence) yield* presenceManager.remove(documentId, connectionId);
+	}));
+	yield* socket.runRaw((data) => effect_Effect.gen(function* () {
+		yield* handleMessage(yield* parseClientMessage(data));
+	}).pipe(effect_Effect.catchAll((error) => effect_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_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_Effect.provideService(MimicServerConfigTag, config), effect_Effect.provideService(MimicAuthServiceTag, authService), effect_Effect.provideService(DocumentManagerTag, documentManager), effect_Effect.provideService(PresenceManagerTag, presenceManager), effect_Effect.scoped);
+});
+/**
+* Handle a WebSocket connection for a document (using document ID directly).
+*/
+const handleConnectionWithDocumentId = (socket, documentId) => effect_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_Effect.gen(function* () {
+		if (!config.presence) return;
+		yield* sendMessage({
+			type: "presence_snapshot",
+			selfId: connectionId,
+			presences: (yield* presenceManager.getSnapshot(documentId)).presences
+		});
+	});
+	const handleAuth = (token) => effect_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_Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!config.presence) return;
+		const validated = _voidhash_mimic.Presence.validateSafe(config.presence, data);
+		if (validated === void 0) {
+			yield* effect_Effect.logWarning("Invalid presence data received", {
+				connectionId,
+				data
+			});
+			return;
+		}
+		yield* presenceManager.set(documentId, connectionId, {
+			data: validated,
+			userId: state.userId
+		});
+		hasPresence = true;
+	});
+	const handlePresenceClear = effect_Effect.gen(function* () {
+		if (!state.authenticated) return;
+		if (!config.presence) return;
+		yield* presenceManager.remove(documentId, connectionId);
+		hasPresence = false;
+	});
+	const handleMessage = (message) => effect_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_Effect.fork(effect_Effect.gen(function* () {
+		while (!state.authenticated) yield* effect_Effect.sleep(effect_Duration.millis(100));
+		const broadcastStream = yield* documentManager.subscribe(documentId);
+		yield* effect_Stream.runForEach(broadcastStream, (broadcast) => sendMessage(broadcast));
+	}).pipe(effect_Effect.scoped));
+	const presenceFiber = yield* effect_Effect.fork(effect_Effect.gen(function* () {
+		if (!config.presence) return;
+		while (!state.authenticated) yield* effect_Effect.sleep(effect_Duration.millis(100));
+		const presenceStream = yield* presenceManager.subscribe(documentId);
+		yield* effect_Stream.runForEach(presenceStream, (event) => effect_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_Effect.scoped));
+	yield* effect_Effect.addFinalizer(() => effect_Effect.gen(function* () {
+		yield* effect_Fiber.interrupt(subscribeFiber);
+		yield* effect_Fiber.interrupt(presenceFiber);
+		if (hasPresence && config.presence) yield* presenceManager.remove(documentId, connectionId);
+	}));
+	yield* socket.runRaw((data) => effect_Effect.gen(function* () {
+		yield* handleMessage(yield* parseClientMessage(data));
+	}).pipe(effect_Effect.catchAll((error) => effect_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_Effect.gen(function* () {
+	const store = yield* effect_Ref.make(effect_HashMap.empty());
+	return {
+		load: (documentId) => effect_Effect.gen(function* () {
+			const current = yield* effect_Ref.get(store);
+			const result = effect_HashMap.get(current, documentId);
+			return result._tag === "Some" ? result.value : void 0;
+		}),
+		save: (documentId, state) => effect_Ref.update(store, (map) => effect_HashMap.set(map, documentId, state)),
+		delete: (documentId) => effect_Ref.update(store, (map) => effect_HashMap.remove(map, documentId)),
+		onLoad: (state) => effect_Effect.succeed(state),
+		onSave: (state) => effect_Effect.succeed(state)
+	};
+});
+/**
+* Layer that provides in-memory data storage.
+* This is the default storage implementation - ephemeral and non-persistent.
+*/
+const layer$2 = effect_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_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 = effect_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 effect_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 effect_Layer.merge(effect_Layer.effect(MimicWebSocketHandler, makeHandler).pipe(effect_Layer.provide(layer$5), effect_Layer.provide(layer$3), effect_Layer.provide(configLayer)), layer$5.pipe(effect_Layer.provide(configLayer))).pipe(effect_Layer.provide(layerDefault$1), effect_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) => effect_Layer.effect(MimicWebSocketHandler, makeHandler).pipe(effect_Layer.provide(layer$5), effect_Layer.provide(layer$3), effect_Layer.provide(layer$7(options)), effect_Layer.provide(layerDefault$1), effect_Layer.provide(layerDefault));
+/**
+* Create the document manager layer.
+*/
+const documentManagerLayer = (options) => layer$5.pipe(effect_Layer.provide(layer$7(options)), effect_Layer.provide(layerDefault$1), effect_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_Effect.gen(function* () {
+	const handler = yield* MimicWebSocketHandler;
+	yield* (yield* _effect_platform_SocketServer.SocketServer).run((socket) => effect_Effect.gen(function* () {
+		yield* handler(socket, yield* extractDocumentId$1(socket));
+	}).pipe(effect_Effect.catchAll((error) => effect_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_Effect.gen(function* () {
+	const config = yield* MimicServerConfigTag;
+	const authService = yield* MimicAuthServiceTag;
+	const documentManager = yield* DocumentManagerTag;
+	const presenceManager = yield* PresenceManagerTag;
+	return effect_Effect.gen(function* () {
+		const request = yield* _effect_platform.HttpServerRequest.HttpServerRequest;
+		yield* extractDocumentId(request.url);
+		const socket = yield* request.upgrade;
+		yield* handleConnection(socket, request.url).pipe(effect_Effect.provideService(MimicServerConfigTag, config), effect_Effect.provideService(MimicAuthServiceTag, authService), effect_Effect.provideService(DocumentManagerTag, documentManager), effect_Effect.provideService(PresenceManagerTag, presenceManager), effect_Effect.scoped, effect_Effect.catchAll((error) => effect_Effect.logError("WebSocket connection error", error)));
+		return _effect_platform.HttpServerResponse.empty();
+	}).pipe(effect_Effect.catchAll((error) => effect_Effect.gen(function* () {
+		yield* effect_Effect.logWarning("WebSocket upgrade failed", error);
+		return _effect_platform.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_Effect.gen(function* () {
+		const router = yield* _effect_platform.HttpLayerRouter.HttpRouter;
+		const handler = yield* makeMimicHandler;
+		yield* router.add("GET", wsPath, handler);
+	});
+	return effect_Layer.scopedDiscard(registerRoute).pipe(effect_Layer.provide(layer$5), effect_Layer.provide(layer$3), effect_Layer.provide(configLayer), effect_Layer.provide(storageLayer), effect_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 = effect_Schema.Struct({
+	kind: effect_Schema.String,
+	path: effect_Schema.Unknown,
+	payload: effect_Schema.Unknown
+});
+/**
+* Schema for a transaction.
+*/
+const TransactionSchema = effect_Schema.Struct({
+	id: effect_Schema.String,
+	ops: effect_Schema.Array(OperationSchema),
+	timestamp: effect_Schema.Number
+});
+/**
+* Schema for a server message that broadcasts a committed transaction.
+*/
+const TransactionMessageSchema = effect_Schema.Struct({
+	type: effect_Schema.Literal("transaction"),
+	transaction: TransactionSchema,
+	version: effect_Schema.Number
+});
+/**
+* Schema for a server message containing a snapshot.
+*/
+const SnapshotMessageSchema = effect_Schema.Struct({
+	type: effect_Schema.Literal("snapshot"),
+	state: effect_Schema.Unknown,
+	version: effect_Schema.Number
+});
+/**
+* Schema for a server error message.
+*/
+const ErrorMessageSchema = effect_Schema.Struct({
+	type: effect_Schema.Literal("error"),
+	transactionId: effect_Schema.String,
+	reason: effect_Schema.String
+});
+/**
+* Schema for a pong message.
+*/
+const PongMessageSchema = effect_Schema.Struct({ type: effect_Schema.Literal("pong") });
+/**
+* Schema for authentication result message.
+*/
+const AuthResultMessageSchema = effect_Schema.Struct({
+	type: effect_Schema.Literal("auth_result"),
+	success: effect_Schema.Boolean,
+	error: effect_Schema.optional(effect_Schema.String)
+});
+/**
+* Union of all server broadcast messages.
+*/
+const ServerBroadcastSchema = effect_Schema.Union(TransactionMessageSchema, ErrorMessageSchema);
+/**
+* Result of submitting a transaction.
+*/
+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
+}));
+
+//#endregion
+exports.AuthenticationError = AuthenticationError;
+Object.defineProperty(exports, 'DocumentManager', {
+  enumerable: true,
+  get: function () {
+    return DocumentManager_exports;
+  }
+});
+exports.DocumentNotFoundError = DocumentNotFoundError;
+Object.defineProperty(exports, 'DocumentProtocol', {
+  enumerable: true,
+  get: function () {
+    return DocumentProtocol_exports;
+  }
+});
+exports.DocumentTypeNotFoundError = DocumentTypeNotFoundError;
+exports.InvalidConnectionError = InvalidConnectionError;
+exports.MessageParseError = MessageParseError;
+Object.defineProperty(exports, 'MimicAuthService', {
+  enumerable: true,
+  get: function () {
+    return MimicAuthService_exports;
+  }
+});
+Object.defineProperty(exports, 'MimicConfig', {
+  enumerable: true,
+  get: function () {
+    return MimicConfig_exports;
+  }
+});
+Object.defineProperty(exports, 'MimicDataStorage', {
+  enumerable: true,
+  get: function () {
+    return MimicDataStorage_exports;
+  }
+});
+Object.defineProperty(exports, 'MimicInMemoryDataStorage', {
+  enumerable: true,
+  get: function () {
+    return InMemoryDataStorage_exports;
+  }
+});
+Object.defineProperty(exports, 'MimicNoAuth', {
+  enumerable: true,
+  get: function () {
+    return NoAuth_exports;
+  }
+});
+Object.defineProperty(exports, 'MimicServer', {
+  enumerable: true,
+  get: function () {
+    return MimicServer_exports;
+  }
+});
+exports.MissingDocumentIdError = MissingDocumentIdError;
+Object.defineProperty(exports, 'PresenceManager', {
+  enumerable: true,
+  get: function () {
+    return PresenceManager_exports;
+  }
+});
+exports.TransactionRejectedError = TransactionRejectedError;
+Object.defineProperty(exports, 'WebSocketHandler', {
+  enumerable: true,
+  get: function () {
+    return WebSocketHandler_exports;
+  }
+});