npm - loro-repo - Versions diffs - 0.3.0 → 0.5.0 - Mend

loro-repo 0.3.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/README.md +18 -17
package/dist/index.cjs +1101 -1191
package/dist/index.cjs.map +1 -1
package/dist/{index-DsCaL9JX.d.cts → index.d.cts} +117 -136
package/dist/{index-tq65q3qY.d.ts → index.d.ts} +118 -137
package/dist/index.js +1084 -1178
package/dist/index.js.map +1 -1
package/package.json +6 -6

package/dist/index.js CHANGED Viewed

@@ -1,876 +1,452 @@
 import { Flock } from "@loro-dev/flock";
-import { FlockAdaptor, LoroAdaptor } from "loro-adaptors";
-import { CrdtType, bytesToHex } from "loro-protocol";
-import { LoroWebsocketClient } from "loro-websocket";
 import { LoroDoc } from "loro-crdt";
 import { promises } from "node:fs";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
+import { LoroAdaptor } from "loro-adaptors/loro";
+import { bytesToHex } from "loro-protocol";
+import { LoroWebsocketClient } from "loro-websocket";
+import { FlockAdaptor } from "loro-adaptors/flock";
-//#region src/loro-adaptor.ts
-function createRepoFlockAdaptorFromDoc(flock, config = {}) {
-	return new FlockAdaptor(flock, config);
-}
-//#endregion
-//#region src/internal/debug.ts
-const getEnv = () => {
-	if (typeof globalThis !== "object" || globalThis === null) return;
-	return globalThis.process?.env;
-};
-const rawNamespaceConfig = (getEnv()?.LORO_REPO_DEBUG ?? "").trim();
-const normalizedNamespaces = rawNamespaceConfig.length > 0 ? rawNamespaceConfig.split(/[\s,]+/).map((token) => token.toLowerCase()).filter(Boolean) : [];
-const wildcardTokens = new Set([
-	"*",
-	"1",
-	"true",
-	"all"
-]);
-const namespaceSet = new Set(normalizedNamespaces);
-const hasWildcard = namespaceSet.size > 0 && normalizedNamespaces.some((token) => wildcardTokens.has(token));
-const isDebugEnabled = (namespace) => {
-	if (!namespaceSet.size) return false;
-	if (!namespace) return hasWildcard;
-	const normalized = namespace.toLowerCase();
-	if (hasWildcard) return true;
-	if (namespaceSet.has(normalized)) return true;
-	const [root] = normalized.split(":");
-	return namespaceSet.has(root);
-};
-const createDebugLogger = (namespace) => {
-	const normalized = namespace.toLowerCase();
-	return (...args) => {
-		if (!isDebugEnabled(normalized)) return;
-		const prefix = `[loro-repo:${namespace}]`;
-		if (args.length === 0) {
-			console.info(prefix);
-			return;
-		}
-		console.info(prefix, ...args);
+//#region src/transport/broadcast-channel.ts
+function deferred() {
+	let resolve;
+	return {
+		promise: new Promise((res) => {
+			resolve = res;
+		}),
+		resolve
 	};
-};
-//#endregion
-//#region src/transport/websocket.ts
-const debug = createDebugLogger("transport:websocket");
-function withTimeout(promise, timeoutMs) {
-	if (!timeoutMs || timeoutMs <= 0) return promise;
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			reject(/* @__PURE__ */ new Error(`Operation timed out after ${timeoutMs}ms`));
-		}, timeoutMs);
-		promise.then((value) => {
-			clearTimeout(timer);
-			resolve(value);
-		}).catch((error) => {
-			clearTimeout(timer);
-			reject(error);
-		});
-	});
 }
-function normalizeRoomId(roomId, fallback) {
-	if (typeof roomId === "string" && roomId.length > 0) return roomId;
-	if (roomId instanceof Uint8Array && roomId.length > 0) try {
-		return bytesToHex(roomId);
+function randomInstanceId() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return Math.random().toString(36).slice(2);
+}
+function ensureBroadcastChannel() {
+	if (typeof BroadcastChannel === "undefined") throw new Error("BroadcastChannel API is not available in this environment");
+	return BroadcastChannel;
+}
+function encodeDocChannelId(docId) {
+	try {
+		return encodeURIComponent(docId);
 	} catch {
-		return fallback;
+		return docId.replace(/[^a-z0-9_-]/gi, "_");
 	}
-	return fallback;
 }
-function bytesEqual(a, b) {
-	if (a === b) return true;
-	if (!a || !b) return false;
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
-	return true;
+function postChannelMessage(channel, message) {
+	channel.postMessage(message);
 }
 /**
-* loro-websocket backed {@link TransportAdapter} implementation for LoroRepo.
+* TransportAdapter that relies on the BroadcastChannel API to fan out metadata
+* and document updates between browser tabs within the same origin.
 */
-var WebSocketTransportAdapter = class {
-	options;
-	client;
-	metadataSession;
-	docSessions = /* @__PURE__ */ new Map();
-	constructor(options) {
-		this.options = options;
+var BroadcastChannelTransportAdapter = class {
+	instanceId = randomInstanceId();
+	namespace;
+	metaChannelName;
+	connected = false;
+	metaState;
+	docStates = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		ensureBroadcastChannel();
+		this.namespace = options.namespace ?? "loro-repo";
+		this.metaChannelName = options.metaChannelName ?? `${this.namespace}-meta`;
 	}
-	async connect(_options) {
-		const client = this.ensureClient();
-		debug("connect requested", { status: client.getStatus() });
-		try {
-			await client.connect();
-			debug("client.connect resolved");
-			await client.waitConnected();
-			debug("client.waitConnected resolved", { status: client.getStatus() });
-		} catch (error) {
-			debug("connect failed", error);
-			throw error;
-		}
+	async connect() {
+		this.connected = true;
 	}
 	async close() {
-		debug("close requested", {
-			docSessions: this.docSessions.size,
-			metadataSession: Boolean(this.metadataSession)
-		});
-		for (const [docId] of this.docSessions) await this.leaveDocSession(docId).catch(() => {});
-		this.docSessions.clear();
-		await this.teardownMetadataSession().catch(() => {});
-		if (this.client) {
-			const client = this.client;
-			this.client = void 0;
-			client.destroy();
-			debug("websocket client destroyed");
+		this.connected = false;
+		if (this.metaState) {
+			for (const entry of this.metaState.listeners) entry.unsubscribe();
+			this.metaState.channel.close();
+			this.metaState = void 0;
 		}
-		debug("close completed");
+		for (const [docId] of this.docStates) this.teardownDocChannel(docId);
+		this.docStates.clear();
 	}
 	isConnected() {
-		return this.client?.getStatus() === "connected";
+		return this.connected;
 	}
-	async syncMeta(flock, options) {
-		if (!this.options.metadataRoomId) {
-			debug("syncMeta skipped; metadata room not configured");
-			return { ok: true };
-		}
-		debug("syncMeta requested", { roomId: this.options.metadataRoomId });
-		try {
-			await withTimeout((await this.ensureMetadataSession(flock, {
-				roomId: this.options.metadataRoomId,
-				auth: this.options.metadataAuth
-			})).firstSynced, options?.timeout);
-			debug("syncMeta completed", { roomId: this.options.metadataRoomId });
-			return { ok: true };
-		} catch (error) {
-			debug("syncMeta failed", error);
-			return { ok: false };
-		}
+	async syncMeta(flock, _options) {
+		const subscription = this.joinMetaRoom(flock);
+		subscription.firstSyncedWithRemote.catch(() => void 0);
+		await subscription.firstSyncedWithRemote;
+		subscription.unsubscribe();
+		return { ok: true };
 	}
-	joinMetaRoom(flock, params) {
-		const fallback = this.options.metadataRoomId ?? "";
-		const roomId = normalizeRoomId(params?.roomId, fallback);
-		if (!roomId) throw new Error("Metadata room id not configured");
-		const auth = params?.auth ?? this.options.metadataAuth;
-		debug("joinMetaRoom requested", {
-			roomId,
-			hasAuth: Boolean(auth && auth.length)
+	joinMetaRoom(flock, _params) {
+		const state = this.ensureMetaChannel();
+		const { promise, resolve } = deferred();
+		const listener = {
+			flock,
+			muted: false,
+			unsubscribe: flock.subscribe(() => {
+				if (listener.muted) return;
+				Promise.resolve(flock.exportJson()).then((bundle) => {
+					postChannelMessage(state.channel, {
+						kind: "meta-export",
+						from: this.instanceId,
+						bundle
+					});
+				});
+			}),
+			resolveFirst: resolve,
+			firstSynced: promise
+		};
+		state.listeners.add(listener);
+		postChannelMessage(state.channel, {
+			kind: "meta-request",
+			from: this.instanceId
 		});
-		const ensure = this.ensureMetadataSession(flock, {
-			roomId,
-			auth
+		Promise.resolve(flock.exportJson()).then((bundle) => {
+			postChannelMessage(state.channel, {
+				kind: "meta-export",
+				from: this.instanceId,
+				bundle
+			});
 		});
-		const firstSynced = ensure.then((session) => session.firstSynced);
-		const getConnected = () => this.isConnected();
-		const subscription = {
+		queueMicrotask(() => resolve());
+		return {
 			unsubscribe: () => {
-				ensure.then((session) => {
-					session.refCount = Math.max(0, session.refCount - 1);
-					debug("metadata session refCount decremented", {
-						roomId: session.roomId,
-						refCount: session.refCount
-					});
-					if (session.refCount === 0) {
-						debug("tearing down metadata session due to refCount=0", { roomId: session.roomId });
-						this.teardownMetadataSession(session).catch(() => {});
-					}
-				});
+				listener.unsubscribe();
+				state.listeners.delete(listener);
+				if (!state.listeners.size) {
+					state.channel.removeEventListener("message", state.onMessage);
+					state.channel.close();
+					this.metaState = void 0;
+				}
 			},
-			firstSyncedWithRemote: firstSynced,
+			firstSyncedWithRemote: listener.firstSynced,
 			get connected() {
-				return getConnected();
+				return true;
 			}
 		};
-		ensure.then((session) => {
-			session.refCount += 1;
-			debug("metadata session refCount incremented", {
-				roomId: session.roomId,
-				refCount: session.refCount
-			});
-		});
-		return subscription;
-	}
-	async syncDoc(docId, doc, options) {
-		debug("syncDoc requested", { docId });
-		try {
-			const session = await this.ensureDocSession(docId, doc, {});
-			await withTimeout(session.firstSynced, options?.timeout);
-			debug("syncDoc completed", {
-				docId,
-				roomId: session.roomId
-			});
-			return { ok: true };
-		} catch (error) {
-			debug("syncDoc failed", {
-				docId,
-				error
-			});
-			return { ok: false };
-		}
 	}
-	joinDocRoom(docId, doc, params) {
-		debug("joinDocRoom requested", {
+	async syncDoc(docId, doc, _options) {
+		const subscription = this.joinDocRoom(docId, doc);
+		subscription.firstSyncedWithRemote.catch(() => void 0);
+		await subscription.firstSyncedWithRemote;
+		subscription.unsubscribe();
+		return { ok: true };
+	}
+	joinDocRoom(docId, doc, _params) {
+		const state = this.ensureDocChannel(docId);
+		const { promise, resolve } = deferred();
+		const listener = {
+			doc,
+			muted: false,
+			unsubscribe: doc.subscribe(() => {
+				if (listener.muted) return;
+				const payload = doc.export({ mode: "update" });
+				postChannelMessage(state.channel, {
+					kind: "doc-update",
+					docId,
+					from: this.instanceId,
+					mode: "update",
+					payload
+				});
+			}),
+			resolveFirst: resolve,
+			firstSynced: promise
+		};
+		state.listeners.add(listener);
+		postChannelMessage(state.channel, {
+			kind: "doc-request",
 			docId,
-			roomParamType: params?.roomId ? typeof params.roomId === "string" ? "string" : "uint8array" : void 0,
-			hasAuthOverride: Boolean(params?.auth && params.auth.length)
+			from: this.instanceId
 		});
-		const ensure = this.ensureDocSession(docId, doc, params ?? {});
-		const firstSynced = ensure.then((session) => session.firstSynced);
-		const getConnected = () => this.isConnected();
-		const subscription = {
+		postChannelMessage(state.channel, {
+			kind: "doc-update",
+			docId,
+			from: this.instanceId,
+			mode: "snapshot",
+			payload: doc.export({ mode: "snapshot" })
+		});
+		queueMicrotask(() => resolve());
+		return {
 			unsubscribe: () => {
-				ensure.then((session) => {
-					session.refCount = Math.max(0, session.refCount - 1);
-					debug("doc session refCount decremented", {
-						docId,
-						roomId: session.roomId,
-						refCount: session.refCount
-					});
-					if (session.refCount === 0) this.leaveDocSession(docId).catch(() => {});
-				});
+				listener.unsubscribe();
+				state.listeners.delete(listener);
+				if (!state.listeners.size) this.teardownDocChannel(docId);
 			},
-			firstSyncedWithRemote: firstSynced,
+			firstSyncedWithRemote: listener.firstSynced,
 			get connected() {
-				return getConnected();
+				return true;
 			}
 		};
-		ensure.then((session) => {
-			session.refCount += 1;
-			debug("doc session refCount incremented", {
-				docId,
-				roomId: session.roomId,
-				refCount: session.refCount
-			});
-		});
-		return subscription;
 	}
-	ensureClient() {
-		if (this.client) {
-			debug("reusing websocket client", { status: this.client.getStatus() });
-			return this.client;
-		}
-		const { url, client: clientOptions } = this.options;
-		debug("creating websocket client", {
-			url,
-			clientOptionsKeys: clientOptions ? Object.keys(clientOptions) : []
-		});
-		const client = new LoroWebsocketClient({
-			url,
-			...clientOptions
-		});
-		this.client = client;
-		return client;
+	ensureMetaChannel() {
+		if (this.metaState) return this.metaState;
+		const channel = new (ensureBroadcastChannel())(this.metaChannelName);
+		const listeners = /* @__PURE__ */ new Set();
+		const onMessage = (event) => {
+			const message = event.data;
+			if (!message || message.from === this.instanceId) return;
+			if (message.kind === "meta-export") for (const entry of listeners) {
+				entry.muted = true;
+				entry.flock.importJson(message.bundle);
+				entry.muted = false;
+				entry.resolveFirst();
+			}
+			else if (message.kind === "meta-request") {
+				const first = listeners.values().next().value;
+				if (!first) return;
+				Promise.resolve(first.flock.exportJson()).then((bundle) => {
+					postChannelMessage(channel, {
+						kind: "meta-export",
+						from: this.instanceId,
+						bundle
+					});
+				});
+			}
+		};
+		channel.addEventListener("message", onMessage);
+		this.metaState = {
+			channel,
+			listeners,
+			onMessage
+		};
+		return this.metaState;
 	}
-	async ensureMetadataSession(flock, params) {
-		debug("ensureMetadataSession invoked", {
-			roomId: params.roomId,
-			hasAuth: Boolean(params.auth && params.auth.length)
-		});
-		const client = this.ensureClient();
-		await client.waitConnected();
-		debug("websocket client ready for metadata session", { status: client.getStatus() });
-		if (this.metadataSession && this.metadataSession.flock === flock && this.metadataSession.roomId === params.roomId && bytesEqual(this.metadataSession.auth, params.auth)) {
-			debug("reusing metadata session", {
-				roomId: this.metadataSession.roomId,
-				refCount: this.metadataSession.refCount
-			});
-			return this.metadataSession;
-		}
-		if (this.metadataSession) {
-			debug("tearing down previous metadata session", { roomId: this.metadataSession.roomId });
-			await this.teardownMetadataSession(this.metadataSession).catch(() => {});
-		}
-		const configuredType = this.options.metadataCrdtType;
-		if (configuredType && configuredType !== CrdtType.Flock) throw new Error(`metadataCrdtType must be ${CrdtType.Flock} when syncing Flock metadata`);
-		const adaptor = createRepoFlockAdaptorFromDoc(flock, this.options.metadataAdaptorConfig ?? {});
-		debug("joining metadata room", {
-			roomId: params.roomId,
-			hasAuth: Boolean(params.auth && params.auth.length)
-		});
-		const room = await client.join({
-			roomId: params.roomId,
-			crdtAdaptor: adaptor,
-			auth: params.auth
-		});
-		const firstSynced = room.waitForReachingServerVersion();
-		firstSynced.then(() => {
-			debug("metadata session firstSynced resolved", { roomId: params.roomId });
-		}, (error) => {
-			debug("metadata session firstSynced rejected", {
-				roomId: params.roomId,
-				error
-			});
-		});
-		const session = {
-			adaptor,
-			room,
-			firstSynced,
-			flock,
-			roomId: params.roomId,
-			auth: params.auth,
-			refCount: 0
+	ensureDocChannel(docId) {
+		const existing = this.docStates.get(docId);
+		if (existing) return existing;
+		const channel = new (ensureBroadcastChannel())(`${this.namespace}-doc-${encodeDocChannelId(docId)}`);
+		const listeners = /* @__PURE__ */ new Set();
+		const onMessage = (event) => {
+			const message = event.data;
+			if (!message || message.from === this.instanceId) return;
+			if (message.kind === "doc-update") for (const entry of listeners) {
+				entry.muted = true;
+				entry.doc.import(message.payload);
+				entry.muted = false;
+				entry.resolveFirst();
+			}
+			else if (message.kind === "doc-request") {
+				const first = listeners.values().next().value;
+				if (!first) return;
+				const payload = message.docId === docId ? first.doc.export({ mode: "snapshot" }) : void 0;
+				if (!payload) return;
+				postChannelMessage(channel, {
+					kind: "doc-update",
+					docId,
+					from: this.instanceId,
+					mode: "snapshot",
+					payload
+				});
+			}
 		};
-		this.metadataSession = session;
-		return session;
+		channel.addEventListener("message", onMessage);
+		const state = {
+			channel,
+			listeners,
+			onMessage
+		};
+		this.docStates.set(docId, state);
+		return state;
 	}
-	async teardownMetadataSession(session) {
-		const target = session ?? this.metadataSession;
-		if (!target) return;
-		debug("teardownMetadataSession invoked", { roomId: target.roomId });
-		if (this.metadataSession === target) this.metadataSession = void 0;
-		const { adaptor, room } = target;
-		try {
-			await room.leave();
-			debug("metadata room left", { roomId: target.roomId });
-		} catch (error) {
-			debug("metadata room leave failed; destroying", {
-				roomId: target.roomId,
-				error
-			});
-			await room.destroy().catch(() => {});
-		}
-		adaptor.destroy();
-		debug("metadata session destroyed", { roomId: target.roomId });
-	}
-	async ensureDocSession(docId, doc, params) {
-		debug("ensureDocSession invoked", { docId });
-		const client = this.ensureClient();
-		await client.waitConnected();
-		debug("websocket client ready for doc session", {
-			docId,
-			status: client.getStatus()
-		});
-		const existing = this.docSessions.get(docId);
-		const derivedRoomId = this.options.docRoomId?.(docId) ?? docId;
-		const roomId = normalizeRoomId(params.roomId, derivedRoomId);
-		const auth = params.auth ?? this.options.docAuth?.(docId);
-		debug("doc session params resolved", {
-			docId,
-			roomId,
-			hasAuth: Boolean(auth && auth.length)
-		});
-		if (existing && existing.doc === doc && existing.roomId === roomId) {
-			debug("reusing doc session", {
-				docId,
-				roomId,
-				refCount: existing.refCount
-			});
-			return existing;
-		}
-		if (existing) {
-			debug("doc session mismatch; leaving existing session", {
-				docId,
-				previousRoomId: existing.roomId,
-				nextRoomId: roomId
-			});
-			await this.leaveDocSession(docId).catch(() => {});
-		}
-		const adaptor = new LoroAdaptor(doc);
-		debug("joining doc room", {
-			docId,
-			roomId,
-			hasAuth: Boolean(auth && auth.length)
-		});
-		const room = await client.join({
-			roomId,
-			crdtAdaptor: adaptor,
-			auth
-		});
-		const firstSynced = room.waitForReachingServerVersion();
-		firstSynced.then(() => {
-			debug("doc session firstSynced resolved", {
-				docId,
-				roomId
-			});
-		}, (error) => {
-			debug("doc session firstSynced rejected", {
-				docId,
-				roomId,
-				error
-			});
-		});
-		const session = {
-			adaptor,
-			room,
-			firstSynced,
-			doc,
-			roomId,
-			refCount: 0
-		};
-		this.docSessions.set(docId, session);
-		return session;
-	}
-	async leaveDocSession(docId) {
-		const session = this.docSessions.get(docId);
-		if (!session) {
-			debug("leaveDocSession invoked but no session found", { docId });
-			return;
-		}
-		this.docSessions.delete(docId);
-		debug("leaving doc session", {
-			docId,
-			roomId: session.roomId
-		});
-		try {
-			await session.room.leave();
-			debug("doc room left", {
-				docId,
-				roomId: session.roomId
-			});
-		} catch (error) {
-			debug("doc room leave failed; destroying", {
-				docId,
-				roomId: session.roomId,
-				error
-			});
-			await session.room.destroy().catch(() => {});
-		}
-		session.adaptor.destroy();
-		debug("doc session destroyed", {
-			docId,
-			roomId: session.roomId
-		});
+	teardownDocChannel(docId) {
+		const state = this.docStates.get(docId);
+		if (!state) return;
+		for (const entry of state.listeners) entry.unsubscribe();
+		state.channel.removeEventListener("message", state.onMessage);
+		state.channel.close();
+		this.docStates.delete(docId);
 	}
 };
 //#endregion
-//#region src/transport/broadcast-channel.ts
-function deferred() {
-	let resolve;
-	return {
-		promise: new Promise((res) => {
-			resolve = res;
-		}),
-		resolve
-	};
-}
-function randomInstanceId() {
-	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
-	return Math.random().toString(36).slice(2);
-}
-function ensureBroadcastChannel() {
-	if (typeof BroadcastChannel === "undefined") throw new Error("BroadcastChannel API is not available in this environment");
-	return BroadcastChannel;
-}
-function encodeDocChannelId(docId) {
-	try {
-		return encodeURIComponent(docId);
+//#region src/storage/indexeddb.ts
+const DEFAULT_DB_NAME = "loro-repo";
+const DEFAULT_DB_VERSION = 1;
+const DEFAULT_DOC_STORE = "docs";
+const DEFAULT_META_STORE = "meta";
+const DEFAULT_ASSET_STORE = "assets";
+const DEFAULT_DOC_UPDATE_STORE = "doc-updates";
+const DEFAULT_META_KEY = "snapshot";
+const textDecoder$1 = new TextDecoder();
+function describeUnknown(cause) {
+	if (typeof cause === "string") return cause;
+	if (typeof cause === "number" || typeof cause === "boolean") return String(cause);
+	if (typeof cause === "bigint") return cause.toString();
+	if (typeof cause === "symbol") return cause.description ?? cause.toString();
+	if (typeof cause === "function") return `[function ${cause.name ?? "anonymous"}]`;
+	if (cause && typeof cause === "object") try {
+		return JSON.stringify(cause);
 	} catch {
-		return docId.replace(/[^a-z0-9_-]/gi, "_");
+		return "[object]";
 	}
+	return String(cause);
 }
-function postChannelMessage(channel, message) {
-	channel.postMessage(message);
-}
-/**
-* TransportAdapter that relies on the BroadcastChannel API to fan out metadata
-* and document updates between browser tabs within the same origin.
-*/
-var BroadcastChannelTransportAdapter = class {
-	instanceId = randomInstanceId();
-	namespace;
-	metaChannelName;
-	connected = false;
-	metaState;
-	docStates = /* @__PURE__ */ new Map();
+var IndexedDBStorageAdaptor = class {
+	idb;
+	dbName;
+	version;
+	docStore;
+	docUpdateStore;
+	metaStore;
+	assetStore;
+	metaKey;
+	dbPromise;
+	closed = false;
 	constructor(options = {}) {
-		ensureBroadcastChannel();
-		this.namespace = options.namespace ?? "loro-repo";
-		this.metaChannelName = options.metaChannelName ?? `${this.namespace}-meta`;
+		const idbFactory = globalThis.indexedDB;
+		if (!idbFactory) throw new Error("IndexedDB is not available in this environment");
+		this.idb = idbFactory;
+		this.dbName = options.dbName ?? DEFAULT_DB_NAME;
+		this.version = options.version ?? DEFAULT_DB_VERSION;
+		this.docStore = options.docStoreName ?? DEFAULT_DOC_STORE;
+		this.docUpdateStore = options.docUpdateStoreName ?? DEFAULT_DOC_UPDATE_STORE;
+		this.metaStore = options.metaStoreName ?? DEFAULT_META_STORE;
+		this.assetStore = options.assetStoreName ?? DEFAULT_ASSET_STORE;
+		this.metaKey = options.metaKey ?? DEFAULT_META_KEY;
 	}
-	async connect() {
-		this.connected = true;
+	async save(payload) {
+		const db = await this.ensureDb();
+		switch (payload.type) {
+			case "doc-snapshot": {
+				const snapshot = payload.snapshot.slice();
+				await this.storeMergedSnapshot(db, payload.docId, snapshot);
+				break;
+			}
+			case "doc-update": {
+				const update = payload.update.slice();
+				await this.appendDocUpdate(db, payload.docId, update);
+				break;
+			}
+			case "asset": {
+				const bytes = payload.data.slice();
+				await this.putBinary(db, this.assetStore, payload.assetId, bytes);
+				break;
+			}
+			case "meta": {
+				const bytes = payload.update.slice();
+				await this.putBinary(db, this.metaStore, this.metaKey, bytes);
+				break;
+			}
+			default: throw new Error("Unsupported storage payload type");
+		}
 	}
-	async close() {
-		this.connected = false;
-		if (this.metaState) {
-			for (const entry of this.metaState.listeners) entry.unsubscribe();
-			this.metaState.channel.close();
-			this.metaState = void 0;
+	async deleteAsset(assetId) {
+		const db = await this.ensureDb();
+		await this.deleteKey(db, this.assetStore, assetId);
+	}
+	async loadDoc(docId) {
+		const db = await this.ensureDb();
+		const snapshot = await this.getBinaryFromDb(db, this.docStore, docId);
+		const pendingUpdates = await this.getDocUpdates(db, docId);
+		if (!snapshot && pendingUpdates.length === 0) return;
+		let doc;
+		try {
+			doc = snapshot ? LoroDoc.fromSnapshot(snapshot) : new LoroDoc();
+		} catch (error) {
+			throw this.createError(`Failed to hydrate document snapshot for "${docId}"`, error);
 		}
-		for (const [docId] of this.docStates) this.teardownDocChannel(docId);
-		this.docStates.clear();
+		let appliedUpdates = false;
+		for (const update of pendingUpdates) try {
+			doc.import(update);
+			appliedUpdates = true;
+		} catch (error) {
+			throw this.createError(`Failed to apply queued document update for "${docId}"`, error);
+		}
+		if (appliedUpdates) {
+			let consolidated;
+			try {
+				consolidated = doc.export({ mode: "snapshot" });
+			} catch (error) {
+				throw this.createError(`Failed to export consolidated snapshot for "${docId}"`, error);
+			}
+			await this.writeSnapshot(db, docId, consolidated);
+			await this.clearDocUpdates(db, docId);
+		}
+		return doc;
 	}
-	isConnected() {
-		return this.connected;
+	async loadMeta() {
+		const bytes = await this.getBinary(this.metaStore, this.metaKey);
+		if (!bytes) return void 0;
+		try {
+			const json = textDecoder$1.decode(bytes);
+			const bundle = JSON.parse(json);
+			const flock = new Flock();
+			flock.importJson(bundle);
+			return flock;
+		} catch (error) {
+			throw this.createError("Failed to hydrate metadata snapshot", error);
+		}
 	}
-	async syncMeta(flock, _options) {
-		const subscription = this.joinMetaRoom(flock);
-		subscription.firstSyncedWithRemote.catch(() => void 0);
-		await subscription.firstSyncedWithRemote;
-		subscription.unsubscribe();
-		return { ok: true };
+	async loadAsset(assetId) {
+		return await this.getBinary(this.assetStore, assetId) ?? void 0;
 	}
-	joinMetaRoom(flock, _params) {
-		const state = this.ensureMetaChannel();
-		const { promise, resolve } = deferred();
-		const listener = {
-			flock,
-			muted: false,
-			unsubscribe: flock.subscribe(() => {
-				if (listener.muted) return;
-				Promise.resolve(flock.exportJson()).then((bundle) => {
-					postChannelMessage(state.channel, {
-						kind: "meta-export",
-						from: this.instanceId,
-						bundle
-					});
-				});
-			}),
-			resolveFirst: resolve,
-			firstSynced: promise
-		};
-		state.listeners.add(listener);
-		postChannelMessage(state.channel, {
-			kind: "meta-request",
-			from: this.instanceId
-		});
-		Promise.resolve(flock.exportJson()).then((bundle) => {
-			postChannelMessage(state.channel, {
-				kind: "meta-export",
-				from: this.instanceId,
-				bundle
+	async close() {
+		this.closed = true;
+		const db = await this.dbPromise;
+		if (db) db.close();
+		this.dbPromise = void 0;
+	}
+	async ensureDb() {
+		if (this.closed) throw new Error("IndexedDBStorageAdaptor has been closed");
+		if (!this.dbPromise) this.dbPromise = new Promise((resolve, reject) => {
+			const request = this.idb.open(this.dbName, this.version);
+			request.addEventListener("upgradeneeded", () => {
+				const db = request.result;
+				this.ensureStore(db, this.docStore);
+				this.ensureStore(db, this.docUpdateStore);
+				this.ensureStore(db, this.metaStore);
+				this.ensureStore(db, this.assetStore);
 			});
+			request.addEventListener("success", () => resolve(request.result), { once: true });
+			request.addEventListener("error", () => {
+				reject(this.createError(`Failed to open IndexedDB database "${this.dbName}"`, request.error));
+			}, { once: true });
 		});
-		queueMicrotask(() => resolve());
-		return {
-			unsubscribe: () => {
-				listener.unsubscribe();
-				state.listeners.delete(listener);
-				if (!state.listeners.size) {
-					state.channel.removeEventListener("message", state.onMessage);
-					state.channel.close();
-					this.metaState = void 0;
-				}
-			},
-			firstSyncedWithRemote: listener.firstSynced,
-			get connected() {
-				return true;
-			}
-		};
+		return this.dbPromise;
 	}
-	async syncDoc(docId, doc, _options) {
-		const subscription = this.joinDocRoom(docId, doc);
-		subscription.firstSyncedWithRemote.catch(() => void 0);
-		await subscription.firstSyncedWithRemote;
-		subscription.unsubscribe();
-		return { ok: true };
+	ensureStore(db, storeName) {
+		const names = db.objectStoreNames;
+		if (this.storeExists(names, storeName)) return;
+		db.createObjectStore(storeName);
 	}
-	joinDocRoom(docId, doc, _params) {
-		const state = this.ensureDocChannel(docId);
-		const { promise, resolve } = deferred();
-		const listener = {
-			doc,
-			muted: false,
-			unsubscribe: doc.subscribe(() => {
-				if (listener.muted) return;
-				const payload = doc.export({ mode: "update" });
-				postChannelMessage(state.channel, {
-					kind: "doc-update",
-					docId,
-					from: this.instanceId,
-					mode: "update",
-					payload
-				});
-			}),
-			resolveFirst: resolve,
-			firstSynced: promise
-		};
-		state.listeners.add(listener);
-		postChannelMessage(state.channel, {
-			kind: "doc-request",
-			docId,
-			from: this.instanceId
-		});
-		postChannelMessage(state.channel, {
-			kind: "doc-update",
-			docId,
-			from: this.instanceId,
-			mode: "snapshot",
-			payload: doc.export({ mode: "snapshot" })
+	storeExists(names, storeName) {
+		if (typeof names.contains === "function") return names.contains(storeName);
+		const length = names.length ?? 0;
+		for (let index = 0; index < length; index += 1) if (names.item?.(index) === storeName) return true;
+		return false;
+	}
+	async storeMergedSnapshot(db, docId, incoming) {
+		await this.runInTransaction(db, this.docStore, "readwrite", async (store) => {
+			const existingRaw = await this.wrapRequest(store.get(docId), "read");
+			const existing = await this.normalizeBinary(existingRaw);
+			const merged = this.mergeSnapshots(docId, existing, incoming);
+			await this.wrapRequest(store.put(merged, docId), "write");
 		});
-		queueMicrotask(() => resolve());
-		return {
-			unsubscribe: () => {
-				listener.unsubscribe();
-				state.listeners.delete(listener);
-				if (!state.listeners.size) this.teardownDocChannel(docId);
-			},
-			firstSyncedWithRemote: listener.firstSynced,
-			get connected() {
-				return true;
-			}
-		};
 	}
-	ensureMetaChannel() {
-		if (this.metaState) return this.metaState;
-		const channel = new (ensureBroadcastChannel())(this.metaChannelName);
-		const listeners = /* @__PURE__ */ new Set();
-		const onMessage = (event) => {
-			const message = event.data;
-			if (!message || message.from === this.instanceId) return;
-			if (message.kind === "meta-export") for (const entry of listeners) {
-				entry.muted = true;
-				entry.flock.importJson(message.bundle);
-				entry.muted = false;
-				entry.resolveFirst();
-			}
-			else if (message.kind === "meta-request") {
-				const first = listeners.values().next().value;
-				if (!first) return;
-				Promise.resolve(first.flock.exportJson()).then((bundle) => {
-					postChannelMessage(channel, {
-						kind: "meta-export",
-						from: this.instanceId,
-						bundle
-					});
-				});
-			}
-		};
-		channel.addEventListener("message", onMessage);
-		this.metaState = {
-			channel,
-			listeners,
-			onMessage
-		};
-		return this.metaState;
+	mergeSnapshots(docId, existing, incoming) {
+		try {
+			const doc = existing ? LoroDoc.fromSnapshot(existing) : new LoroDoc();
+			doc.import(incoming);
+			return doc.export({ mode: "snapshot" });
+		} catch (error) {
+			throw this.createError(`Failed to merge snapshot for "${docId}"`, error);
+		}
 	}
-	ensureDocChannel(docId) {
-		const existing = this.docStates.get(docId);
-		if (existing) return existing;
-		const channel = new (ensureBroadcastChannel())(`${this.namespace}-doc-${encodeDocChannelId(docId)}`);
-		const listeners = /* @__PURE__ */ new Set();
-		const onMessage = (event) => {
-			const message = event.data;
-			if (!message || message.from === this.instanceId) return;
-			if (message.kind === "doc-update") for (const entry of listeners) {
-				entry.muted = true;
-				entry.doc.import(message.payload);
-				entry.muted = false;
-				entry.resolveFirst();
-			}
-			else if (message.kind === "doc-request") {
-				const first = listeners.values().next().value;
-				if (!first) return;
-				const payload = message.docId === docId ? first.doc.export({ mode: "snapshot" }) : void 0;
-				if (!payload) return;
-				postChannelMessage(channel, {
-					kind: "doc-update",
-					docId,
-					from: this.instanceId,
-					mode: "snapshot",
-					payload
-				});
-			}
-		};
-		channel.addEventListener("message", onMessage);
-		const state = {
-			channel,
-			listeners,
-			onMessage
-		};
-		this.docStates.set(docId, state);
-		return state;
+	async appendDocUpdate(db, docId, update) {
+		await this.runInTransaction(db, this.docUpdateStore, "readwrite", async (store) => {
+			const raw = await this.wrapRequest(store.get(docId), "read");
+			const queue = await this.normalizeUpdateQueue(raw);
+			queue.push(update.slice());
+			await this.wrapRequest(store.put({ updates: queue }, docId), "write");
+		});
 	}
-	teardownDocChannel(docId) {
-		const state = this.docStates.get(docId);
-		if (!state) return;
-		for (const entry of state.listeners) entry.unsubscribe();
-		state.channel.removeEventListener("message", state.onMessage);
-		state.channel.close();
-		this.docStates.delete(docId);
+	async getDocUpdates(db, docId) {
+		const raw = await this.runInTransaction(db, this.docUpdateStore, "readonly", (store) => this.wrapRequest(store.get(docId), "read"));
+		return this.normalizeUpdateQueue(raw);
 	}
-};
-//#endregion
-//#region src/storage/indexeddb.ts
-const DEFAULT_DB_NAME = "loro-repo";
-const DEFAULT_DB_VERSION = 1;
-const DEFAULT_DOC_STORE = "docs";
-const DEFAULT_META_STORE = "meta";
-const DEFAULT_ASSET_STORE = "assets";
-const DEFAULT_DOC_UPDATE_STORE = "doc-updates";
-const DEFAULT_META_KEY = "snapshot";
-const textDecoder$1 = new TextDecoder();
-function describeUnknown(cause) {
-	if (typeof cause === "string") return cause;
-	if (typeof cause === "number" || typeof cause === "boolean") return String(cause);
-	if (typeof cause === "bigint") return cause.toString();
-	if (typeof cause === "symbol") return cause.description ?? cause.toString();
-	if (typeof cause === "function") return `[function ${cause.name ?? "anonymous"}]`;
-	if (cause && typeof cause === "object") try {
-		return JSON.stringify(cause);
-	} catch {
-		return "[object]";
+	async clearDocUpdates(db, docId) {
+		await this.runInTransaction(db, this.docUpdateStore, "readwrite", (store) => this.wrapRequest(store.delete(docId), "delete"));
 	}
-	return String(cause);
-}
-var IndexedDBStorageAdaptor = class {
-	idb;
-	dbName;
-	version;
-	docStore;
-	docUpdateStore;
-	metaStore;
-	assetStore;
-	metaKey;
-	dbPromise;
-	closed = false;
-	constructor(options = {}) {
-		const idbFactory = globalThis.indexedDB;
-		if (!idbFactory) throw new Error("IndexedDB is not available in this environment");
-		this.idb = idbFactory;
-		this.dbName = options.dbName ?? DEFAULT_DB_NAME;
-		this.version = options.version ?? DEFAULT_DB_VERSION;
-		this.docStore = options.docStoreName ?? DEFAULT_DOC_STORE;
-		this.docUpdateStore = options.docUpdateStoreName ?? DEFAULT_DOC_UPDATE_STORE;
-		this.metaStore = options.metaStoreName ?? DEFAULT_META_STORE;
-		this.assetStore = options.assetStoreName ?? DEFAULT_ASSET_STORE;
-		this.metaKey = options.metaKey ?? DEFAULT_META_KEY;
-	}
-	async save(payload) {
-		const db = await this.ensureDb();
-		switch (payload.type) {
-			case "doc-snapshot": {
-				const snapshot = payload.snapshot.slice();
-				await this.storeMergedSnapshot(db, payload.docId, snapshot);
-				break;
-			}
-			case "doc-update": {
-				const update = payload.update.slice();
-				await this.appendDocUpdate(db, payload.docId, update);
-				break;
-			}
-			case "asset": {
-				const bytes = payload.data.slice();
-				await this.putBinary(db, this.assetStore, payload.assetId, bytes);
-				break;
-			}
-			case "meta": {
-				const bytes = payload.update.slice();
-				await this.putBinary(db, this.metaStore, this.metaKey, bytes);
-				break;
-			}
-			default: throw new Error("Unsupported storage payload type");
-		}
-	}
-	async deleteAsset(assetId) {
-		const db = await this.ensureDb();
-		await this.deleteKey(db, this.assetStore, assetId);
-	}
-	async loadDoc(docId) {
-		const db = await this.ensureDb();
-		const snapshot = await this.getBinaryFromDb(db, this.docStore, docId);
-		const pendingUpdates = await this.getDocUpdates(db, docId);
-		if (!snapshot && pendingUpdates.length === 0) return;
-		let doc;
-		try {
-			doc = snapshot ? LoroDoc.fromSnapshot(snapshot) : new LoroDoc();
-		} catch (error) {
-			throw this.createError(`Failed to hydrate document snapshot for "${docId}"`, error);
-		}
-		let appliedUpdates = false;
-		for (const update of pendingUpdates) try {
-			doc.import(update);
-			appliedUpdates = true;
-		} catch (error) {
-			throw this.createError(`Failed to apply queued document update for "${docId}"`, error);
-		}
-		if (appliedUpdates) {
-			let consolidated;
-			try {
-				consolidated = doc.export({ mode: "snapshot" });
-			} catch (error) {
-				throw this.createError(`Failed to export consolidated snapshot for "${docId}"`, error);
-			}
-			await this.writeSnapshot(db, docId, consolidated);
-			await this.clearDocUpdates(db, docId);
-		}
-		return doc;
-	}
-	async loadMeta() {
-		const bytes = await this.getBinary(this.metaStore, this.metaKey);
-		if (!bytes) return void 0;
-		try {
-			const json = textDecoder$1.decode(bytes);
-			const bundle = JSON.parse(json);
-			const flock = new Flock();
-			flock.importJson(bundle);
-			return flock;
-		} catch (error) {
-			throw this.createError("Failed to hydrate metadata snapshot", error);
-		}
-	}
-	async loadAsset(assetId) {
-		return await this.getBinary(this.assetStore, assetId) ?? void 0;
-	}
-	async close() {
-		this.closed = true;
-		const db = await this.dbPromise;
-		if (db) db.close();
-		this.dbPromise = void 0;
-	}
-	async ensureDb() {
-		if (this.closed) throw new Error("IndexedDBStorageAdaptor has been closed");
-		if (!this.dbPromise) this.dbPromise = new Promise((resolve, reject) => {
-			const request = this.idb.open(this.dbName, this.version);
-			request.addEventListener("upgradeneeded", () => {
-				const db = request.result;
-				this.ensureStore(db, this.docStore);
-				this.ensureStore(db, this.docUpdateStore);
-				this.ensureStore(db, this.metaStore);
-				this.ensureStore(db, this.assetStore);
-			});
-			request.addEventListener("success", () => resolve(request.result), { once: true });
-			request.addEventListener("error", () => {
-				reject(this.createError(`Failed to open IndexedDB database "${this.dbName}"`, request.error));
-			}, { once: true });
-		});
-		return this.dbPromise;
-	}
-	ensureStore(db, storeName) {
-		const names = db.objectStoreNames;
-		if (this.storeExists(names, storeName)) return;
-		db.createObjectStore(storeName);
-	}
-	storeExists(names, storeName) {
-		if (typeof names.contains === "function") return names.contains(storeName);
-		const length = names.length ?? 0;
-		for (let index = 0; index < length; index += 1) if (names.item?.(index) === storeName) return true;
-		return false;
-	}
-	async storeMergedSnapshot(db, docId, incoming) {
-		await this.runInTransaction(db, this.docStore, "readwrite", async (store) => {
-			const existingRaw = await this.wrapRequest(store.get(docId), "read");
-			const existing = await this.normalizeBinary(existingRaw);
-			const merged = this.mergeSnapshots(docId, existing, incoming);
-			await this.wrapRequest(store.put(merged, docId), "write");
-		});
-	}
-	mergeSnapshots(docId, existing, incoming) {
-		try {
-			const doc = existing ? LoroDoc.fromSnapshot(existing) : new LoroDoc();
-			doc.import(incoming);
-			return doc.export({ mode: "snapshot" });
-		} catch (error) {
-			throw this.createError(`Failed to merge snapshot for "${docId}"`, error);
-		}
-	}
-	async appendDocUpdate(db, docId, update) {
-		await this.runInTransaction(db, this.docUpdateStore, "readwrite", async (store) => {
-			const raw = await this.wrapRequest(store.get(docId), "read");
-			const queue = await this.normalizeUpdateQueue(raw);
-			queue.push(update.slice());
-			await this.wrapRequest(store.put({ updates: queue }, docId), "write");
-		});
-	}
-	async getDocUpdates(db, docId) {
-		const raw = await this.runInTransaction(db, this.docUpdateStore, "readonly", (store) => this.wrapRequest(store.get(docId), "read"));
-		return this.normalizeUpdateQueue(raw);
-	}
-	async clearDocUpdates(db, docId) {
-		await this.runInTransaction(db, this.docUpdateStore, "readwrite", (store) => this.wrapRequest(store.delete(docId), "delete"));
-	}
-	async writeSnapshot(db, docId, snapshot) {
-		await this.putBinary(db, this.docStore, docId, snapshot.slice());
+	async writeSnapshot(db, docId, snapshot) {
+		await this.putBinary(db, this.docStore, docId, snapshot.slice());
 	}
 	async getBinaryFromDb(db, storeName, key) {
 		const value = await this.runInTransaction(db, storeName, "readonly", (store) => this.wrapRequest(store.get(key), "read"));
@@ -1066,22 +642,445 @@ async function removeIfExists(filePath) {
 		if (error.code === "ENOENT") return;
 		throw error;
 	}
-}
-async function listFiles(dir) {
-	try {
-		return (await promises.readdir(dir)).sort();
-	} catch (error) {
-		if (error.code === "ENOENT") return [];
-		throw error;
+}
+async function listFiles(dir) {
+	try {
+		return (await promises.readdir(dir)).sort();
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	}
+}
+async function writeFileAtomic(targetPath, data) {
+	const dir = path.dirname(targetPath);
+	await ensureDir(dir);
+	const tempPath = path.join(dir, `.tmp-${randomUUID()}`);
+	await promises.writeFile(tempPath, data);
+	await promises.rename(tempPath, targetPath);
+}
+//#endregion
+//#region src/internal/debug.ts
+const getEnv = () => {
+	if (typeof globalThis !== "object" || globalThis === null) return;
+	return globalThis.process?.env;
+};
+const rawNamespaceConfig = (getEnv()?.LORO_REPO_DEBUG ?? "").trim();
+const normalizedNamespaces = rawNamespaceConfig.length > 0 ? rawNamespaceConfig.split(/[\s,]+/).map((token) => token.toLowerCase()).filter(Boolean) : [];
+const wildcardTokens = new Set([
+	"*",
+	"1",
+	"true",
+	"all"
+]);
+const namespaceSet = new Set(normalizedNamespaces);
+const hasWildcard = namespaceSet.size > 0 && normalizedNamespaces.some((token) => wildcardTokens.has(token));
+const isDebugEnabled = (namespace) => {
+	if (!namespaceSet.size) return false;
+	if (!namespace) return hasWildcard;
+	const normalized = namespace.toLowerCase();
+	if (hasWildcard) return true;
+	if (namespaceSet.has(normalized)) return true;
+	const [root] = normalized.split(":");
+	return namespaceSet.has(root);
+};
+const createDebugLogger = (namespace) => {
+	const normalized = namespace.toLowerCase();
+	return (...args) => {
+		if (!isDebugEnabled(normalized)) return;
+		const prefix = `[loro-repo:${namespace}]`;
+		if (args.length === 0) {
+			console.info(prefix);
+			return;
+		}
+		console.info(prefix, ...args);
+	};
+};
+//#endregion
+//#region src/transport/websocket.ts
+const debug = createDebugLogger("transport:websocket");
+function withTimeout(promise, timeoutMs) {
+	if (!timeoutMs || timeoutMs <= 0) return promise;
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`Operation timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		promise.then((value) => {
+			clearTimeout(timer);
+			resolve(value);
+		}).catch((error) => {
+			clearTimeout(timer);
+			reject(error);
+		});
+	});
+}
+function normalizeRoomId(roomId, fallback) {
+	if (typeof roomId === "string" && roomId.length > 0) return roomId;
+	if (roomId instanceof Uint8Array && roomId.length > 0) try {
+		return bytesToHex(roomId);
+	} catch {
+		return fallback;
+	}
+	return fallback;
+}
+function bytesEqual(a, b) {
+	if (a === b) return true;
+	if (!a || !b) return false;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
+	return true;
+}
+/**
+* loro-websocket backed {@link TransportAdapter} implementation for LoroRepo.
+* It uses loro-protocol as the underlying protocol for the transport.
+*/
+var WebSocketTransportAdapter = class {
+	options;
+	client;
+	metadataSession;
+	docSessions = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	async connect(_options) {
+		const client = this.ensureClient();
+		debug("connect requested", { status: client.getStatus() });
+		try {
+			await client.connect();
+			debug("client.connect resolved");
+			await client.waitConnected();
+			debug("client.waitConnected resolved", { status: client.getStatus() });
+		} catch (error) {
+			debug("connect failed", error);
+			throw error;
+		}
+	}
+	async close() {
+		debug("close requested", {
+			docSessions: this.docSessions.size,
+			metadataSession: Boolean(this.metadataSession)
+		});
+		for (const [docId] of this.docSessions) await this.leaveDocSession(docId).catch(() => {});
+		this.docSessions.clear();
+		await this.teardownMetadataSession().catch(() => {});
+		if (this.client) {
+			const client = this.client;
+			this.client = void 0;
+			client.destroy();
+			debug("websocket client destroyed");
+		}
+		debug("close completed");
+	}
+	isConnected() {
+		return this.client?.getStatus() === "connected";
+	}
+	async syncMeta(flock, options) {
+		debug("syncMeta requested", { roomId: this.options.metadataRoomId });
+		try {
+			let auth;
+			if (this.options.metadataAuth) if (typeof this.options.metadataAuth === "function") auth = await this.options.metadataAuth();
+			else auth = this.options.metadataAuth;
+			await withTimeout((await this.ensureMetadataSession(flock, {
+				roomId: this.options.metadataRoomId ?? "repo:meta",
+				auth
+			})).firstSynced, options?.timeout);
+			debug("syncMeta completed", { roomId: this.options.metadataRoomId });
+			return { ok: true };
+		} catch (error) {
+			debug("syncMeta failed", error);
+			return { ok: false };
+		}
+	}
+	joinMetaRoom(flock, params) {
+		const fallback = this.options.metadataRoomId ?? "";
+		const roomId = normalizeRoomId(params?.roomId, fallback);
+		if (!roomId) throw new Error("Metadata room id not configured");
+		const session = (async () => {
+			let auth;
+			const authWay = params?.auth ?? this.options.metadataAuth;
+			if (typeof authWay === "function") auth = await authWay();
+			else auth = authWay;
+			debug("joinMetaRoom requested", {
+				roomId,
+				hasAuth: Boolean(auth && auth.length)
+			});
+			return this.ensureMetadataSession(flock, {
+				roomId,
+				auth
+			});
+		})();
+		const firstSynced = session.then((session$1) => session$1.firstSynced);
+		const getConnected = () => this.isConnected();
+		const subscription = {
+			unsubscribe: () => {
+				session.then((session$1) => {
+					session$1.refCount = Math.max(0, session$1.refCount - 1);
+					debug("metadata session refCount decremented", {
+						roomId: session$1.roomId,
+						refCount: session$1.refCount
+					});
+					if (session$1.refCount === 0) {
+						debug("tearing down metadata session due to refCount=0", { roomId: session$1.roomId });
+						this.teardownMetadataSession(session$1).catch(() => {});
+					}
+				});
+			},
+			firstSyncedWithRemote: firstSynced,
+			get connected() {
+				return getConnected();
+			}
+		};
+		session.then((session$1) => {
+			session$1.refCount += 1;
+			debug("metadata session refCount incremented", {
+				roomId: session$1.roomId,
+				refCount: session$1.refCount
+			});
+		});
+		return subscription;
+	}
+	async syncDoc(docId, doc, options) {
+		debug("syncDoc requested", { docId });
+		try {
+			const session = await this.ensureDocSession(docId, doc, {});
+			await withTimeout(session.firstSynced, options?.timeout);
+			debug("syncDoc completed", {
+				docId,
+				roomId: session.roomId
+			});
+			return { ok: true };
+		} catch (error) {
+			debug("syncDoc failed", {
+				docId,
+				error
+			});
+			return { ok: false };
+		}
+	}
+	joinDocRoom(docId, doc, params) {
+		debug("joinDocRoom requested", {
+			docId,
+			roomParamType: params?.roomId ? typeof params.roomId === "string" ? "string" : "uint8array" : void 0,
+			hasAuthOverride: Boolean(params?.auth && params.auth.length)
+		});
+		const ensure = this.ensureDocSession(docId, doc, params ?? {});
+		const firstSynced = ensure.then((session) => session.firstSynced);
+		const getConnected = () => this.isConnected();
+		const subscription = {
+			unsubscribe: () => {
+				ensure.then((session) => {
+					session.refCount = Math.max(0, session.refCount - 1);
+					debug("doc session refCount decremented", {
+						docId,
+						roomId: session.roomId,
+						refCount: session.refCount
+					});
+					if (session.refCount === 0) this.leaveDocSession(docId).catch(() => {});
+				});
+			},
+			firstSyncedWithRemote: firstSynced,
+			get connected() {
+				return getConnected();
+			}
+		};
+		ensure.then((session) => {
+			session.refCount += 1;
+			debug("doc session refCount incremented", {
+				docId,
+				roomId: session.roomId,
+				refCount: session.refCount
+			});
+		});
+		return subscription;
+	}
+	ensureClient() {
+		if (this.client) {
+			debug("reusing websocket client", { status: this.client.getStatus() });
+			return this.client;
+		}
+		const { url, client: clientOptions } = this.options;
+		debug("creating websocket client", {
+			url,
+			clientOptionsKeys: clientOptions ? Object.keys(clientOptions) : []
+		});
+		const client = new LoroWebsocketClient({
+			url,
+			...clientOptions
+		});
+		this.client = client;
+		return client;
+	}
+	async ensureMetadataSession(flock, params) {
+		debug("ensureMetadataSession invoked", {
+			roomId: params.roomId,
+			hasAuth: Boolean(params.auth && params.auth.length)
+		});
+		const client = this.ensureClient();
+		await client.waitConnected();
+		debug("websocket client ready for metadata session", { status: client.getStatus() });
+		if (this.metadataSession && this.metadataSession.flock === flock && this.metadataSession.roomId === params.roomId && bytesEqual(this.metadataSession.auth, params.auth)) {
+			debug("reusing metadata session", {
+				roomId: this.metadataSession.roomId,
+				refCount: this.metadataSession.refCount
+			});
+			return this.metadataSession;
+		}
+		if (this.metadataSession) {
+			debug("tearing down previous metadata session", { roomId: this.metadataSession.roomId });
+			await this.teardownMetadataSession(this.metadataSession).catch(() => {});
+		}
+		const adaptor = new FlockAdaptor(flock, this.options.metadataAdaptorConfig);
+		debug("joining metadata room", {
+			roomId: params.roomId,
+			hasAuth: Boolean(params.auth && params.auth.length)
+		});
+		const room = await client.join({
+			roomId: params.roomId,
+			crdtAdaptor: adaptor,
+			auth: params.auth
+		});
+		const firstSynced = room.waitForReachingServerVersion();
+		firstSynced.then(() => {
+			debug("metadata session firstSynced resolved", { roomId: params.roomId });
+		}, (error) => {
+			debug("metadata session firstSynced rejected", {
+				roomId: params.roomId,
+				error
+			});
+		});
+		const session = {
+			adaptor,
+			room,
+			firstSynced,
+			flock,
+			roomId: params.roomId,
+			auth: params.auth,
+			refCount: 0
+		};
+		this.metadataSession = session;
+		return session;
+	}
+	async teardownMetadataSession(session) {
+		const target = session ?? this.metadataSession;
+		if (!target) return;
+		debug("teardownMetadataSession invoked", { roomId: target.roomId });
+		if (this.metadataSession === target) this.metadataSession = void 0;
+		const { adaptor, room } = target;
+		try {
+			await room.leave();
+			debug("metadata room left", { roomId: target.roomId });
+		} catch (error) {
+			debug("metadata room leave failed; destroying", {
+				roomId: target.roomId,
+				error
+			});
+			await room.destroy().catch(() => {});
+		}
+		adaptor.destroy();
+		debug("metadata session destroyed", { roomId: target.roomId });
+	}
+	async ensureDocSession(docId, doc, params) {
+		debug("ensureDocSession invoked", { docId });
+		const client = this.ensureClient();
+		await client.waitConnected();
+		debug("websocket client ready for doc session", {
+			docId,
+			status: client.getStatus()
+		});
+		const existing = this.docSessions.get(docId);
+		const derivedRoomId = this.options.docRoomId?.(docId) ?? docId;
+		const roomId = normalizeRoomId(params.roomId, derivedRoomId);
+		let auth;
+		auth = await (params.auth ?? this.options.docAuth?.(docId));
+		debug("doc session params resolved", {
+			docId,
+			roomId,
+			hasAuth: Boolean(auth && auth.length)
+		});
+		if (existing && existing.doc === doc && existing.roomId === roomId) {
+			debug("reusing doc session", {
+				docId,
+				roomId,
+				refCount: existing.refCount
+			});
+			return existing;
+		}
+		if (existing) {
+			debug("doc session mismatch; leaving existing session", {
+				docId,
+				previousRoomId: existing.roomId,
+				nextRoomId: roomId
+			});
+			await this.leaveDocSession(docId).catch(() => {});
+		}
+		const adaptor = new LoroAdaptor(doc);
+		debug("joining doc room", {
+			docId,
+			roomId,
+			hasAuth: Boolean(auth && auth.length)
+		});
+		const room = await client.join({
+			roomId,
+			crdtAdaptor: adaptor,
+			auth
+		});
+		const firstSynced = room.waitForReachingServerVersion();
+		firstSynced.then(() => {
+			debug("doc session firstSynced resolved", {
+				docId,
+				roomId
+			});
+		}, (error) => {
+			debug("doc session firstSynced rejected", {
+				docId,
+				roomId,
+				error
+			});
+		});
+		const session = {
+			adaptor,
+			room,
+			firstSynced,
+			doc,
+			roomId,
+			refCount: 0
+		};
+		this.docSessions.set(docId, session);
+		return session;
+	}
+	async leaveDocSession(docId) {
+		const session = this.docSessions.get(docId);
+		if (!session) {
+			debug("leaveDocSession invoked but no session found", { docId });
+			return;
+		}
+		this.docSessions.delete(docId);
+		debug("leaving doc session", {
+			docId,
+			roomId: session.roomId
+		});
+		try {
+			await session.room.leave();
+			debug("doc room left", {
+				docId,
+				roomId: session.roomId
+			});
+		} catch (error) {
+			debug("doc room leave failed; destroying", {
+				docId,
+				roomId: session.roomId,
+				error
+			});
+			await session.room.destroy().catch(() => {});
+		}
+		session.adaptor.destroy();
+		debug("doc session destroyed", {
+			docId,
+			roomId: session.roomId
+		});
 	}
-}
-async function writeFileAtomic(targetPath, data) {
-	const dir = path.dirname(targetPath);
-	await ensureDir(dir);
-	const tempPath = path.join(dir, `.tmp-${randomUUID()}`);
-	await promises.writeFile(tempPath, data);
-	await promises.rename(tempPath, targetPath);
-}
+};
 //#endregion
 //#region src/internal/event-bus.ts
@@ -1102,223 +1101,35 @@ var RepoEventBus = class {
 		for (const entry of this.watchers) if (this.shouldNotify(entry.filter, event)) entry.listener(event);
 	}
 	clear() {
-		this.watchers.clear();
-		this.eventByStack.length = 0;
-	}
-	pushEventBy(by) {
-		this.eventByStack.push(by);
-	}
-	popEventBy() {
-		this.eventByStack.pop();
-	}
-	resolveEventBy(defaultBy) {
-		const index = this.eventByStack.length - 1;
-		return index >= 0 ? this.eventByStack[index] : defaultBy;
-	}
-	shouldNotify(filter, event) {
-		if (!filter.docIds && !filter.kinds && !filter.metadataFields && !filter.by) return true;
-		if (filter.kinds && !filter.kinds.includes(event.kind)) return false;
-		if (filter.by && !filter.by.includes(event.by)) return false;
-		const docId = (() => {
-			if (event.kind === "doc-metadata" || event.kind === "doc-frontiers") return event.docId;
-			if (event.kind === "asset-link" || event.kind === "asset-unlink") return event.docId;
-		})();
-		if (filter.docIds && docId && !filter.docIds.includes(docId)) return false;
-		if (filter.docIds && !docId) return false;
-		if (filter.metadataFields && event.kind === "doc-metadata") {
-			if (!Object.keys(event.patch).some((key) => filter.metadataFields?.includes(key))) return false;
-		}
-		return true;
-	}
-};
-//#endregion
-//#region src/utils.ts
-async function streamToUint8Array(stream) {
-	const reader = stream.getReader();
-	const chunks = [];
-	let total = 0;
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		if (value) {
-			chunks.push(value);
-			total += value.byteLength;
-		}
-	}
-	const buffer = new Uint8Array(total);
-	let offset = 0;
-	for (const chunk of chunks) {
-		buffer.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	return buffer;
-}
-async function assetContentToUint8Array(content) {
-	if (content instanceof Uint8Array) return content;
-	if (ArrayBuffer.isView(content)) return new Uint8Array(content.buffer.slice(content.byteOffset, content.byteOffset + content.byteLength));
-	if (typeof Blob !== "undefined" && content instanceof Blob) return new Uint8Array(await content.arrayBuffer());
-	if (typeof ReadableStream !== "undefined" && content instanceof ReadableStream) return streamToUint8Array(content);
-	throw new TypeError("Unsupported asset content type");
-}
-function bytesToHex$1(bytes) {
-	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-async function computeSha256(bytes) {
-	const globalCrypto = globalThis.crypto;
-	if (globalCrypto?.subtle && typeof globalCrypto.subtle.digest === "function") {
-		const digest = await globalCrypto.subtle.digest("SHA-256", bytes);
-		return bytesToHex$1(new Uint8Array(digest));
-	}
-	try {
-		const { createHash } = await import("node:crypto");
-		const hash = createHash("sha256");
-		hash.update(bytes);
-		return hash.digest("hex");
-	} catch {
-		throw new Error("SHA-256 digest is not available in this environment");
-	}
-}
-function cloneJsonValue(value) {
-	if (value === null) return null;
-	if (typeof value === "string" || typeof value === "boolean") return value;
-	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
-	if (Array.isArray(value)) {
-		const arr = [];
-		for (const entry of value) {
-			const cloned = cloneJsonValue(entry);
-			if (cloned !== void 0) arr.push(cloned);
-		}
-		return arr;
-	}
-	if (value && typeof value === "object") {
-		const input = value;
-		const obj = {};
-		for (const [key, entry] of Object.entries(input)) {
-			const cloned = cloneJsonValue(entry);
-			if (cloned !== void 0) obj[key] = cloned;
-		}
-		return obj;
-	}
-}
-function cloneJsonObject(value) {
-	const cloned = cloneJsonValue(value);
-	if (cloned && typeof cloned === "object" && !Array.isArray(cloned)) return cloned;
-	return {};
-}
-function asJsonObject(value) {
-	const cloned = cloneJsonValue(value);
-	if (cloned && typeof cloned === "object" && !Array.isArray(cloned)) return cloned;
-}
-function isJsonObjectValue(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function stableStringify(value) {
-	if (value === null) return "null";
-	if (typeof value === "string") return JSON.stringify(value);
-	if (typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
-	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
-	if (!isJsonObjectValue(value)) return "null";
-	return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
-}
-function jsonEquals(a, b) {
-	if (a === void 0 && b === void 0) return true;
-	if (a === void 0 || b === void 0) return false;
-	return stableStringify(a) === stableStringify(b);
-}
-function diffJsonObjects(previous, next) {
-	const patch = {};
-	const keys = /* @__PURE__ */ new Set();
-	if (previous) for (const key of Object.keys(previous)) keys.add(key);
-	for (const key of Object.keys(next)) keys.add(key);
-	for (const key of keys) {
-		const prevValue = previous ? previous[key] : void 0;
-		const nextValue = next[key];
-		if (!jsonEquals(prevValue, nextValue)) {
-			if (nextValue === void 0 && previous && key in previous) {
-				patch[key] = null;
-				continue;
-			}
-			const cloned = cloneJsonValue(nextValue);
-			if (cloned !== void 0) patch[key] = cloned;
-		}
-	}
-	return patch;
-}
-function assetMetaToJson(meta) {
-	const json = {
-		assetId: meta.assetId,
-		size: meta.size,
-		createdAt: meta.createdAt
-	};
-	if (meta.mime !== void 0) json.mime = meta.mime;
-	if (meta.policy !== void 0) json.policy = meta.policy;
-	if (meta.tag !== void 0) json.tag = meta.tag;
-	return json;
-}
-function assetMetaFromJson(value) {
-	const obj = asJsonObject(value);
-	if (!obj) return void 0;
-	const assetId = typeof obj.assetId === "string" ? obj.assetId : void 0;
-	if (!assetId) return void 0;
-	const size = typeof obj.size === "number" ? obj.size : void 0;
-	const createdAt = typeof obj.createdAt === "number" ? obj.createdAt : void 0;
-	if (size === void 0 || createdAt === void 0) return void 0;
-	return {
-		assetId,
-		size,
-		createdAt,
-		...typeof obj.mime === "string" ? { mime: obj.mime } : {},
-		...typeof obj.policy === "string" ? { policy: obj.policy } : {},
-		...typeof obj.tag === "string" ? { tag: obj.tag } : {}
-	};
-}
-function assetMetadataEqual(a, b) {
-	if (!a && !b) return true;
-	if (!a || !b) return false;
-	return stableStringify(assetMetaToJson(a)) === stableStringify(assetMetaToJson(b));
-}
-function cloneRepoAssetMetadata(meta) {
-	return {
-		assetId: meta.assetId,
-		size: meta.size,
-		createdAt: meta.createdAt,
-		...meta.mime !== void 0 ? { mime: meta.mime } : {},
-		...meta.policy !== void 0 ? { policy: meta.policy } : {},
-		...meta.tag !== void 0 ? { tag: meta.tag } : {}
-	};
-}
-function toReadableStream(bytes) {
-	return new ReadableStream({ start(controller) {
-		controller.enqueue(bytes);
-		controller.close();
-	} });
-}
-function canonicalizeFrontiers(frontiers) {
-	const json = [...frontiers].sort((a, b) => {
-		if (a.peer < b.peer) return -1;
-		if (a.peer > b.peer) return 1;
-		return a.counter - b.counter;
-	}).map((f) => ({
-		peer: f.peer,
-		counter: f.counter
-	}));
-	return {
-		json,
-		key: stableStringify(json)
-	};
-}
-function includesFrontiers(vv, frontiers) {
-	for (const { peer, counter } of frontiers) if ((vv.get(peer) ?? 0) <= counter) return false;
-	return true;
-}
-function matchesQuery(docId, _metadata, query) {
-	if (!query) return true;
-	if (query.prefix && !docId.startsWith(query.prefix)) return false;
-	if (query.start && docId < query.start) return false;
-	if (query.end && docId > query.end) return false;
-	return true;
-}
+		this.watchers.clear();
+		this.eventByStack.length = 0;
+	}
+	pushEventBy(by) {
+		this.eventByStack.push(by);
+	}
+	popEventBy() {
+		this.eventByStack.pop();
+	}
+	resolveEventBy(defaultBy) {
+		const index = this.eventByStack.length - 1;
+		return index >= 0 ? this.eventByStack[index] : defaultBy;
+	}
+	shouldNotify(filter, event) {
+		if (!filter.docIds && !filter.kinds && !filter.metadataFields && !filter.by) return true;
+		if (filter.kinds && !filter.kinds.includes(event.kind)) return false;
+		if (filter.by && !filter.by.includes(event.by)) return false;
+		const docId = (() => {
+			if (event.kind === "doc-metadata" || event.kind === "doc-frontiers") return event.docId;
+			if (event.kind === "asset-link" || event.kind === "asset-unlink") return event.docId;
+		})();
+		if (filter.docIds && docId && !filter.docIds.includes(docId)) return false;
+		if (filter.docIds && !docId) return false;
+		if (filter.metadataFields && event.kind === "doc-metadata") {
+			if (!Object.keys(event.patch).some((key) => filter.metadataFields?.includes(key))) return false;
+		}
+		return true;
+	}
+};
 //#endregion
 //#region src/internal/logging.ts
@@ -1337,23 +1148,18 @@ var DocManager = class {
 	getMetaFlock;
 	eventBus;
 	persistMeta;
-	state;
 	docs = /* @__PURE__ */ new Map();
 	docSubscriptions = /* @__PURE__ */ new Map();
 	docFrontierUpdates = /* @__PURE__ */ new Map();
 	docPersistedVersions = /* @__PURE__ */ new Map();
-	get docFrontierKeys() {
-		return this.state.docFrontierKeys;
-	}
 	constructor(options) {
 		this.storage = options.storage;
 		this.docFrontierDebounceMs = options.docFrontierDebounceMs;
 		this.getMetaFlock = options.getMetaFlock;
 		this.eventBus = options.eventBus;
 		this.persistMeta = options.persistMeta;
-		this.state = options.state;
 	}
-	async openCollaborativeDoc(docId) {
+	async openPersistedDoc(docId) {
 		return await this.ensureDoc(docId);
 	}
 	async openDetachedDoc(docId) {
@@ -1400,38 +1206,27 @@ var DocManager = class {
 	}
 	async updateDocFrontiers(docId, doc, defaultBy) {
 		const frontiers = doc.oplogFrontiers();
-		const { json, key } = canonicalizeFrontiers(frontiers);
-		const existingKeys = this.docFrontierKeys.get(docId) ?? /* @__PURE__ */ new Set();
+		const vv = doc.version();
+		const existingFrontiers = this.readFrontiersFromFlock(docId);
 		let mutated = false;
 		const metaFlock = this.metaFlock;
-		const vv = doc.version();
-		for (const entry of existingKeys) {
-			if (entry === key) continue;
-			let oldFrontiers;
-			try {
-				oldFrontiers = JSON.parse(entry);
-			} catch {
-				continue;
-			}
-			if (includesFrontiers(vv, oldFrontiers)) {
-				metaFlock.delete([
-					"f",
-					docId,
-					entry
-				]);
-				mutated = true;
-			}
-		}
-		if (!existingKeys.has(key)) {
+		for (const f of frontiers) if (existingFrontiers.get(f.peer) !== f.counter) {
 			metaFlock.put([
 				"f",
 				docId,
-				key
-			], json);
+				f.peer
+			], f.counter);
 			mutated = true;
 		}
 		if (mutated) {
-			this.refreshDocFrontierKeys(docId);
+			for (const [peer, counter] of existingFrontiers) {
+				const docCounterEnd = vv.get(peer);
+				if (docCounterEnd != null && docCounterEnd > counter) metaFlock.delete([
+					"f",
+					docId,
+					peer
+				]);
+			}
 			await this.persistMeta();
 		}
 		const by = this.eventBus.resolveEventBy(defaultBy);
@@ -1483,37 +1278,22 @@ var DocManager = class {
 		this.docFrontierUpdates.clear();
 		this.docs.clear();
 		this.docPersistedVersions.clear();
-		this.docFrontierKeys.clear();
 	}
-	hydrateFrontierKeys() {
-		const nextFrontierKeys = /* @__PURE__ */ new Map();
-		const frontierRows = this.metaFlock.scan({ prefix: ["f"] });
-		for (const row of frontierRows) {
-			if (!Array.isArray(row.key) || row.key.length < 3) continue;
-			const docId = row.key[1];
-			const frontierKey = row.key[2];
-			if (typeof docId !== "string" || typeof frontierKey !== "string") continue;
-			const set = nextFrontierKeys.get(docId) ?? /* @__PURE__ */ new Set();
-			set.add(frontierKey);
-			nextFrontierKeys.set(docId, set);
-		}
-		this.docFrontierKeys.clear();
-		for (const [docId, keys] of nextFrontierKeys) this.docFrontierKeys.set(docId, keys);
+	get metaFlock() {
+		return this.getMetaFlock();
 	}
-	refreshDocFrontierKeys(docId) {
+	readFrontiersFromFlock(docId) {
 		const rows = this.metaFlock.scan({ prefix: ["f", docId] });
-		const keys = /* @__PURE__ */ new Set();
+		const frontiers = /* @__PURE__ */ new Map();
 		for (const row of rows) {
 			if (!Array.isArray(row.key) || row.key.length < 3) continue;
-			if (row.value === void 0 || row.value === null) continue;
-			const frontierKey = row.key[2];
-			if (typeof frontierKey === "string") keys.add(frontierKey);
+			const peer = row.key[2];
+			const counter = row.value;
+			if (typeof peer !== "string") continue;
+			if (typeof counter !== "number" || !Number.isFinite(counter)) continue;
+			frontiers.set(peer, counter);
 		}
-		if (keys.size > 0) this.docFrontierKeys.set(docId, keys);
-		else this.docFrontierKeys.delete(docId);
-	}
-	get metaFlock() {
-		return this.getMetaFlock();
+		return frontiers;
 	}
 	registerDoc(docId, doc) {
 		this.docs.set(docId, doc);
@@ -1626,6 +1406,176 @@ var DocManager = class {
 	}
 };
+//#endregion
+//#region src/utils.ts
+async function streamToUint8Array(stream) {
+	const reader = stream.getReader();
+	const chunks = [];
+	let total = 0;
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		if (value) {
+			chunks.push(value);
+			total += value.byteLength;
+		}
+	}
+	const buffer = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		buffer.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return buffer;
+}
+async function assetContentToUint8Array(content) {
+	if (content instanceof Uint8Array) return content;
+	if (ArrayBuffer.isView(content)) return new Uint8Array(content.buffer.slice(content.byteOffset, content.byteOffset + content.byteLength));
+	if (typeof Blob !== "undefined" && content instanceof Blob) return new Uint8Array(await content.arrayBuffer());
+	if (typeof ReadableStream !== "undefined" && content instanceof ReadableStream) return streamToUint8Array(content);
+	throw new TypeError("Unsupported asset content type");
+}
+function bytesToHex$1(bytes) {
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function computeSha256(bytes) {
+	const globalCrypto = globalThis.crypto;
+	if (globalCrypto?.subtle && typeof globalCrypto.subtle.digest === "function") {
+		const digest = await globalCrypto.subtle.digest("SHA-256", bytes);
+		return bytesToHex$1(new Uint8Array(digest));
+	}
+	try {
+		const { createHash } = await import("node:crypto");
+		const hash = createHash("sha256");
+		hash.update(bytes);
+		return hash.digest("hex");
+	} catch {
+		throw new Error("SHA-256 digest is not available in this environment");
+	}
+}
+function cloneJsonValue(value) {
+	if (value === null) return null;
+	if (typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+	if (Array.isArray(value)) {
+		const arr = [];
+		for (const entry of value) {
+			const cloned = cloneJsonValue(entry);
+			if (cloned !== void 0) arr.push(cloned);
+		}
+		return arr;
+	}
+	if (value && typeof value === "object") {
+		const input = value;
+		const obj = {};
+		for (const [key, entry] of Object.entries(input)) {
+			const cloned = cloneJsonValue(entry);
+			if (cloned !== void 0) obj[key] = cloned;
+		}
+		return obj;
+	}
+}
+function cloneJsonObject(value) {
+	const cloned = cloneJsonValue(value);
+	if (cloned && typeof cloned === "object" && !Array.isArray(cloned)) return cloned;
+	return {};
+}
+function asJsonObject(value) {
+	const cloned = cloneJsonValue(value);
+	if (cloned && typeof cloned === "object" && !Array.isArray(cloned)) return cloned;
+}
+function isJsonObjectValue(value) {
+	return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function stableStringify(value) {
+	if (value === null) return "null";
+	if (typeof value === "string") return JSON.stringify(value);
+	if (typeof value === "number" || typeof value === "boolean") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (!isJsonObjectValue(value)) return "null";
+	return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+}
+function jsonEquals(a, b) {
+	if (a === void 0 && b === void 0) return true;
+	if (a === void 0 || b === void 0) return false;
+	return stableStringify(a) === stableStringify(b);
+}
+function diffJsonObjects(previous, next) {
+	const patch = {};
+	const keys = /* @__PURE__ */ new Set();
+	if (previous) for (const key of Object.keys(previous)) keys.add(key);
+	for (const key of Object.keys(next)) keys.add(key);
+	for (const key of keys) {
+		const prevValue = previous ? previous[key] : void 0;
+		const nextValue = next[key];
+		if (!jsonEquals(prevValue, nextValue)) {
+			if (nextValue === void 0 && previous && key in previous) {
+				patch[key] = null;
+				continue;
+			}
+			const cloned = cloneJsonValue(nextValue);
+			if (cloned !== void 0) patch[key] = cloned;
+		}
+	}
+	return patch;
+}
+function assetMetaToJson(meta) {
+	const json = {
+		assetId: meta.assetId,
+		size: meta.size,
+		createdAt: meta.createdAt
+	};
+	if (meta.mime !== void 0) json.mime = meta.mime;
+	if (meta.policy !== void 0) json.policy = meta.policy;
+	if (meta.tag !== void 0) json.tag = meta.tag;
+	return json;
+}
+function assetMetaFromJson(value) {
+	const obj = asJsonObject(value);
+	if (!obj) return void 0;
+	const assetId = typeof obj.assetId === "string" ? obj.assetId : void 0;
+	if (!assetId) return void 0;
+	const size = typeof obj.size === "number" ? obj.size : void 0;
+	const createdAt = typeof obj.createdAt === "number" ? obj.createdAt : void 0;
+	if (size === void 0 || createdAt === void 0) return void 0;
+	return {
+		assetId,
+		size,
+		createdAt,
+		...typeof obj.mime === "string" ? { mime: obj.mime } : {},
+		...typeof obj.policy === "string" ? { policy: obj.policy } : {},
+		...typeof obj.tag === "string" ? { tag: obj.tag } : {}
+	};
+}
+function assetMetadataEqual(a, b) {
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	return stableStringify(assetMetaToJson(a)) === stableStringify(assetMetaToJson(b));
+}
+function cloneRepoAssetMetadata(meta) {
+	return {
+		assetId: meta.assetId,
+		size: meta.size,
+		createdAt: meta.createdAt,
+		...meta.mime !== void 0 ? { mime: meta.mime } : {},
+		...meta.policy !== void 0 ? { policy: meta.policy } : {},
+		...meta.tag !== void 0 ? { tag: meta.tag } : {}
+	};
+}
+function toReadableStream(bytes) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} });
+}
+function matchesQuery(docId, _metadata, query) {
+	if (!query) return true;
+	if (query.prefix && !docId.startsWith(query.prefix)) return false;
+	if (query.start && docId < query.start) return false;
+	if (query.end && docId > query.end) return false;
+	return true;
+}
 //#endregion
 //#region src/internal/metadata-manager.ts
 var MetadataManager = class {
@@ -1867,13 +1817,11 @@ var AssetManager = class {
 		if (params.assetId && params.assetId !== assetId) throw new Error("Provided assetId does not match content digest");
 		const existing = this.assets.get(assetId);
 		if (existing) {
-			if (!existing.data) {
-				const clone = bytes.slice();
-				existing.data = clone;
-				if (this.storage) await this.storage.save({
+			if (this.storage) {
+				if (!await this.storage.loadAsset(assetId)) await this.storage.save({
 					type: "asset",
 					assetId,
-					data: clone.slice()
+					data: bytes.slice()
 				});
 			}
 			let metadataMutated = false;
@@ -1900,7 +1848,7 @@ var AssetManager = class {
 				await this.persistMeta();
 				this.eventBus.emit({
 					kind: "asset-metadata",
-					asset: this.createAssetDownload(assetId, metadata$1, existing.data),
+					asset: this.createAssetDownload(assetId, metadata$1, bytes),
 					by: "local"
 				});
 			}
@@ -1930,7 +1878,8 @@ var AssetManager = class {
 			assetId,
 			data: storedBytes.slice()
 		});
-		this.rememberAsset(metadata, storedBytes);
+		this.rememberAsset(metadata);
+		this.markAssetAsOrphan(assetId, metadata);
 		this.updateDocAssetMetadata(assetId, metadata);
 		this.metaFlock.put(["a", assetId], assetMetaToJson(metadata));
 		await this.persistMeta();
@@ -1951,13 +1900,11 @@ var AssetManager = class {
 		const existing = this.assets.get(assetId);
 		if (existing) {
 			metadata = existing.metadata;
-			if (!existing.data) {
-				const clone = bytes.slice();
-				existing.data = clone;
-				if (this.storage) await this.storage.save({
+			if (this.storage) {
+				if (!await this.storage.loadAsset(assetId)) await this.storage.save({
 					type: "asset",
 					assetId,
-					data: clone.slice()
+					data: bytes.slice()
 				});
 			}
 			let nextMetadata = metadata;
@@ -1997,11 +1944,11 @@ var AssetManager = class {
 				await this.persistMeta();
 				this.eventBus.emit({
 					kind: "asset-metadata",
-					asset: this.createAssetDownload(assetId, metadata, existing.data),
+					asset: this.createAssetDownload(assetId, metadata, bytes),
 					by: "local"
 				});
 			} else metadata = existing.metadata;
-			storedBytes = existing.data;
+			storedBytes = bytes;
 			this.rememberAsset(metadata);
 		} else {
 			metadata = {
@@ -2027,7 +1974,7 @@ var AssetManager = class {
 				assetId,
 				data: storedBytes.slice()
 			});
-			this.rememberAsset(metadata, storedBytes);
+			this.rememberAsset(metadata);
 			this.updateDocAssetMetadata(assetId, metadata);
 			this.metaFlock.put(["a", assetId], assetMetaToJson(metadata));
 			created = true;
@@ -2035,9 +1982,7 @@ var AssetManager = class {
 		const mapping = this.docAssets.get(docId) ?? /* @__PURE__ */ new Map();
 		mapping.set(assetId, metadata);
 		this.docAssets.set(docId, mapping);
-		const refs = this.assetToDocRefs.get(assetId) ?? /* @__PURE__ */ new Set();
-		refs.add(docId);
-		this.assetToDocRefs.set(assetId, refs);
+		this.addDocReference(assetId, docId);
 		this.metaFlock.put([
 			"ld",
 			docId,
@@ -2067,20 +2012,7 @@ var AssetManager = class {
 			docId,
 			assetId
 		]);
-		const refs = this.assetToDocRefs.get(assetId);
-		if (refs) {
-			refs.delete(docId);
-			if (refs.size === 0) {
-				this.assetToDocRefs.delete(assetId);
-				const record = this.assets.get(assetId);
-				if (record) this.orphanedAssets.set(assetId, {
-					metadata: record.metadata,
-					deletedAt: Date.now()
-				});
-				this.metaFlock.delete(["a", assetId]);
-				this.assets.delete(assetId);
-			}
-		}
+		this.removeDocAssetReference(assetId, docId);
 		await this.persistMeta();
 		this.eventBus.emit({
 			kind: "asset-unlink",
@@ -2167,12 +2099,11 @@ var AssetManager = class {
 			this.handleAssetRemoval(assetId, by);
 			return;
 		}
-		const existingData = previous?.data;
-		this.rememberAsset(metadata, existingData);
+		this.rememberAsset(metadata);
 		this.updateDocAssetMetadata(assetId, cloneRepoAssetMetadata(metadata));
 		if (!previous || !assetMetadataEqual(previous.metadata, metadata)) this.eventBus.emit({
 			kind: "asset-metadata",
-			asset: this.createAssetDownload(assetId, metadata, existingData),
+			asset: this.createAssetDownload(assetId, metadata),
 			by
 		});
 	}
@@ -2187,11 +2118,7 @@ var AssetManager = class {
 			if (typeof assetId !== "string") continue;
 			const metadata = assetMetaFromJson(row.value);
 			if (!metadata) continue;
-			const existing = this.assets.get(assetId);
-			nextAssets.set(assetId, {
-				metadata,
-				data: existing?.data
-			});
+			nextAssets.set(assetId, { metadata });
 		}
 		const nextDocAssets = /* @__PURE__ */ new Map();
 		const linkRows = this.metaFlock.scan({ prefix: ["ld"] });
@@ -2227,12 +2154,18 @@ var AssetManager = class {
 			this.assetToDocRefs.set(assetId, refs);
 		}
 		this.assets.clear();
-		for (const record of nextAssets.values()) this.rememberAsset(record.metadata, record.data);
+		for (const record of nextAssets.values()) this.rememberAsset(record.metadata);
+		for (const assetId of nextAssets.keys()) {
+			const refs = this.assetToDocRefs.get(assetId);
+			if (!refs || refs.size === 0) {
+				if (!this.orphanedAssets.has(assetId)) this.markAssetAsOrphan(assetId, nextAssets.get(assetId).metadata);
+			} else this.orphanedAssets.delete(assetId);
+		}
 		for (const [assetId, record] of nextAssets) {
 			const previous = prevAssets.get(assetId)?.metadata;
 			if (!assetMetadataEqual(previous, record.metadata)) this.eventBus.emit({
 				kind: "asset-metadata",
-				asset: this.createAssetDownload(assetId, record.metadata, record.data),
+				asset: this.createAssetDownload(assetId, record.metadata),
 				by
 			});
 		}
@@ -2328,36 +2261,24 @@ var AssetManager = class {
 		};
 	}
 	async materializeAsset(assetId) {
-		let record = this.assets.get(assetId);
-		if (record?.data) return {
-			metadata: record.metadata,
-			bytes: record.data.slice()
-		};
+		const record = this.assets.get(assetId);
 		if (record && this.storage) {
 			const stored = await this.storage.loadAsset(assetId);
-			if (stored) {
-				const clone = stored.slice();
-				record.data = clone.slice();
-				return {
-					metadata: record.metadata,
-					bytes: clone
-				};
-			}
+			if (stored) return {
+				metadata: record.metadata,
+				bytes: stored
+			};
 		}
 		if (!record && this.storage) {
 			const stored = await this.storage.loadAsset(assetId);
 			if (stored) {
 				const metadata$1 = this.getAssetMetadata(assetId);
 				if (!metadata$1) throw new Error(`Missing metadata for asset ${assetId}`);
-				const clone = stored.slice();
-				this.assets.set(assetId, {
-					metadata: metadata$1,
-					data: clone.slice()
-				});
+				this.assets.set(assetId, { metadata: metadata$1 });
 				this.updateDocAssetMetadata(assetId, metadata$1);
 				return {
 					metadata: metadata$1,
-					bytes: clone
+					bytes: stored
 				};
 			}
 		}
@@ -2373,10 +2294,7 @@ var AssetManager = class {
 			...remote.policy ? { policy: remote.policy } : {},
 			...remote.tag ? { tag: remote.tag } : {}
 		};
-		this.assets.set(assetId, {
-			metadata,
-			data: remoteBytes.slice()
-		});
+		this.assets.set(assetId, { metadata });
 		this.updateDocAssetMetadata(assetId, metadata);
 		this.metaFlock.put(["a", assetId], assetMetaToJson(metadata));
 		await this.persistMeta();
@@ -2398,18 +2316,14 @@ var AssetManager = class {
 			if (assets) assets.set(assetId, metadata);
 		}
 	}
-	rememberAsset(metadata, bytes) {
-		const data = bytes ? bytes.slice() : this.assets.get(metadata.assetId)?.data;
-		this.assets.set(metadata.assetId, {
-			metadata,
-			data
-		});
-		this.orphanedAssets.delete(metadata.assetId);
+	rememberAsset(metadata) {
+		this.assets.set(metadata.assetId, { metadata });
 	}
 	addDocReference(assetId, docId) {
 		const refs = this.assetToDocRefs.get(assetId) ?? /* @__PURE__ */ new Set();
 		refs.add(docId);
 		this.assetToDocRefs.set(assetId, refs);
+		this.orphanedAssets.delete(assetId);
 	}
 	removeDocAssetReference(assetId, docId) {
 		const refs = this.assetToDocRefs.get(assetId);
@@ -2459,13 +2373,11 @@ var FlockHydrator = class {
 		const nextMetadata = this.readAllDocMetadata();
 		this.metadataManager.replaceAll(nextMetadata, by);
 		this.assetManager.hydrateFromFlock(by);
-		this.docManager.hydrateFrontierKeys();
 	}
 	applyEvents(events, by) {
 		if (!events.length) return;
 		const docMetadataIds = /* @__PURE__ */ new Set();
 		const docAssetIds = /* @__PURE__ */ new Set();
-		const docFrontiersIds = /* @__PURE__ */ new Set();
 		const assetIds = /* @__PURE__ */ new Set();
 		for (const event of events) {
 			const key = event.key;
@@ -2482,15 +2394,11 @@ var FlockHydrator = class {
 				const assetId = key[2];
 				if (typeof docId === "string") docAssetIds.add(docId);
 				if (typeof assetId === "string") assetIds.add(assetId);
-			} else if (root === "f") {
-				const docId = key[1];
-				if (typeof docId === "string") docFrontiersIds.add(docId);
 			}
 		}
 		for (const assetId of assetIds) this.assetManager.refreshAssetMetadataEntry(assetId, by);
 		for (const docId of docMetadataIds) this.metadataManager.refreshFromFlock(docId, by);
 		for (const docId of docAssetIds) this.assetManager.refreshDocAssetsEntry(docId, by);
-		for (const docId of docFrontiersIds) this.docManager.refreshDocFrontierKeys(docId);
 	}
 	readAllDocMetadata() {
 		const nextMetadata = /* @__PURE__ */ new Map();
@@ -2701,8 +2609,7 @@ function createRepoState() {
 		docAssets: /* @__PURE__ */ new Map(),
 		assets: /* @__PURE__ */ new Map(),
 		orphanedAssets: /* @__PURE__ */ new Map(),
-		assetToDocRefs: /* @__PURE__ */ new Map(),
-		docFrontierKeys: /* @__PURE__ */ new Map()
+		assetToDocRefs: /* @__PURE__ */ new Map()
 	};
 }
@@ -2738,8 +2645,7 @@ var LoroRepo = class LoroRepo {
 			docFrontierDebounceMs,
 			getMetaFlock: () => this.metaFlock,
 			eventBus: this.eventBus,
-			persistMeta: () => this.persistMeta(),
-			state: this.state
+			persistMeta: () => this.persistMeta()
 		});
 		this.metadataManager = new MetadataManager({
 			getMetaFlock: () => this.metaFlock,
@@ -2828,7 +2734,7 @@ var LoroRepo = class LoroRepo {
 	*/
 	async openPersistedDoc(docId) {
 		return {
-			doc: await this.docManager.openCollaborativeDoc(docId),
+			doc: await this.docManager.openPersistedDoc(docId),
 			syncOnce: () => {
 				return this.sync({
 					scope: "doc",