@voidhash/mimic 0.0.1-alpha.1 → 0.0.1-alpha.10

package/dist/client/index.mjs

@@ -0,0 +1,1413 @@
+import { t as __export } from "../chunk-CLMFDpHK.mjs";
+import { a as encode, d as isPrefix, f as pathsEqual, i as decode, m as _defineProperty, n as make$3, o as isEmpty, p as pathsOverlap } from "../Document-CwiAFTIq.mjs";
+import { n as validate, r as _objectSpread2, t as Presence_exports } from "../Presence-DdMVKcOv.mjs";
+
+//#region src/client/Rebase.ts
+var Rebase_exports = /* @__PURE__ */ __export({
+	rebaseAfterRejection: () => rebaseAfterRejection,
+	rebaseAfterRejectionWithPrimitive: () => rebaseAfterRejectionWithPrimitive,
+	rebasePendingTransactions: () => rebasePendingTransactions,
+	rebasePendingTransactionsWithPrimitive: () => rebasePendingTransactionsWithPrimitive,
+	transformOperation: () => transformOperation,
+	transformOperationWithPrimitive: () => transformOperationWithPrimitive,
+	transformTransaction: () => transformTransaction,
+	transformTransactionWithPrimitive: () => transformTransactionWithPrimitive
+});
+/**
+* Transforms a client operation against a server operation using a primitive.
+* 
+* This delegates to the primitive's transformOperation method, which handles
+* type-specific conflict resolution.
+* 
+* @param clientOp - The client's operation to transform
+* @param serverOp - The server's operation that has already been applied
+* @param primitive - The root primitive to use for transformation
+* @returns TransformResult indicating how the client operation should be handled
+*/
+const transformOperationWithPrimitive = (clientOp, serverOp, primitive) => {
+	return primitive._internal.transformOperation(clientOp, serverOp);
+};
+/**
+* Transforms a client operation against a server operation.
+*
+* This is a standalone implementation for cases where the primitive is not available.
+* For schema-aware transformation, use transformOperationWithPrimitive instead.
+*
+* The key principle: client ops "shadow" server ops for the same path,
+* meaning if both touch the same field, the client's intention wins
+* (since it was made with knowledge of the server state at that time).
+*/
+const transformOperation = (clientOp, serverOp) => {
+	const clientPath = clientOp.path;
+	const serverPath = serverOp.path;
+	if (!pathsOverlap(clientPath, serverPath)) return {
+		type: "transformed",
+		operation: clientOp
+	};
+	if (serverOp.kind === "array.remove") {
+		const removedId = serverOp.payload.id;
+		const clientTokens = clientPath.toTokens().filter((t) => t !== "");
+		const serverTokens = serverPath.toTokens().filter((t) => t !== "");
+		if (clientTokens.length > serverTokens.length) {
+			if (clientTokens[serverTokens.length] === removedId) return { type: "noop" };
+		}
+	}
+	if (serverOp.kind === "array.insert" && clientOp.kind === "array.insert") return {
+		type: "transformed",
+		operation: clientOp
+	};
+	if (serverOp.kind === "array.move" && clientOp.kind === "array.move") {
+		if (serverOp.payload.id === clientOp.payload.id) return {
+			type: "transformed",
+			operation: clientOp
+		};
+		return {
+			type: "transformed",
+			operation: clientOp
+		};
+	}
+	if (pathsEqual(clientPath, serverPath)) return {
+		type: "transformed",
+		operation: clientOp
+	};
+	if (isPrefix(serverPath, clientPath)) {
+		const serverKind = serverOp.kind;
+		if (serverKind === "struct.set" || serverKind === "array.set" || serverKind === "union.set") return {
+			type: "transformed",
+			operation: clientOp
+		};
+	}
+	return {
+		type: "transformed",
+		operation: clientOp
+	};
+};
+/**
+* Transforms all operations in a client transaction against a server transaction.
+* Uses the primitive's transformOperation for schema-aware transformation.
+*/
+const transformTransactionWithPrimitive = (clientTx, serverTx, primitive) => {
+	const transformedOps = [];
+	for (const clientOp of clientTx.ops) {
+		let currentOp = clientOp;
+		for (const serverOp of serverTx.ops) {
+			if (currentOp === null) break;
+			const result = transformOperationWithPrimitive(currentOp, serverOp, primitive);
+			switch (result.type) {
+				case "transformed":
+					currentOp = result.operation;
+					break;
+				case "noop":
+					currentOp = null;
+					break;
+				case "conflict": break;
+			}
+		}
+		if (currentOp !== null) transformedOps.push(currentOp);
+	}
+	return {
+		id: clientTx.id,
+		ops: transformedOps,
+		timestamp: clientTx.timestamp
+	};
+};
+/**
+* Transforms all operations in a client transaction against a server transaction.
+* This is a standalone version that doesn't require a primitive.
+*/
+const transformTransaction = (clientTx, serverTx) => {
+	const transformedOps = [];
+	for (const clientOp of clientTx.ops) {
+		let currentOp = clientOp;
+		for (const serverOp of serverTx.ops) {
+			if (currentOp === null) break;
+			const result = transformOperation(currentOp, serverOp);
+			switch (result.type) {
+				case "transformed":
+					currentOp = result.operation;
+					break;
+				case "noop":
+					currentOp = null;
+					break;
+				case "conflict": break;
+			}
+		}
+		if (currentOp !== null) transformedOps.push(currentOp);
+	}
+	return {
+		id: clientTx.id,
+		ops: transformedOps,
+		timestamp: clientTx.timestamp
+	};
+};
+/**
+* Rebases a list of pending transactions against a server transaction using a primitive.
+*
+* This is called when a server transaction arrives that is NOT one of our pending
+* transactions. We need to transform all pending transactions to work correctly
+* on top of the new server state.
+*/
+const rebasePendingTransactionsWithPrimitive = (pendingTxs, serverTx, primitive) => {
+	return pendingTxs.map((pendingTx) => transformTransactionWithPrimitive(pendingTx, serverTx, primitive));
+};
+/**
+* Rebases a list of pending transactions against a server transaction.
+*
+* This is called when a server transaction arrives that is NOT one of our pending
+* transactions. We need to transform all pending transactions to work correctly
+* on top of the new server state.
+*/
+const rebasePendingTransactions = (pendingTxs, serverTx) => {
+	return pendingTxs.map((pendingTx) => transformTransaction(pendingTx, serverTx));
+};
+/**
+* Rebases pending transactions after a rejection using a primitive.
+*
+* When a transaction is rejected, we need to re-transform remaining pending
+* transactions as if the rejected transaction never happened. This is done by
+* rebuilding from the original operations against the current server state.
+*
+* @param originalPendingTxs - The original pending transactions before any rebasing
+* @param rejectedTxId - ID of the rejected transaction
+* @param serverTxsSinceOriginal - Server transactions that have arrived since original
+* @param primitive - The root primitive to use for transformation
+*/
+const rebaseAfterRejectionWithPrimitive = (originalPendingTxs, rejectedTxId, serverTxsSinceOriginal, primitive) => {
+	let result = [...originalPendingTxs.filter((tx) => tx.id !== rejectedTxId)];
+	for (const serverTx of serverTxsSinceOriginal) result = rebasePendingTransactionsWithPrimitive(result, serverTx, primitive);
+	return result;
+};
+/**
+* Rebases pending transactions after a rejection.
+*
+* When a transaction is rejected, we need to re-transform remaining pending
+* transactions as if the rejected transaction never happened. This is done by
+* rebuilding from the original operations against the current server state.
+*
+* @param originalPendingTxs - The original pending transactions before any rebasing
+* @param rejectedTxId - ID of the rejected transaction
+* @param serverTxsSinceOriginal - Server transactions that have arrived since original
+*/
+const rebaseAfterRejection = (originalPendingTxs, rejectedTxId, serverTxsSinceOriginal) => {
+	let result = [...originalPendingTxs.filter((tx) => tx.id !== rejectedTxId)];
+	for (const serverTx of serverTxsSinceOriginal) result = rebasePendingTransactions(result, serverTx);
+	return result;
+};
+
+//#endregion
+//#region src/client/errors.ts
+/**
+* Base error class for all mimic-client errors.
+*/
+var MimicClientError = class extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "_tag", "MimicClientError");
+		this.name = "MimicClientError";
+	}
+};
+/**
+* Error thrown when a transaction is rejected by the server.
+*/
+var TransactionRejectedError = class extends MimicClientError {
+	constructor(transaction, reason) {
+		super(`Transaction ${transaction.id} rejected: ${reason}`);
+		_defineProperty(this, "_tag", "TransactionRejectedError");
+		_defineProperty(this, "transaction", void 0);
+		_defineProperty(this, "reason", void 0);
+		this.name = "TransactionRejectedError";
+		this.transaction = transaction;
+		this.reason = reason;
+	}
+};
+/**
+* Error thrown when the transport is not connected.
+*/
+var NotConnectedError = class extends MimicClientError {
+	constructor() {
+		super("Transport is not connected");
+		_defineProperty(this, "_tag", "NotConnectedError");
+		this.name = "NotConnectedError";
+	}
+};
+/**
+* Error thrown when connection to the server fails.
+*/
+var ConnectionError = class extends MimicClientError {
+	constructor(message, cause) {
+		super(message);
+		_defineProperty(this, "_tag", "ConnectionError");
+		_defineProperty(this, "cause", void 0);
+		this.name = "ConnectionError";
+		this.cause = cause;
+	}
+};
+/**
+* Error thrown when state drift is detected and cannot be recovered.
+*/
+var StateDriftError = class extends MimicClientError {
+	constructor(expectedVersion, receivedVersion) {
+		super(`State drift detected: expected version ${expectedVersion}, received ${receivedVersion}`);
+		_defineProperty(this, "_tag", "StateDriftError");
+		_defineProperty(this, "expectedVersion", void 0);
+		_defineProperty(this, "receivedVersion", void 0);
+		this.name = "StateDriftError";
+		this.expectedVersion = expectedVersion;
+		this.receivedVersion = receivedVersion;
+	}
+};
+/**
+* Error thrown when a pending transaction times out waiting for confirmation.
+*/
+var TransactionTimeoutError = class extends MimicClientError {
+	constructor(transaction, timeoutMs) {
+		super(`Transaction ${transaction.id} timed out after ${timeoutMs}ms waiting for confirmation`);
+		_defineProperty(this, "_tag", "TransactionTimeoutError");
+		_defineProperty(this, "transaction", void 0);
+		_defineProperty(this, "timeoutMs", void 0);
+		this.name = "TransactionTimeoutError";
+		this.transaction = transaction;
+		this.timeoutMs = timeoutMs;
+	}
+};
+/**
+* Error thrown when rebasing operations fails.
+*/
+var RebaseError = class extends MimicClientError {
+	constructor(transactionId, message) {
+		super(`Failed to rebase transaction ${transactionId}: ${message}`);
+		_defineProperty(this, "_tag", "RebaseError");
+		_defineProperty(this, "transactionId", void 0);
+		this.name = "RebaseError";
+		this.transactionId = transactionId;
+	}
+};
+/**
+* Error thrown when the client document is in an invalid state.
+*/
+var InvalidStateError = class extends MimicClientError {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "_tag", "InvalidStateError");
+		this.name = "InvalidStateError";
+	}
+};
+/**
+* Error thrown when WebSocket connection or communication fails.
+*/
+var WebSocketError = class extends MimicClientError {
+	constructor(message, code, reason) {
+		super(message);
+		_defineProperty(this, "_tag", "WebSocketError");
+		_defineProperty(this, "code", void 0);
+		_defineProperty(this, "reason", void 0);
+		this.name = "WebSocketError";
+		this.code = code;
+		this.reason = reason;
+	}
+};
+/**
+* Error thrown when authentication fails.
+*/
+var AuthenticationError = class extends MimicClientError {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "_tag", "AuthenticationError");
+		this.name = "AuthenticationError";
+	}
+};
+
+//#endregion
+//#region src/client/ClientDocument.ts
+var ClientDocument_exports = /* @__PURE__ */ __export({ make: () => make$2 });
+/**
+* Creates a new ClientDocument for the given schema.
+*/
+const make$2 = (options) => {
+	const { schema, transport, initialState, initialVersion = 0, onRejection, onStateChange, onConnectionChange, onReady, transactionTimeout = 3e4, initTimeout = 1e4, debug = false, presence: presenceSchema, initialPresence } = options;
+	let _serverState = initialState;
+	let _serverVersion = initialVersion;
+	let _pending = [];
+	let _serverTransactionHistory = [];
+	const MAX_HISTORY_SIZE = 100;
+	let _optimisticDoc = make$3(schema, { initial: _serverState });
+	let _unsubscribe = null;
+	const _timeoutHandles = /* @__PURE__ */ new Map();
+	let _initState = initialState !== void 0 ? { type: "ready" } : { type: "uninitialized" };
+	let _initTimeoutHandle = null;
+	let _initResolver = null;
+	let _initRejecter = null;
+	const _subscribers = /* @__PURE__ */ new Set();
+	let _presenceSelfId = void 0;
+	let _presenceSelfData = void 0;
+	const _presenceOthers = /* @__PURE__ */ new Map();
+	const _presenceSubscribers = /* @__PURE__ */ new Set();
+	/**
+	* Debug logging helper that only logs when debug is enabled.
+	*/
+	const debugLog = (...args) => {
+		if (debug) console.log("[ClientDocument]", ...args);
+	};
+	/**
+	* Notifies all listeners of a state change.
+	*/
+	const notifyStateChange = (state) => {
+		debugLog("notifyStateChange", {
+			state,
+			subscriberCount: _subscribers.size,
+			hasOnStateChange: !!onStateChange
+		});
+		onStateChange === null || onStateChange === void 0 || onStateChange(state);
+		for (const listener of _subscribers) {
+			var _listener$onStateChan;
+			(_listener$onStateChan = listener.onStateChange) === null || _listener$onStateChan === void 0 || _listener$onStateChan.call(listener, state);
+		}
+	};
+	/**
+	* Notifies all listeners of a connection change.
+	*/
+	const notifyConnectionChange = (connected) => {
+		debugLog("notifyConnectionChange", {
+			connected,
+			subscriberCount: _subscribers.size,
+			hasOnConnectionChange: !!onConnectionChange
+		});
+		onConnectionChange === null || onConnectionChange === void 0 || onConnectionChange(connected);
+		for (const listener of _subscribers) {
+			var _listener$onConnectio;
+			(_listener$onConnectio = listener.onConnectionChange) === null || _listener$onConnectio === void 0 || _listener$onConnectio.call(listener, connected);
+		}
+	};
+	/**
+	* Notifies all listeners when ready.
+	*/
+	const notifyReady = () => {
+		debugLog("notifyReady", {
+			subscriberCount: _subscribers.size,
+			hasOnReady: !!onReady
+		});
+		onReady === null || onReady === void 0 || onReady();
+		for (const listener of _subscribers) {
+			var _listener$onReady;
+			(_listener$onReady = listener.onReady) === null || _listener$onReady === void 0 || _listener$onReady.call(listener);
+		}
+	};
+	/**
+	* Notifies all presence listeners of a change.
+	*/
+	const notifyPresenceChange = () => {
+		debugLog("notifyPresenceChange", { subscriberCount: _presenceSubscribers.size });
+		for (const listener of _presenceSubscribers) try {
+			var _listener$onPresenceC;
+			(_listener$onPresenceC = listener.onPresenceChange) === null || _listener$onPresenceC === void 0 || _listener$onPresenceC.call(listener);
+		} catch (_unused) {}
+	};
+	/**
+	* Handles incoming presence snapshot from server.
+	*/
+	const handlePresenceSnapshot = (message) => {
+		if (!presenceSchema) return;
+		debugLog("handlePresenceSnapshot", {
+			selfId: message.selfId,
+			presenceCount: Object.keys(message.presences).length
+		});
+		_presenceSelfId = message.selfId;
+		_presenceOthers.clear();
+		for (const [id, entry] of Object.entries(message.presences)) if (id !== message.selfId) _presenceOthers.set(id, entry);
+		notifyPresenceChange();
+	};
+	/**
+	* Handles incoming presence update from server (another user).
+	*/
+	const handlePresenceUpdate = (message) => {
+		if (!presenceSchema) return;
+		debugLog("handlePresenceUpdate", {
+			id: message.id,
+			userId: message.userId
+		});
+		_presenceOthers.set(message.id, {
+			data: message.data,
+			userId: message.userId
+		});
+		notifyPresenceChange();
+	};
+	/**
+	* Handles incoming presence remove from server (user disconnected).
+	*/
+	const handlePresenceRemove = (message) => {
+		if (!presenceSchema) return;
+		debugLog("handlePresenceRemove", { id: message.id });
+		_presenceOthers.delete(message.id);
+		notifyPresenceChange();
+	};
+	/**
+	* Clears all presence state (on disconnect).
+	*/
+	const clearPresenceState = () => {
+		_presenceSelfId = void 0;
+		_presenceSelfData = void 0;
+		_presenceOthers.clear();
+		notifyPresenceChange();
+	};
+	/**
+	* Recomputes the optimistic document from server state + pending transactions.
+	*/
+	const recomputeOptimisticState = () => {
+		debugLog("recomputeOptimisticState", {
+			serverVersion: _serverVersion,
+			pendingCount: _pending.length,
+			serverState: _serverState
+		});
+		_optimisticDoc = make$3(schema, { initial: _serverState });
+		for (const pending of _pending) _optimisticDoc.apply(pending.transaction.ops);
+		const newState = _optimisticDoc.get();
+		debugLog("recomputeOptimisticState: new optimistic state", newState);
+		notifyStateChange(newState);
+	};
+	/**
+	* Adds a transaction to pending queue and sends to server.
+	*/
+	const submitTransaction = (tx) => {
+		if (!transport.isConnected()) throw new NotConnectedError();
+		debugLog("submitTransaction", {
+			txId: tx.id,
+			ops: tx.ops,
+			pendingCount: _pending.length + 1
+		});
+		const pending = {
+			transaction: tx,
+			original: tx,
+			sentAt: Date.now()
+		};
+		_pending.push(pending);
+		const timeoutHandle = setTimeout(() => {
+			handleTransactionTimeout(tx.id);
+		}, transactionTimeout);
+		_timeoutHandles.set(tx.id, timeoutHandle);
+		transport.send(tx);
+		debugLog("submitTransaction: sent to server", { txId: tx.id });
+	};
+	/**
+	* Handles a transaction timeout.
+	*/
+	const handleTransactionTimeout = (txId) => {
+		debugLog("handleTransactionTimeout", { txId });
+		const index = _pending.findIndex((p) => p.transaction.id === txId);
+		if (index === -1) {
+			debugLog("handleTransactionTimeout: transaction not found (already confirmed/rejected)", { txId });
+			return;
+		}
+		const [removed] = _pending.splice(index, 1);
+		_timeoutHandles.delete(txId);
+		debugLog("handleTransactionTimeout: removed from pending", {
+			txId,
+			remainingPending: _pending.length
+		});
+		recomputeOptimisticState();
+		onRejection === null || onRejection === void 0 || onRejection(removed.transaction, "Transaction timed out");
+	};
+	/**
+	* Handles an incoming server transaction.
+	*/
+	const handleServerTransaction = (serverTx, version) => {
+		debugLog("handleServerTransaction", {
+			txId: serverTx.id,
+			version,
+			ops: serverTx.ops,
+			currentServerVersion: _serverVersion,
+			pendingCount: _pending.length
+		});
+		_serverVersion = version;
+		const pendingIndex = _pending.findIndex((p) => p.transaction.id === serverTx.id);
+		if (pendingIndex !== -1) {
+			debugLog("handleServerTransaction: transaction confirmed (ACK)", {
+				txId: serverTx.id,
+				pendingIndex
+			});
+			_pending[pendingIndex];
+			const timeoutHandle = _timeoutHandles.get(serverTx.id);
+			if (timeoutHandle) {
+				clearTimeout(timeoutHandle);
+				_timeoutHandles.delete(serverTx.id);
+			}
+			_pending.splice(pendingIndex, 1);
+			const tempDoc = make$3(schema, { initial: _serverState });
+			tempDoc.apply(serverTx.ops);
+			_serverState = tempDoc.get();
+			debugLog("handleServerTransaction: updated server state", {
+				txId: serverTx.id,
+				newServerState: _serverState,
+				remainingPending: _pending.length
+			});
+			recomputeOptimisticState();
+		} else {
+			debugLog("handleServerTransaction: remote transaction, rebasing pending", {
+				txId: serverTx.id,
+				pendingCount: _pending.length
+			});
+			const tempDoc = make$3(schema, { initial: _serverState });
+			tempDoc.apply(serverTx.ops);
+			_serverState = tempDoc.get();
+			_serverTransactionHistory.push(serverTx);
+			if (_serverTransactionHistory.length > MAX_HISTORY_SIZE) _serverTransactionHistory.shift();
+			const rebasedPending = _pending.map((p) => _objectSpread2(_objectSpread2({}, p), {}, { transaction: transformTransactionWithPrimitive(p.transaction, serverTx, schema) }));
+			debugLog("handleServerTransaction: rebased pending transactions", {
+				txId: serverTx.id,
+				rebasedCount: rebasedPending.length,
+				originalPendingIds: _pending.map((p) => p.transaction.id),
+				rebasedPendingIds: rebasedPending.map((p) => p.transaction.id)
+			});
+			_pending = rebasedPending;
+			recomputeOptimisticState();
+		}
+	};
+	/**
+	* Handles a transaction rejection from the server.
+	*/
+	const handleRejection = (txId, reason) => {
+		debugLog("handleRejection", {
+			txId,
+			reason,
+			pendingCount: _pending.length
+		});
+		const index = _pending.findIndex((p) => p.transaction.id === txId);
+		if (index === -1) {
+			debugLog("handleRejection: transaction not found (already removed)", { txId });
+			return;
+		}
+		const rejected = _pending[index];
+		const timeoutHandle = _timeoutHandles.get(txId);
+		if (timeoutHandle) {
+			clearTimeout(timeoutHandle);
+			_timeoutHandles.delete(txId);
+		}
+		_pending.splice(index, 1);
+		debugLog("handleRejection: removed rejected transaction, rebasing remaining", {
+			txId,
+			remainingPending: _pending.length,
+			serverHistorySize: _serverTransactionHistory.length
+		});
+		const remainingOriginals = _pending.map((p) => p.original);
+		const retransformed = rebaseAfterRejectionWithPrimitive([...remainingOriginals, rejected.original], txId, _serverTransactionHistory, schema);
+		_pending = _pending.map((p, i) => {
+			var _retransformed$i;
+			return _objectSpread2(_objectSpread2({}, p), {}, { transaction: (_retransformed$i = retransformed[i]) !== null && _retransformed$i !== void 0 ? _retransformed$i : p.transaction });
+		});
+		debugLog("handleRejection: rebased remaining transactions", {
+			txId,
+			rebasedCount: _pending.length
+		});
+		recomputeOptimisticState();
+		onRejection === null || onRejection === void 0 || onRejection(rejected.original, reason);
+	};
+	/**
+	* Handles a snapshot from the server.
+	* @param isInitialSnapshot - If true, this is the initial sync snapshot
+	*/
+	const handleSnapshot = (state, version, isInitialSnapshot = false) => {
+		debugLog("handleSnapshot", {
+			isInitialSnapshot,
+			version,
+			currentServerVersion: _serverVersion,
+			pendingCount: _pending.length,
+			state
+		});
+		if (!isInitialSnapshot) {
+			debugLog("handleSnapshot: non-initial snapshot, clearing pending transactions", { clearedPendingCount: _pending.length });
+			for (const handle of _timeoutHandles.values()) clearTimeout(handle);
+			_timeoutHandles.clear();
+			for (const pending of _pending) onRejection === null || onRejection === void 0 || onRejection(pending.original, "State reset due to resync");
+			_pending = [];
+		}
+		_serverTransactionHistory = [];
+		_serverState = state;
+		_serverVersion = version;
+		debugLog("handleSnapshot: updated server state", {
+			newVersion: _serverVersion,
+			newState: _serverState
+		});
+		recomputeOptimisticState();
+	};
+	/**
+	* Processes buffered messages after receiving the initial snapshot.
+	* Filters out transactions already included in the snapshot (version <= snapshotVersion)
+	* and applies newer transactions in order.
+	*/
+	const processBufferedMessages = (bufferedMessages, snapshotVersion) => {
+		debugLog("processBufferedMessages", {
+			bufferedCount: bufferedMessages.length,
+			snapshotVersion
+		});
+		const sortedMessages = [...bufferedMessages].sort((a, b) => {
+			if (a.type === "transaction" && b.type === "transaction") return a.version - b.version;
+			return 0;
+		});
+		for (const message of sortedMessages) switch (message.type) {
+			case "transaction":
+				if (message.version > snapshotVersion) {
+					debugLog("processBufferedMessages: applying buffered transaction", {
+						txId: message.transaction.id,
+						version: message.version,
+						snapshotVersion
+					});
+					handleServerTransaction(message.transaction, message.version);
+				} else debugLog("processBufferedMessages: skipping buffered transaction (already in snapshot)", {
+					txId: message.transaction.id,
+					version: message.version,
+					snapshotVersion
+				});
+				break;
+			case "error":
+				debugLog("processBufferedMessages: processing buffered error", {
+					txId: message.transactionId,
+					reason: message.reason
+				});
+				handleRejection(message.transactionId, message.reason);
+				break;
+		}
+	};
+	/**
+	* Completes initialization and transitions to ready state.
+	*/
+	const completeInitialization = () => {
+		debugLog("completeInitialization");
+		if (_initTimeoutHandle !== null) {
+			clearTimeout(_initTimeoutHandle);
+			_initTimeoutHandle = null;
+		}
+		_initState = { type: "ready" };
+		if (_initResolver) {
+			_initResolver();
+			_initResolver = null;
+			_initRejecter = null;
+		}
+		debugLog("completeInitialization: ready", {
+			serverVersion: _serverVersion,
+			serverState: _serverState
+		});
+		notifyReady();
+	};
+	/**
+	* Handles initialization timeout.
+	*/
+	const handleInitTimeout = () => {
+		debugLog("handleInitTimeout: initialization timed out");
+		_initTimeoutHandle = null;
+		if (_initRejecter) {
+			_initRejecter(/* @__PURE__ */ new Error("Initialization timed out waiting for snapshot"));
+			_initResolver = null;
+			_initRejecter = null;
+		}
+		_initState = { type: "uninitialized" };
+	};
+	/**
+	* Handles incoming server messages.
+	* During initialization, messages are buffered until the snapshot arrives.
+	* Presence messages are always processed immediately (not buffered).
+	*/
+	const handleServerMessage = (message) => {
+		debugLog("handleServerMessage", {
+			messageType: message.type,
+			initState: _initState.type
+		});
+		if (message.type === "presence_snapshot") {
+			handlePresenceSnapshot(message);
+			return;
+		}
+		if (message.type === "presence_update") {
+			handlePresenceUpdate(message);
+			return;
+		}
+		if (message.type === "presence_remove") {
+			handlePresenceRemove(message);
+			return;
+		}
+		if (_initState.type === "initializing") {
+			if (message.type === "snapshot") {
+				debugLog("handleServerMessage: received snapshot during initialization", {
+					version: message.version,
+					bufferedCount: _initState.bufferedMessages.length
+				});
+				const buffered = _initState.bufferedMessages;
+				handleSnapshot(message.state, message.version, true);
+				processBufferedMessages(buffered, message.version);
+				completeInitialization();
+			} else {
+				debugLog("handleServerMessage: buffering message during initialization", {
+					messageType: message.type,
+					bufferedCount: _initState.bufferedMessages.length + 1
+				});
+				_initState.bufferedMessages.push(message);
+			}
+			return;
+		}
+		switch (message.type) {
+			case "transaction":
+				handleServerTransaction(message.transaction, message.version);
+				break;
+			case "snapshot":
+				handleSnapshot(message.state, message.version, false);
+				break;
+			case "error":
+				handleRejection(message.transactionId, message.reason);
+				break;
+		}
+	};
+	return {
+		schema,
+		get root() {
+			return _optimisticDoc.root;
+		},
+		get: () => _optimisticDoc.get(),
+		getServerState: () => _serverState,
+		getServerVersion: () => _serverVersion,
+		getPendingCount: () => _pending.length,
+		hasPendingChanges: () => _pending.length > 0,
+		transaction: (fn) => {
+			debugLog("transaction: starting", {
+				isConnected: transport.isConnected(),
+				isReady: _initState.type === "ready",
+				pendingCount: _pending.length
+			});
+			if (!transport.isConnected()) throw new NotConnectedError();
+			if (_initState.type !== "ready") throw new InvalidStateError("Client is not ready. Wait for initialization to complete.");
+			const result = _optimisticDoc.transaction(fn);
+			const tx = _optimisticDoc.flush();
+			if (!isEmpty(tx)) {
+				debugLog("transaction: flushed, submitting", {
+					txId: tx.id,
+					opsCount: tx.ops.length
+				});
+				submitTransaction(tx);
+			} else debugLog("transaction: flushed, empty transaction (no ops)");
+			notifyStateChange(_optimisticDoc.get());
+			return result;
+		},
+		connect: async () => {
+			debugLog("connect: starting");
+			_unsubscribe = transport.subscribe(handleServerMessage);
+			await transport.connect();
+			debugLog("connect: transport connected");
+			notifyConnectionChange(true);
+			if (presenceSchema && initialPresence !== void 0) {
+				debugLog("connect: setting initial presence", { initialPresence });
+				const validated = validate(presenceSchema, initialPresence);
+				_presenceSelfData = validated;
+				transport.sendPresenceSet(validated);
+				notifyPresenceChange();
+			}
+			if (_initState.type === "ready") {
+				debugLog("connect: already ready (has initial state)");
+				notifyReady();
+				return;
+			}
+			_initState = {
+				type: "initializing",
+				bufferedMessages: []
+			};
+			debugLog("connect: entering initializing state", { initTimeout });
+			_initTimeoutHandle = setTimeout(handleInitTimeout, initTimeout);
+			const readyPromise = new Promise((resolve, reject) => {
+				_initResolver = resolve;
+				_initRejecter = reject;
+			});
+			debugLog("connect: requesting initial snapshot");
+			transport.requestSnapshot();
+			await readyPromise;
+			debugLog("connect: completed");
+		},
+		disconnect: () => {
+			debugLog("disconnect: starting", {
+				pendingCount: _pending.length,
+				initState: _initState.type
+			});
+			for (const handle of _timeoutHandles.values()) clearTimeout(handle);
+			_timeoutHandles.clear();
+			if (_initTimeoutHandle !== null) {
+				clearTimeout(_initTimeoutHandle);
+				_initTimeoutHandle = null;
+			}
+			if (_initRejecter) {
+				_initRejecter(/* @__PURE__ */ new Error("Disconnected during initialization"));
+				_initResolver = null;
+				_initRejecter = null;
+			}
+			if (_initState.type === "initializing") _initState = { type: "uninitialized" };
+			clearPresenceState();
+			if (_unsubscribe) {
+				_unsubscribe();
+				_unsubscribe = null;
+			}
+			transport.disconnect();
+			notifyConnectionChange(false);
+			debugLog("disconnect: completed");
+		},
+		isConnected: () => transport.isConnected(),
+		isReady: () => _initState.type === "ready",
+		resync: () => {
+			debugLog("resync: requesting snapshot", {
+				currentVersion: _serverVersion,
+				pendingCount: _pending.length
+			});
+			if (!transport.isConnected()) throw new NotConnectedError();
+			transport.requestSnapshot();
+		},
+		subscribe: (listener) => {
+			_subscribers.add(listener);
+			return () => {
+				_subscribers.delete(listener);
+			};
+		},
+		presence: presenceSchema ? {
+			selfId: () => _presenceSelfId,
+			self: () => _presenceSelfData,
+			others: () => _presenceOthers,
+			all: () => {
+				const all = /* @__PURE__ */ new Map();
+				for (const [id, entry] of _presenceOthers) all.set(id, entry);
+				if (_presenceSelfId !== void 0 && _presenceSelfData !== void 0) all.set(_presenceSelfId, { data: _presenceSelfData });
+				return all;
+			},
+			set: (data) => {
+				if (!presenceSchema) return;
+				const validated = validate(presenceSchema, data);
+				debugLog("presence.set", { data: validated });
+				_presenceSelfData = validated;
+				transport.sendPresenceSet(validated);
+				notifyPresenceChange();
+			},
+			clear: () => {
+				if (!presenceSchema) return;
+				debugLog("presence.clear");
+				_presenceSelfData = void 0;
+				transport.sendPresenceClear();
+				notifyPresenceChange();
+			},
+			subscribe: (listener) => {
+				_presenceSubscribers.add(listener);
+				return () => {
+					_presenceSubscribers.delete(listener);
+				};
+			}
+		} : void 0
+	};
+};
+
+//#endregion
+//#region src/client/Transport.ts
+var Transport_exports = {};
+
+//#endregion
+//#region src/client/WebSocketTransport.ts
+var WebSocketTransport_exports = /* @__PURE__ */ __export({ make: () => make$1 });
+/**
+* Creates a WebSocket-based transport for real-time server communication.
+*/
+/**
+* Build the WebSocket URL with optional document ID path.
+*/
+const buildWebSocketUrl = (baseUrl, documentId) => {
+	if (!documentId) return baseUrl;
+	return `${baseUrl.replace(/\/+$/, "")}/doc/${encodeURIComponent(documentId)}`;
+};
+const make$1 = (options) => {
+	const { url: baseUrl, documentId, protocols, authToken, onEvent, connectionTimeout = 1e4, autoReconnect = true, maxReconnectAttempts = 10, reconnectDelay = 1e3, maxReconnectDelay = 3e4, heartbeatInterval = 3e4, heartbeatTimeout = 1e4 } = options;
+	const url = buildWebSocketUrl(baseUrl, documentId);
+	let _state = { type: "disconnected" };
+	let _ws = null;
+	let _messageHandlers = /* @__PURE__ */ new Set();
+	let _connectionTimeoutHandle = null;
+	let _heartbeatIntervalHandle = null;
+	let _heartbeatTimeoutHandle = null;
+	let _reconnectTimeoutHandle = null;
+	let _messageQueue = [];
+	let _connectResolver = null;
+	let _connectRejecter = null;
+	let _reconnectAttempt = 0;
+	const emit = (handler, event) => {
+		handler === null || handler === void 0 || handler(event);
+	};
+	/**
+	* Encodes a client message for network transport.
+	*/
+	const encodeClientMessage = (message) => {
+		if (message.type === "submit") return {
+			type: "submit",
+			transaction: encode(message.transaction)
+		};
+		return message;
+	};
+	/**
+	* Decodes a server message from network transport.
+	*/
+	const decodeServerMessage = (encoded) => {
+		if (encoded.type === "transaction") return {
+			type: "transaction",
+			transaction: decode(encoded.transaction),
+			version: encoded.version
+		};
+		return encoded;
+	};
+	/**
+	* Sends a raw message over the WebSocket.
+	*/
+	const sendRaw = (message) => {
+		if (_ws && _ws.readyState === WebSocket.OPEN) _ws.send(JSON.stringify(encodeClientMessage(message)));
+	};
+	/**
+	* Clears all active timers.
+	*/
+	const clearTimers = () => {
+		if (_connectionTimeoutHandle) {
+			clearTimeout(_connectionTimeoutHandle);
+			_connectionTimeoutHandle = null;
+		}
+		if (_heartbeatIntervalHandle) {
+			clearInterval(_heartbeatIntervalHandle);
+			_heartbeatIntervalHandle = null;
+		}
+		if (_heartbeatTimeoutHandle) {
+			clearTimeout(_heartbeatTimeoutHandle);
+			_heartbeatTimeoutHandle = null;
+		}
+		if (_reconnectTimeoutHandle) {
+			clearTimeout(_reconnectTimeoutHandle);
+			_reconnectTimeoutHandle = null;
+		}
+	};
+	/**
+	* Starts the heartbeat mechanism.
+	*/
+	const startHeartbeat = () => {
+		stopHeartbeat();
+		_heartbeatIntervalHandle = setInterval(() => {
+			if (_state.type !== "connected") return;
+			sendRaw({ type: "ping" });
+			_heartbeatTimeoutHandle = setTimeout(() => {
+				handleConnectionLost("Heartbeat timeout");
+			}, heartbeatTimeout);
+		}, heartbeatInterval);
+	};
+	/**
+	* Stops the heartbeat mechanism.
+	*/
+	const stopHeartbeat = () => {
+		if (_heartbeatIntervalHandle) {
+			clearInterval(_heartbeatIntervalHandle);
+			_heartbeatIntervalHandle = null;
+		}
+		if (_heartbeatTimeoutHandle) {
+			clearTimeout(_heartbeatTimeoutHandle);
+			_heartbeatTimeoutHandle = null;
+		}
+	};
+	/**
+	* Handles pong response - clears the heartbeat timeout.
+	*/
+	const handlePong = () => {
+		if (_heartbeatTimeoutHandle) {
+			clearTimeout(_heartbeatTimeoutHandle);
+			_heartbeatTimeoutHandle = null;
+		}
+	};
+	/**
+	* Flushes the message queue after reconnection.
+	*/
+	const flushMessageQueue = () => {
+		const queue = _messageQueue;
+		_messageQueue = [];
+		for (const message of queue) sendRaw(message);
+	};
+	/**
+	* Calculates reconnection delay with exponential backoff.
+	*/
+	const getReconnectDelay = (attempt) => {
+		const delay = reconnectDelay * Math.pow(2, attempt);
+		return Math.min(delay, maxReconnectDelay);
+	};
+	/**
+	* Resolves the auth token (handles both string and function).
+	* Returns empty string if no token is configured.
+	*/
+	const resolveAuthToken = async () => {
+		if (!authToken) return "";
+		if (typeof authToken === "string") return authToken;
+		return authToken();
+	};
+	/**
+	* Performs authentication after connection.
+	* Always sends an auth message (even with empty token) to trigger server auth flow.
+	*/
+	const authenticate = async () => {
+		const token = await resolveAuthToken();
+		_state = { type: "authenticating" };
+		sendRaw({
+			type: "auth",
+			token
+		});
+	};
+	/**
+	* Handles authentication result from server.
+	*/
+	const handleAuthResult = (success, error) => {
+		if (!success) {
+			const authError = new AuthenticationError(error || "Authentication failed");
+			cleanup();
+			_connectRejecter === null || _connectRejecter === void 0 || _connectRejecter(authError);
+			_connectResolver = null;
+			_connectRejecter = null;
+			emit(onEvent, {
+				type: "error",
+				error: authError
+			});
+			return;
+		}
+		completeConnection();
+	};
+	/**
+	* Completes the connection process.
+	*/
+	const completeConnection = () => {
+		_state = { type: "connected" };
+		_reconnectAttempt = 0;
+		if (_connectionTimeoutHandle) {
+			clearTimeout(_connectionTimeoutHandle);
+			_connectionTimeoutHandle = null;
+		}
+		startHeartbeat();
+		flushMessageQueue();
+		_connectResolver === null || _connectResolver === void 0 || _connectResolver();
+		_connectResolver = null;
+		_connectRejecter = null;
+		emit(onEvent, { type: "connected" });
+	};
+	/**
+	* Cleans up WebSocket and related state.
+	*/
+	const cleanup = () => {
+		clearTimers();
+		if (_ws) {
+			_ws.onopen = null;
+			_ws.onclose = null;
+			_ws.onerror = null;
+			_ws.onmessage = null;
+			if (_ws.readyState === WebSocket.OPEN || _ws.readyState === WebSocket.CONNECTING) _ws.close();
+			_ws = null;
+		}
+	};
+	/**
+	* Handles connection lost - initiates reconnection if enabled.
+	*/
+	const handleConnectionLost = (reason) => {
+		cleanup();
+		if (_state.type === "disconnected") return;
+		if (_connectRejecter !== null) {
+			_state = { type: "disconnected" };
+			_reconnectAttempt = 0;
+			_connectRejecter(new WebSocketError("Connection failed", void 0, reason));
+			_connectResolver = null;
+			_connectRejecter = null;
+			emit(onEvent, {
+				type: "disconnected",
+				reason
+			});
+			return;
+		}
+		if (!autoReconnect) {
+			_state = { type: "disconnected" };
+			_reconnectAttempt = 0;
+			emit(onEvent, {
+				type: "disconnected",
+				reason
+			});
+			return;
+		}
+		_reconnectAttempt++;
+		if (_reconnectAttempt > maxReconnectAttempts) {
+			_state = { type: "disconnected" };
+			_reconnectAttempt = 0;
+			emit(onEvent, {
+				type: "disconnected",
+				reason: "Max reconnection attempts reached"
+			});
+			return;
+		}
+		_state = {
+			type: "reconnecting",
+			attempt: _reconnectAttempt
+		};
+		emit(onEvent, {
+			type: "reconnecting",
+			attempt: _reconnectAttempt
+		});
+		const delay = getReconnectDelay(_reconnectAttempt - 1);
+		_reconnectTimeoutHandle = setTimeout(() => {
+			_reconnectTimeoutHandle = null;
+			attemptConnection();
+		}, delay);
+	};
+	/**
+	* Attempts to establish WebSocket connection.
+	*/
+	const attemptConnection = () => {
+		if (_state.type === "connected") return;
+		_state = { type: "connecting" };
+		try {
+			_ws = new WebSocket(url, protocols);
+		} catch (error) {
+			handleConnectionLost(error.message);
+			return;
+		}
+		_connectionTimeoutHandle = setTimeout(() => {
+			_connectionTimeoutHandle = null;
+			handleConnectionLost("Connection timeout");
+		}, connectionTimeout);
+		_ws.onopen = async () => {
+			if (_connectionTimeoutHandle) {
+				clearTimeout(_connectionTimeoutHandle);
+				_connectionTimeoutHandle = null;
+			}
+			try {
+				await authenticate();
+			} catch (error) {
+				handleConnectionLost(error.message);
+			}
+		};
+		_ws.onclose = (event) => {
+			handleConnectionLost(event.reason || `Connection closed (code: ${event.code})`);
+		};
+		_ws.onerror = () => {};
+		_ws.onmessage = (event) => {
+			try {
+				handleMessage(decodeServerMessage(JSON.parse(event.data)));
+			} catch (_unused) {}
+		};
+	};
+	/**
+	* Handles incoming server messages.
+	*/
+	const handleMessage = (message) => {
+		if (message.type === "pong") {
+			handlePong();
+			return;
+		}
+		if (message.type === "auth_result") {
+			handleAuthResult(message.success, message.error);
+			return;
+		}
+		for (const handler of _messageHandlers) try {
+			handler(message);
+		} catch (_unused2) {}
+	};
+	return {
+		send: (transaction) => {
+			const message = {
+				type: "submit",
+				transaction
+			};
+			if (_state.type === "connected") sendRaw(message);
+			else if (_state.type === "reconnecting") _messageQueue.push(message);
+		},
+		requestSnapshot: () => {
+			const message = { type: "request_snapshot" };
+			if (_state.type === "connected") sendRaw(message);
+			else if (_state.type === "reconnecting") _messageQueue.push(message);
+		},
+		subscribe: (handler) => {
+			_messageHandlers.add(handler);
+			return () => {
+				_messageHandlers.delete(handler);
+			};
+		},
+		connect: async () => {
+			if (_state.type === "connected") return;
+			if (_state.type === "connecting" || _state.type === "authenticating") return new Promise((resolve, reject) => {
+				const existingResolver = _connectResolver;
+				const existingRejecter = _connectRejecter;
+				_connectResolver = () => {
+					existingResolver === null || existingResolver === void 0 || existingResolver();
+					resolve();
+				};
+				_connectRejecter = (error) => {
+					existingRejecter === null || existingRejecter === void 0 || existingRejecter(error);
+					reject(error);
+				};
+			});
+			return new Promise((resolve, reject) => {
+				_connectResolver = resolve;
+				_connectRejecter = reject;
+				attemptConnection();
+			});
+		},
+		disconnect: () => {
+			if (_reconnectTimeoutHandle) {
+				clearTimeout(_reconnectTimeoutHandle);
+				_reconnectTimeoutHandle = null;
+			}
+			if (_connectRejecter) {
+				_connectRejecter(new WebSocketError("Disconnected by user"));
+				_connectResolver = null;
+				_connectRejecter = null;
+			}
+			cleanup();
+			_state = { type: "disconnected" };
+			_reconnectAttempt = 0;
+			_messageQueue = [];
+			emit(onEvent, {
+				type: "disconnected",
+				reason: "User disconnected"
+			});
+		},
+		isConnected: () => {
+			return _state.type === "connected";
+		},
+		sendPresenceSet: (data) => {
+			const message = {
+				type: "presence_set",
+				data
+			};
+			if (_state.type === "connected") sendRaw(message);
+			else if (_state.type === "reconnecting") {
+				_messageQueue = _messageQueue.filter((message$1) => message$1.type !== "presence_set");
+				_messageQueue.push(message);
+			}
+		},
+		sendPresenceClear: () => {
+			const message = { type: "presence_clear" };
+			if (_state.type === "connected") sendRaw(message);
+			else if (_state.type === "reconnecting") {
+				_messageQueue = _messageQueue.filter((message$1) => message$1.type !== "presence_clear");
+				_messageQueue.push(message);
+			}
+		}
+	};
+};
+
+//#endregion
+//#region src/client/StateMonitor.ts
+var StateMonitor_exports = /* @__PURE__ */ __export({
+	determineRecoveryAction: () => determineRecoveryAction,
+	make: () => make
+});
+/**
+* Creates a new StateMonitor.
+*/
+const make = (options = {}) => {
+	const { onEvent, healthCheckInterval = 5e3, stalePendingThreshold = 1e4, maxVersionGap = 10 } = options;
+	let _expectedVersion = 0;
+	let _pendingMap = /* @__PURE__ */ new Map();
+	let _isRecovering = false;
+	let _healthCheckHandle = null;
+	/**
+	* Emits an event if handler is provided.
+	*/
+	const emit = (event) => {
+		onEvent === null || onEvent === void 0 || onEvent(event);
+	};
+	/**
+	* Checks if there's a version gap indicating drift.
+	*/
+	const checkVersionGap = (receivedVersion) => {
+		const expectedNext = _expectedVersion + 1;
+		if (receivedVersion < expectedNext) return true;
+		if (receivedVersion > expectedNext + maxVersionGap) {
+			emit({
+				type: "drift_detected",
+				expectedVersion: expectedNext,
+				receivedVersion
+			});
+			return false;
+		}
+		return true;
+	};
+	/**
+	* Runs a health check.
+	*/
+	const runHealthCheck = () => {
+		const now = Date.now();
+		let oldestPendingMs = null;
+		for (const [id, info] of _pendingMap) {
+			const elapsed = now - info.sentAt;
+			if (oldestPendingMs === null || elapsed > oldestPendingMs) oldestPendingMs = elapsed;
+			if (elapsed > stalePendingThreshold) emit({
+				type: "pending_timeout",
+				transactionId: id,
+				elapsedMs: elapsed
+			});
+		}
+		emit({
+			type: "health_check",
+			pendingCount: _pendingMap.size,
+			oldestPendingMs
+		});
+	};
+	return {
+		onServerVersion: (version) => {
+			const isValid = checkVersionGap(version);
+			if (isValid) _expectedVersion = Math.max(_expectedVersion, version);
+			return isValid;
+		},
+		trackPending: (info) => {
+			_pendingMap.set(info.id, info);
+		},
+		untrackPending: (id) => {
+			_pendingMap.delete(id);
+		},
+		getStalePending: () => {
+			const now = Date.now();
+			const stale = [];
+			for (const info of _pendingMap.values()) if (now - info.sentAt > stalePendingThreshold) stale.push(info);
+			return stale;
+		},
+		getStatus: () => {
+			const now = Date.now();
+			let oldestPendingMs = null;
+			for (const info of _pendingMap.values()) {
+				const elapsed = now - info.sentAt;
+				if (oldestPendingMs === null || elapsed > oldestPendingMs) oldestPendingMs = elapsed;
+			}
+			const isHealthy = !_isRecovering && (oldestPendingMs === null || oldestPendingMs < stalePendingThreshold * 2);
+			return {
+				expectedVersion: _expectedVersion,
+				pendingCount: _pendingMap.size,
+				oldestPendingMs,
+				isHealthy,
+				isRecovering: _isRecovering
+			};
+		},
+		start: () => {
+			if (_healthCheckHandle !== null) return;
+			_healthCheckHandle = setInterval(runHealthCheck, healthCheckInterval);
+		},
+		stop: () => {
+			if (_healthCheckHandle !== null) {
+				clearInterval(_healthCheckHandle);
+				_healthCheckHandle = null;
+			}
+		},
+		reset: (newVersion) => {
+			_expectedVersion = newVersion;
+			_pendingMap.clear();
+			_isRecovering = false;
+			emit({
+				type: "recovery_completed",
+				version: newVersion
+			});
+		}
+	};
+};
+/**
+* Determines the appropriate recovery action based on current state.
+*/
+const determineRecoveryAction = (status, stalePending) => {
+	if (!status.isHealthy || stalePending.length > 3) return { type: "request_snapshot" };
+	if (stalePending.length > 0) return {
+		type: "drop_pending",
+		transactionIds: stalePending.map((p) => p.id)
+	};
+	return { type: "request_snapshot" };
+};
+
+//#endregion
+export { AuthenticationError, ClientDocument_exports as ClientDocument, ConnectionError, InvalidStateError, MimicClientError, NotConnectedError, Presence_exports as Presence, Rebase_exports as Rebase, RebaseError, StateDriftError, StateMonitor_exports as StateMonitor, TransactionRejectedError, TransactionTimeoutError, Transport_exports as Transport, WebSocketError, WebSocketTransport_exports as WebSocketTransport };
+//# sourceMappingURL=index.mjs.map