loro-repo 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -23,891 +23,466 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 //#endregion
 let __loro_dev_flock = require("@loro-dev/flock");
 __loro_dev_flock = __toESM(__loro_dev_flock);
-let loro_adaptors_loro = require("loro-adaptors/loro");
-loro_adaptors_loro = __toESM(loro_adaptors_loro);
-let loro_protocol = require("loro-protocol");
-loro_protocol = __toESM(loro_protocol);
-let loro_websocket = require("loro-websocket");
-loro_websocket = __toESM(loro_websocket);
 let loro_crdt = require("loro-crdt");
 loro_crdt = __toESM(loro_crdt);
-let loro_adaptors_flock = require("loro-adaptors/flock");
-loro_adaptors_flock = __toESM(loro_adaptors_flock);
 let node_fs = require("node:fs");
 node_fs = __toESM(node_fs);
 let node_path = require("node:path");
 node_path = __toESM(node_path);
 let node_crypto = require("node:crypto");
 node_crypto = __toESM(node_crypto);
+let loro_adaptors_loro = require("loro-adaptors/loro");
+loro_adaptors_loro = __toESM(loro_adaptors_loro);
+let loro_protocol = require("loro-protocol");
+loro_protocol = __toESM(loro_protocol);
+let loro_websocket = require("loro-websocket");
+loro_websocket = __toESM(loro_websocket);
+let loro_adaptors_flock = require("loro-adaptors/flock");
+loro_adaptors_flock = __toESM(loro_adaptors_flock);
 
-//#region src/loro-adaptor.ts
-function createRepoFlockAdaptorFromDoc(flock, config = {}) {
-	return new loro_adaptors_flock.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 (0, loro_protocol.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 };
-		}
+	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) {
-		debug("joinDocRoom requested", {
+	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 loro_websocket.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 !== loro_protocol.CrdtType.Flock) throw new Error(`metadataCrdtType must be ${loro_protocol.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 loro_adaptors_loro.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 ? loro_crdt.LoroDoc.fromSnapshot(snapshot) : new loro_crdt.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 __loro_dev_flock.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
+	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");
 		});
-		postChannelMessage(state.channel, {
-			kind: "doc-update",
-			docId,
-			from: this.instanceId,
-			mode: "snapshot",
-			payload: doc.export({ mode: "snapshot" })
+	}
+	mergeSnapshots(docId, existing, incoming) {
+		try {
+			const doc = existing ? loro_crdt.LoroDoc.fromSnapshot(existing) : new loro_crdt.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");
 		});
-		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;
+	async getDocUpdates(db, docId) {
+		const raw = await this.runInTransaction(db, this.docUpdateStore, "readonly", (store) => this.wrapRequest(store.get(docId), "read"));
+		return this.normalizeUpdateQueue(raw);
 	}
-	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 clearDocUpdates(db, docId) {
+		await this.runInTransaction(db, this.docUpdateStore, "readwrite", (store) => this.wrapRequest(store.delete(docId), "delete"));
 	}
-	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 writeSnapshot(db, docId, snapshot) {
+		await this.putBinary(db, this.docStore, docId, snapshot.slice());
 	}
-};
-
-//#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]";
-	}
-	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 ? loro_crdt.LoroDoc.fromSnapshot(snapshot) : new loro_crdt.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 __loro_dev_flock.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 ? loro_crdt.LoroDoc.fromSnapshot(existing) : new loro_crdt.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 getBinaryFromDb(db, storeName, key) {
-		const value = await this.runInTransaction(db, storeName, "readonly", (store) => this.wrapRequest(store.get(key), "read"));
-		return this.normalizeBinary(value);
+	async getBinaryFromDb(db, storeName, key) {
+		const value = await this.runInTransaction(db, storeName, "readonly", (store) => this.wrapRequest(store.get(key), "read"));
+		return this.normalizeBinary(value);
 	}
 	async normalizeUpdateQueue(value) {
 		if (value == null) return [];
@@ -1117,241 +692,476 @@ async function writeFileAtomic(targetPath, data) {
 }
 
 //#endregion
-//#region src/internal/event-bus.ts
-var RepoEventBus = class {
-	watchers = /* @__PURE__ */ new Set();
-	eventByStack = [];
-	watch(listener, filter = {}) {
-		const entry = {
-			listener,
-			filter
-		};
-		this.watchers.add(entry);
-		return { unsubscribe: () => {
-			this.watchers.delete(entry);
-		} };
-	}
-	emit(event) {
-		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;
+//#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;
 		}
-		return true;
-	}
+		console.info(prefix, ...args);
+	};
 };
 
 //#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;
+//#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);
+		});
+	});
 }
-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 normalizeRoomId(roomId, fallback) {
+	if (typeof roomId === "string" && roomId.length > 0) return roomId;
+	if (roomId instanceof Uint8Array && roomId.length > 0) try {
+		return (0, loro_protocol.bytesToHex)(roomId);
+	} catch {
+		return fallback;
+	}
+	return fallback;
 }
-function bytesToHex(bytes) {
-	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+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;
 }
-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(new Uint8Array(digest));
+/**
+* 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;
 	}
-	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");
+	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;
+		}
 	}
-}
-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);
+	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");
 		}
-		return arr;
+		debug("close completed");
 	}
-	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;
+	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 };
 		}
-		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;
+	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();
 			}
-			const cloned = cloneJsonValue(nextValue);
-			if (cloned !== void 0) patch[key] = cloned;
+		};
+		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 };
 		}
 	}
-	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;
-}
+	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 loro_websocket.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 loro_adaptors_flock.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 loro_adaptors_loro.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
+		});
+	}
+};
+
+//#endregion
+//#region src/internal/event-bus.ts
+var RepoEventBus = class {
+	watchers = /* @__PURE__ */ new Set();
+	eventByStack = [];
+	watch(listener, filter = {}) {
+		const entry = {
+			listener,
+			filter
+		};
+		this.watchers.add(entry);
+		return { unsubscribe: () => {
+			this.watchers.delete(entry);
+		} };
+	}
+	emit(event) {
+		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/internal/logging.ts
@@ -1370,23 +1180,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) {
@@ -1433,38 +1238,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);
@@ -1516,37 +1310,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);
@@ -1659,6 +1438,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(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(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 {
@@ -2456,13 +2405,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;
@@ -2479,15 +2426,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();
@@ -2698,8 +2641,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()
 	};
 }
 
@@ -2735,8 +2677,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,
@@ -2825,7 +2766,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",