loro-repo 0.4.0 → 0.5.1

package/dist/index.js

@@ -1,1325 +1,53 @@
 import { Flock } from "@loro-dev/flock";
-import { LoroAdaptor } from "loro-adaptors/loro";
-import { CrdtType, bytesToHex } from "loro-protocol";
-import { LoroWebsocketClient } from "loro-websocket";
 import { LoroDoc } from "loro-crdt";
-import { FlockAdaptor } from "loro-adaptors/flock";
-import { promises } from "node:fs";
-import * as path from "node:path";
-import { randomUUID } from "node:crypto";
 
-//#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);
-	};
-};
-
-//#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.
-*/
-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) {
-		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 };
-		}
-	}
-	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)
-		});
-		const ensure = this.ensureMetadataSession(flock, {
-			roomId,
-			auth
-		});
-		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("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(() => {});
-					}
-				});
-			},
-			firstSyncedWithRemote: firstSynced,
-			get connected() {
-				return getConnected();
-			}
-		};
-		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", {
-			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 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
-		};
-		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);
-		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
-		});
-	}
-};
-
-//#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);
-	} catch {
-		return docId.replace(/[^a-z0-9_-]/gi, "_");
-	}
-}
-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();
-	constructor(options = {}) {
-		ensureBroadcastChannel();
-		this.namespace = options.namespace ?? "loro-repo";
-		this.metaChannelName = options.metaChannelName ?? `${this.namespace}-meta`;
-	}
-	async connect() {
-		this.connected = true;
-	}
-	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;
-		}
-		for (const [docId] of this.docStates) this.teardownDocChannel(docId);
-		this.docStates.clear();
-	}
-	isConnected() {
-		return this.connected;
-	}
-	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 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
-			});
-		});
-		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;
-			}
-		};
-	}
-	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,
-			from: this.instanceId
-		});
-		postChannelMessage(state.channel, {
-			kind: "doc-update",
-			docId,
-			from: this.instanceId,
-			mode: "snapshot",
-			payload: doc.export({ mode: "snapshot" })
-		});
-		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;
-	}
-	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;
-	}
-	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/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 ? 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 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 [];
-		const list = Array.isArray(value) ? value : typeof value === "object" && value !== null ? value.updates : void 0;
-		if (!Array.isArray(list)) return [];
-		const queue = [];
-		for (const entry of list) {
-			const bytes = await this.normalizeBinary(entry);
-			if (bytes) queue.push(bytes);
-		}
-		return queue;
-	}
-	async putBinary(db, storeName, key, value) {
-		await this.runInTransaction(db, storeName, "readwrite", (store) => this.wrapRequest(store.put(value, key), "write"));
-	}
-	async deleteKey(db, storeName, key) {
-		await this.runInTransaction(db, storeName, "readwrite", (store) => this.wrapRequest(store.delete(key), "delete"));
-	}
-	async getBinary(storeName, key) {
-		const db = await this.ensureDb();
-		return this.getBinaryFromDb(db, storeName, key);
-	}
-	runInTransaction(db, storeName, mode, executor) {
-		const tx = db.transaction(storeName, mode);
-		const store = tx.objectStore(storeName);
-		const completion = new Promise((resolve, reject) => {
-			tx.addEventListener("complete", () => resolve(), { once: true });
-			tx.addEventListener("abort", () => reject(this.createError("IndexedDB transaction aborted", tx.error)), { once: true });
-			tx.addEventListener("error", () => reject(this.createError("IndexedDB transaction failed", tx.error)), { once: true });
-		});
-		return Promise.all([executor(store), completion]).then(([result]) => result);
-	}
-	wrapRequest(request, action) {
-		return new Promise((resolve, reject) => {
-			request.addEventListener("success", () => resolve(request.result), { once: true });
-			request.addEventListener("error", () => reject(this.createError(`IndexedDB request failed during ${action}`, request.error)), { once: true });
-		});
-	}
-	async normalizeBinary(value) {
-		if (value == null) return void 0;
-		if (value instanceof Uint8Array) return value.slice();
-		if (ArrayBuffer.isView(value)) return new Uint8Array(value.buffer, value.byteOffset, value.byteLength).slice();
-		if (value instanceof ArrayBuffer) return new Uint8Array(value.slice(0));
-		if (typeof value === "object" && value !== null && "arrayBuffer" in value) {
-			const candidate = value;
-			if (typeof candidate.arrayBuffer === "function") {
-				const buffer = await candidate.arrayBuffer();
-				return new Uint8Array(buffer);
-			}
-		}
-	}
-	createError(message, cause) {
-		if (cause instanceof Error) return new Error(`${message}: ${cause.message}`, { cause });
-		if (cause !== void 0 && cause !== null) return /* @__PURE__ */ new Error(`${message}: ${describeUnknown(cause)}`);
-		return new Error(message);
-	}
-};
-
-//#endregion
-//#region src/storage/filesystem.ts
-const textDecoder = new TextDecoder();
-var FileSystemStorageAdaptor = class {
-	baseDir;
-	docsDir;
-	assetsDir;
-	metaPath;
-	initPromise;
-	updateCounter = 0;
-	constructor(options = {}) {
-		this.baseDir = path.resolve(options.baseDir ?? path.join(process.cwd(), ".loro-repo"));
-		this.docsDir = path.join(this.baseDir, options.docsDirName ?? "docs");
-		this.assetsDir = path.join(this.baseDir, options.assetsDirName ?? "assets");
-		this.metaPath = path.join(this.baseDir, options.metaFileName ?? "meta.json");
-		this.initPromise = this.ensureLayout();
-	}
-	async save(payload) {
-		await this.initPromise;
-		switch (payload.type) {
-			case "doc-snapshot":
-				await this.writeDocSnapshot(payload.docId, payload.snapshot);
-				return;
-			case "doc-update":
-				await this.enqueueDocUpdate(payload.docId, payload.update);
-				return;
-			case "asset":
-				await this.writeAsset(payload.assetId, payload.data);
-				return;
-			case "meta":
-				await writeFileAtomic(this.metaPath, payload.update);
-				return;
-			default: throw new Error(`Unsupported payload type: ${payload.type}`);
-		}
-	}
-	async deleteAsset(assetId) {
-		await this.initPromise;
-		await removeIfExists(this.assetPath(assetId));
-	}
-	async loadDoc(docId) {
-		await this.initPromise;
-		const snapshotBytes = await readFileIfExists(this.docSnapshotPath(docId));
-		const updateDir = this.docUpdatesDir(docId);
-		const updateFiles = await listFiles(updateDir);
-		if (!snapshotBytes && updateFiles.length === 0) return;
-		const doc = snapshotBytes ? LoroDoc.fromSnapshot(snapshotBytes) : new LoroDoc();
-		if (updateFiles.length === 0) return doc;
-		const updatePaths = updateFiles.map((file) => path.join(updateDir, file));
-		for (const updatePath of updatePaths) {
-			const update = await readFileIfExists(updatePath);
-			if (!update) continue;
-			doc.import(update);
-		}
-		await Promise.all(updatePaths.map((filePath) => removeIfExists(filePath)));
-		const consolidated = doc.export({ mode: "snapshot" });
-		await this.writeDocSnapshot(docId, consolidated);
-		return doc;
-	}
-	async loadMeta() {
-		await this.initPromise;
-		const bytes = await readFileIfExists(this.metaPath);
-		if (!bytes) return void 0;
-		try {
-			const bundle = JSON.parse(textDecoder.decode(bytes));
-			const flock = new Flock();
-			flock.importJson(bundle);
-			return flock;
-		} catch (error) {
-			throw new Error("Failed to hydrate metadata snapshot", { cause: error });
-		}
-	}
-	async loadAsset(assetId) {
-		await this.initPromise;
-		return readFileIfExists(this.assetPath(assetId));
-	}
-	async ensureLayout() {
-		await Promise.all([
-			ensureDir(this.baseDir),
-			ensureDir(this.docsDir),
-			ensureDir(this.assetsDir)
-		]);
-	}
-	async writeDocSnapshot(docId, snapshot) {
-		await ensureDir(this.docDir(docId));
-		await writeFileAtomic(this.docSnapshotPath(docId), snapshot);
-	}
-	async enqueueDocUpdate(docId, update) {
-		const dir = this.docUpdatesDir(docId);
-		await ensureDir(dir);
-		const counter = this.updateCounter = (this.updateCounter + 1) % 1e6;
-		const fileName = `${Date.now().toString().padStart(13, "0")}-${counter.toString().padStart(6, "0")}.bin`;
-		await writeFileAtomic(path.join(dir, fileName), update);
-	}
-	async writeAsset(assetId, data) {
-		const filePath = this.assetPath(assetId);
-		await ensureDir(path.dirname(filePath));
-		await writeFileAtomic(filePath, data);
-	}
-	docDir(docId) {
-		return path.join(this.docsDir, encodeComponent(docId));
-	}
-	docSnapshotPath(docId) {
-		return path.join(this.docDir(docId), "snapshot.bin");
-	}
-	docUpdatesDir(docId) {
-		return path.join(this.docDir(docId), "updates");
-	}
-	assetPath(assetId) {
-		return path.join(this.assetsDir, encodeComponent(assetId));
-	}
-};
-function encodeComponent(value) {
-	return Buffer.from(value, "utf8").toString("base64url");
-}
-async function ensureDir(dir) {
-	await promises.mkdir(dir, { recursive: true });
-}
-async function readFileIfExists(filePath) {
-	try {
-		const data = await promises.readFile(filePath);
-		return new Uint8Array(data.buffer, data.byteOffset, data.byteLength).slice();
-	} catch (error) {
-		if (error.code === "ENOENT") return;
-		throw error;
-	}
-}
-async function removeIfExists(filePath) {
-	try {
-		await promises.rm(filePath);
-	} 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/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/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;
-}
+//#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
@@ -1338,23 +66,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) {
@@ -1401,38 +124,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);
@@ -1468,12 +180,12 @@ var DocManager = class {
 		this.docPersistedVersions.delete(docId);
 	}
 	async flush() {
-		const promises$1 = [];
-		for (const [docId, doc] of this.docs) promises$1.push((async () => {
+		const promises = [];
+		for (const [docId, doc] of this.docs) promises.push((async () => {
 			await this.persistDocUpdate(docId, doc);
 			await this.flushScheduledDocFrontierUpdate(docId);
 		})());
-		await Promise.all(promises$1);
+		await Promise.all(promises);
 	}
 	async close() {
 		await this.flush();
@@ -1484,37 +196,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);
@@ -1627,6 +324,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 {
@@ -2424,13 +1291,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;
@@ -2447,15 +1312,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();
@@ -2666,8 +1527,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()
 	};
 }
 
@@ -2703,8 +1563,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,
@@ -2793,7 +1652,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",
@@ -2887,5 +1746,5 @@ var LoroRepo = class LoroRepo {
 };
 
 //#endregion
-export { BroadcastChannelTransportAdapter, FileSystemStorageAdaptor, IndexedDBStorageAdaptor, LoroRepo, WebSocketTransportAdapter };
+export { LoroRepo };
 //# sourceMappingURL=index.js.map