loro-repo 0.0.0

package/dist/index.cjs

@@ -0,0 +1,2173 @@
+let __loro_dev_flock = require("@loro-dev/flock");
+let loro_crdt = require("loro-crdt");
+let loro_adaptors = require("loro-adaptors");
+let loro_protocol = require("loro-protocol");
+let loro_websocket = require("loro-websocket");
+
+//#region src/loro-adaptor.ts
+function createRepoFlockAdaptorFromDoc(flock, config = {}) {
+	return new loro_adaptors.FlockAdaptor(flock, config);
+}
+
+//#endregion
+//#region src/transport/websocket.ts
+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);
+	} 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();
+		await client.connect();
+		await client.waitConnected();
+	}
+	async close() {
+		for (const [docId] of this.docSessions) await this.leaveDocSession(docId).catch(() => {});
+		this.docSessions.clear();
+		await this.teardownMetadataSession().catch(() => {});
+		if (this.client) {
+			this.client.destroy();
+			this.client = void 0;
+		}
+	}
+	isConnected() {
+		return this.client?.getStatus() === "connected";
+	}
+	async syncMeta(flock, options) {
+		if (!this.options.metadataRoomId) return { ok: true };
+		try {
+			await withTimeout((await this.ensureMetadataSession(flock, {
+				roomId: this.options.metadataRoomId,
+				auth: this.options.metadataAuth
+			})).firstSynced, options?.timeout);
+			return { ok: true };
+		} catch {
+			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;
+		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);
+					if (session.refCount === 0) this.teardownMetadataSession(session).catch(() => {});
+				});
+			},
+			firstSyncedWithRemote: firstSynced,
+			get connected() {
+				return getConnected();
+			}
+		};
+		ensure.then((session) => {
+			session.refCount += 1;
+		});
+		return subscription;
+	}
+	async syncDoc(docId, doc, options) {
+		try {
+			await withTimeout((await this.ensureDocSession(docId, doc, {})).firstSynced, options?.timeout);
+			return { ok: true };
+		} catch {
+			return { ok: false };
+		}
+	}
+	joinDocRoom(docId, doc, params) {
+		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);
+					if (session.refCount === 0) this.leaveDocSession(docId).catch(() => {});
+				});
+			},
+			firstSyncedWithRemote: firstSynced,
+			get connected() {
+				return getConnected();
+			}
+		};
+		ensure.then((session) => {
+			session.refCount += 1;
+		});
+		return subscription;
+	}
+	ensureClient() {
+		if (this.client) return this.client;
+		const { url, client: clientOptions } = this.options;
+		const client = new loro_websocket.LoroWebsocketClient({
+			url,
+			...clientOptions
+		});
+		this.client = client;
+		return client;
+	}
+	async ensureMetadataSession(flock, params) {
+		const client = this.ensureClient();
+		await client.waitConnected();
+		if (this.metadataSession && this.metadataSession.flock === flock && this.metadataSession.roomId === params.roomId && bytesEqual(this.metadataSession.auth, params.auth)) return this.metadataSession;
+		if (this.metadataSession) 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 ?? {});
+		const room = await client.join({
+			roomId: params.roomId,
+			crdtAdaptor: adaptor,
+			auth: params.auth
+		});
+		const session = {
+			adaptor,
+			room,
+			firstSynced: room.waitForReachingServerVersion(),
+			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;
+		if (this.metadataSession === target) this.metadataSession = void 0;
+		const { adaptor, room } = target;
+		try {
+			await room.leave();
+		} catch {
+			await room.destroy().catch(() => {});
+		}
+		adaptor.destroy();
+	}
+	async ensureDocSession(docId, doc, params) {
+		const client = this.ensureClient();
+		await client.waitConnected();
+		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);
+		if (existing && existing.doc === doc && existing.roomId === roomId) return existing;
+		if (existing) await this.leaveDocSession(docId).catch(() => {});
+		const adaptor = (0, loro_adaptors.createLoroAdaptorFromDoc)(doc);
+		const room = await client.join({
+			roomId,
+			crdtAdaptor: adaptor,
+			auth
+		});
+		const session = {
+			adaptor,
+			room,
+			firstSynced: room.waitForReachingServerVersion(),
+			doc,
+			roomId,
+			refCount: 0
+		};
+		this.docSessions.set(docId, session);
+		return session;
+	}
+	async leaveDocSession(docId) {
+		const session = this.docSessions.get(docId);
+		if (!session) return;
+		this.docSessions.delete(docId);
+		try {
+			await session.room.leave();
+		} catch {
+			await session.room.destroy().catch(() => {});
+		}
+		session.adaptor.destroy();
+	}
+};
+
+//#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 = 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.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 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/index.ts
+const textEncoder = new TextEncoder();
+const DEFAULT_DOC_FRONTIER_DEBOUNCE_MS = 1e3;
+function logAsyncError(context) {
+	return (error) => {
+		if (error instanceof Error) console.error(`[loro-repo] ${context} failed: ${error.message}`, error);
+		else console.error(`[loro-repo] ${context} failed with non-error reason:`, error);
+	};
+}
+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 typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (!isJsonObjectValue(value)) return JSON.stringify(value);
+	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 = new Set([...Object.keys(next), ...previous ? Object.keys(previous) : []]);
+	for (const key of keys) {
+		const prevValue = previous ? previous[key] : void 0;
+		if (!Object.prototype.hasOwnProperty.call(next, key)) {
+			patch[key] = null;
+			continue;
+		}
+		const nextValue = next[key];
+		if (!jsonEquals(prevValue, nextValue)) {
+			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 computeVersionVector(doc) {
+	const candidate = doc;
+	if (typeof candidate.frontiers === "function" && typeof candidate.frontiersToVV === "function") {
+		const frontiers = candidate.frontiers();
+		return candidate.frontiersToVV(frontiers);
+	}
+	if (typeof candidate.version === "function") return candidate.version();
+	return {};
+}
+function emptyFrontiers() {
+	return [];
+}
+function getDocFrontiers(doc) {
+	const candidate = doc;
+	if (typeof candidate.frontiers === "function") {
+		const result = candidate.frontiers();
+		if (result) return result;
+	}
+	return emptyFrontiers();
+}
+function versionVectorToJson(vv) {
+	const map = vv.toJSON();
+	const record = {};
+	if (map instanceof Map) {
+		const entries = Array.from(map.entries()).sort(([a], [b]) => String(a).localeCompare(String(b)));
+		for (const [peer, counter] of entries) {
+			if (typeof counter !== "number" || !Number.isFinite(counter)) continue;
+			const key = typeof peer === "string" ? peer : JSON.stringify(peer);
+			record[key] = counter;
+		}
+	}
+	return record;
+}
+function canonicalizeVersionVector(vv) {
+	const json = versionVectorToJson(vv);
+	return {
+		json,
+		key: stableStringify(json)
+	};
+}
+var RepoDocHandleImpl = class {
+	doc;
+	whenSyncedWithRemote;
+	docId;
+	onClose;
+	constructor(docId, doc, whenSyncedWithRemote, onClose) {
+		this.docId = docId;
+		this.doc = doc;
+		this.whenSyncedWithRemote = whenSyncedWithRemote;
+		this.onClose = onClose;
+	}
+	async close() {
+		await this.onClose(this.docId, this.doc);
+	}
+};
+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;
+}
+var LoroRepo = class {
+	options;
+	transport;
+	storage;
+	assetTransport;
+	docFactory;
+	metaFlock = new __loro_dev_flock.Flock();
+	metadata = /* @__PURE__ */ new Map();
+	docs = /* @__PURE__ */ new Map();
+	docRefs = /* @__PURE__ */ new Map();
+	docSubscriptions = /* @__PURE__ */ new Map();
+	docAssets = /* @__PURE__ */ new Map();
+	assets = /* @__PURE__ */ new Map();
+	orphanedAssets = /* @__PURE__ */ new Map();
+	assetToDocRefs = /* @__PURE__ */ new Map();
+	docFrontierKeys = /* @__PURE__ */ new Map();
+	docFrontierUpdates = /* @__PURE__ */ new Map();
+	docPersistedVersions = /* @__PURE__ */ new Map();
+	docFrontierDebounceMs;
+	watchers = /* @__PURE__ */ new Set();
+	eventByStack = [];
+	metaRoomSubscription;
+	unsubscribeMetaFlock;
+	readyPromise;
+	constructor(options) {
+		this.options = options;
+		this.transport = options.transportAdapter;
+		this.storage = options.storageAdapter;
+		this.assetTransport = options.assetTransportAdapter;
+		this.docFactory = options.docFactory ?? (async () => new loro_crdt.LoroDoc());
+		const configuredDebounce = options.docFrontierDebounceMs;
+		this.docFrontierDebounceMs = typeof configuredDebounce === "number" && Number.isFinite(configuredDebounce) && configuredDebounce >= 0 ? configuredDebounce : DEFAULT_DOC_FRONTIER_DEBOUNCE_MS;
+	}
+	async ready() {
+		if (!this.readyPromise) this.readyPromise = this.initialize();
+		await this.readyPromise;
+	}
+	async initialize() {
+		if (this.storage) {
+			const snapshot = await this.storage.loadMeta();
+			if (snapshot) this.metaFlock = snapshot;
+		}
+		this.hydrateMetadataFromFlock("sync");
+	}
+	async sync(options = {}) {
+		await this.ready();
+		const { scope = "full", docIds } = options;
+		if (!this.transport) return;
+		if (!this.transport.isConnected()) await this.transport.connect();
+		if (scope === "meta" || scope === "full") {
+			this.pushEventBy("sync");
+			const recordedEvents = [];
+			const unsubscribe = this.metaFlock.subscribe((batch) => {
+				if (batch.source === "local") return;
+				recordedEvents.push(...batch.events);
+			});
+			try {
+				if (!(await this.transport.syncMeta(this.metaFlock)).ok) throw new Error("Metadata sync failed");
+				if (recordedEvents.length > 0) this.applyMetaFlockEvents(recordedEvents, "sync");
+				else this.hydrateMetadataFromFlock("sync");
+				await this.persistMeta();
+			} finally {
+				unsubscribe();
+				this.popEventBy();
+			}
+		}
+		if (scope === "doc" || scope === "full") {
+			const targets = docIds ?? Array.from(this.metadata.keys());
+			for (const docId of targets) {
+				const doc = await this.ensureDoc(docId);
+				this.pushEventBy("sync");
+				try {
+					if (!(await this.transport.syncDoc(docId, doc)).ok) throw new Error(`Document sync failed for ${docId}`);
+				} finally {
+					this.popEventBy();
+				}
+				await this.persistDoc(docId, doc);
+				await this.updateDocFrontiers(docId, doc, "sync");
+			}
+		}
+	}
+	refreshDocMetadataEntry(docId, by) {
+		const previous = this.metadata.get(docId);
+		const next = this.readDocMetadataFromFlock(docId);
+		if (!next) {
+			if (previous) {
+				this.metadata.delete(docId);
+				this.emit({
+					kind: "doc-metadata",
+					docId,
+					patch: {},
+					by
+				});
+			}
+			return;
+		}
+		this.metadata.set(docId, next);
+		const patch = diffJsonObjects(previous, next);
+		if (!previous || Object.keys(patch).length > 0) this.emit({
+			kind: "doc-metadata",
+			docId,
+			patch,
+			by
+		});
+	}
+	refreshDocAssetsEntry(docId, by) {
+		const mapping = this.readDocAssetsFromFlock(docId);
+		const previous = this.docAssets.get(docId);
+		if (!mapping.size) {
+			if (previous?.size) {
+				this.docAssets.delete(docId);
+				for (const assetId of previous.keys()) {
+					this.emit({
+						kind: "asset-unlink",
+						docId,
+						assetId,
+						by
+					});
+					if (!Array.from(this.docAssets.values()).some((assets) => assets.has(assetId))) {
+						const record = this.assets.get(assetId);
+						if (record) {
+							const deletedAt = this.orphanedAssets.get(assetId)?.deletedAt ?? Date.now();
+							this.orphanedAssets.set(assetId, {
+								metadata: record.metadata,
+								deletedAt
+							});
+						}
+					}
+				}
+			}
+			return;
+		}
+		this.docAssets.set(docId, mapping);
+		const added = [];
+		const removed = [];
+		if (previous) {
+			for (const assetId of previous.keys()) if (!mapping.has(assetId)) removed.push(assetId);
+		}
+		for (const assetId of mapping.keys()) if (!previous || !previous.has(assetId)) added.push(assetId);
+		for (const assetId of removed) {
+			this.emit({
+				kind: "asset-unlink",
+				docId,
+				assetId,
+				by
+			});
+			if (!Array.from(this.docAssets.values()).some((assets) => assets.has(assetId))) {
+				const record = this.assets.get(assetId);
+				if (record) {
+					const deletedAt = this.orphanedAssets.get(assetId)?.deletedAt ?? Date.now();
+					this.orphanedAssets.set(assetId, {
+						metadata: record.metadata,
+						deletedAt
+					});
+				}
+			}
+		}
+		for (const assetId of added) this.emit({
+			kind: "asset-link",
+			docId,
+			assetId,
+			by
+		});
+	}
+	refreshAssetMetadataEntry(assetId, by) {
+		const previous = this.assets.get(assetId);
+		const metadata = assetMetaFromJson(this.metaFlock.get(["a", assetId]));
+		if (!metadata) {
+			this.handleAssetRemoval(assetId, by);
+			return;
+		}
+		const existingData = previous?.data;
+		this.rememberAsset(metadata, existingData);
+		for (const assets of this.docAssets.values()) if (assets.has(assetId)) assets.set(assetId, cloneRepoAssetMetadata(metadata));
+		if (!previous || !assetMetadataEqual(previous.metadata, metadata)) this.emit({
+			kind: "asset-metadata",
+			asset: this.createAssetDownload(assetId, metadata, existingData),
+			by
+		});
+	}
+	refreshDocFrontierKeys(docId) {
+		const rows = this.metaFlock.scan({ prefix: ["f", docId] });
+		const keys = /* @__PURE__ */ new Set();
+		for (const row of rows) {
+			if (!Array.isArray(row.key) || row.key.length < 3) continue;
+			const frontierKey = row.key[2];
+			if (typeof frontierKey === "string") keys.add(frontierKey);
+		}
+		if (keys.size > 0) this.docFrontierKeys.set(docId, keys);
+		else this.docFrontierKeys.delete(docId);
+	}
+	readDocMetadataFromFlock(docId) {
+		const rows = this.metaFlock.scan({ prefix: ["m", docId] });
+		if (!rows.length) return void 0;
+		const docMeta = {};
+		let populated = false;
+		for (const row of rows) {
+			if (!Array.isArray(row.key) || row.key.length < 2) continue;
+			if (row.key.length === 2) {
+				const obj = asJsonObject(row.value);
+				if (!obj) continue;
+				for (const [field, value] of Object.entries(obj)) {
+					const cloned = cloneJsonValue(value);
+					if (cloned !== void 0) {
+						docMeta[field] = cloned;
+						populated = true;
+					}
+				}
+				continue;
+			}
+			const fieldKey = row.key[2];
+			if (typeof fieldKey !== "string") continue;
+			if (fieldKey === "$tombstone") {
+				docMeta.tombstone = Boolean(row.value);
+				populated = true;
+				continue;
+			}
+			const jsonValue = cloneJsonValue(row.value);
+			if (jsonValue === void 0) continue;
+			docMeta[fieldKey] = jsonValue;
+			populated = true;
+		}
+		return populated ? docMeta : void 0;
+	}
+	readDocAssetsFromFlock(docId) {
+		const rows = this.metaFlock.scan({ prefix: ["ld", docId] });
+		const mapping = /* @__PURE__ */ new Map();
+		for (const row of rows) {
+			if (!Array.isArray(row.key) || row.key.length < 3) continue;
+			const assetId = row.key[2];
+			if (typeof assetId !== "string") continue;
+			if (!(row.value !== void 0 && row.value !== null && row.value !== false)) continue;
+			let metadata = this.assets.get(assetId)?.metadata;
+			if (!metadata) {
+				metadata = this.readAssetMetadataFromFlock(assetId);
+				if (!metadata) continue;
+				this.rememberAsset(metadata);
+			}
+			mapping.set(assetId, cloneRepoAssetMetadata(metadata));
+		}
+		return mapping;
+	}
+	readAssetMetadataFromFlock(assetId) {
+		return assetMetaFromJson(this.metaFlock.get(["a", assetId]));
+	}
+	handleAssetRemoval(assetId, by) {
+		const record = this.assets.get(assetId);
+		if (!record) return;
+		this.assets.delete(assetId);
+		const deletedAt = this.orphanedAssets.get(assetId)?.deletedAt ?? Date.now();
+		this.orphanedAssets.set(assetId, {
+			metadata: record.metadata,
+			deletedAt
+		});
+		const affectedDocs = [];
+		for (const [docId, assets] of this.docAssets) if (assets.delete(assetId)) {
+			if (assets.size === 0) this.docAssets.delete(docId);
+			affectedDocs.push(docId);
+		}
+		for (const docId of affectedDocs) this.emit({
+			kind: "asset-unlink",
+			docId,
+			assetId,
+			by
+		});
+	}
+	emit(event) {
+		for (const entry of this.watchers) if (this.shouldNotify(entry.filter, event)) entry.listener(event);
+	}
+	async joinMetaRoom(params) {
+		await this.ready();
+		if (!this.transport) throw new Error("Transport adapter not configured");
+		if (!this.transport.isConnected()) await this.transport.connect();
+		if (this.metaRoomSubscription) return this.metaRoomSubscription;
+		this.ensureMetaLiveMonitor();
+		const subscription = this.transport.joinMetaRoom(this.metaFlock, params);
+		const wrapped = {
+			unsubscribe: () => {
+				subscription.unsubscribe();
+				if (this.metaRoomSubscription === wrapped) this.metaRoomSubscription = void 0;
+				if (this.unsubscribeMetaFlock) {
+					this.unsubscribeMetaFlock();
+					this.unsubscribeMetaFlock = void 0;
+				}
+			},
+			firstSyncedWithRemote: subscription.firstSyncedWithRemote,
+			get connected() {
+				return subscription.connected;
+			}
+		};
+		this.metaRoomSubscription = wrapped;
+		subscription.firstSyncedWithRemote.then(async () => {
+			const by = this.resolveEventBy("live");
+			this.hydrateMetadataFromFlock(by);
+			await this.persistMeta();
+		}).catch(logAsyncError("meta room first sync"));
+		return wrapped;
+	}
+	async joinDocRoom(docId, params) {
+		await this.ready();
+		if (!this.transport) throw new Error("Transport adapter not configured");
+		if (!this.transport.isConnected()) await this.transport.connect();
+		const doc = await this.ensureDoc(docId);
+		const subscription = this.transport.joinDocRoom(docId, doc, params);
+		subscription.firstSyncedWithRemote.catch(logAsyncError(`doc ${docId} first sync`));
+		return subscription;
+	}
+	async close() {
+		for (const unsubscribe of this.docSubscriptions.values()) try {
+			unsubscribe();
+		} catch {}
+		this.docSubscriptions.clear();
+		this.metaRoomSubscription?.unsubscribe();
+		this.metaRoomSubscription = void 0;
+		if (this.unsubscribeMetaFlock) {
+			this.unsubscribeMetaFlock();
+			this.unsubscribeMetaFlock = void 0;
+		}
+		const pendingDocIds = Array.from(this.docFrontierUpdates.keys());
+		for (const docId of pendingDocIds) try {
+			await this.flushScheduledDocFrontierUpdate(docId);
+		} catch (error) {
+			logAsyncError(`doc ${docId} frontier flush on close`)(error);
+		}
+		this.docFrontierUpdates.clear();
+		this.watchers.clear();
+		this.docs.clear();
+		this.docRefs.clear();
+		this.metadata.clear();
+		this.docAssets.clear();
+		this.assets.clear();
+		this.docFrontierKeys.clear();
+		this.docPersistedVersions.clear();
+		this.readyPromise = void 0;
+		await this.transport?.close();
+	}
+	async upsertDocMeta(docId, patch, _options = {}) {
+		await this.ready();
+		const base = this.metadata.get(docId);
+		const next = base ? cloneJsonObject(base) : {};
+		const outPatch = {};
+		let changed = false;
+		const patchObject = patch;
+		for (const key of Object.keys(patchObject)) {
+			const rawValue = patchObject[key];
+			if (rawValue === void 0) continue;
+			let canonical;
+			if (key === "tombstone") canonical = Boolean(rawValue);
+			else canonical = cloneJsonValue(rawValue);
+			if (canonical === void 0) continue;
+			if (jsonEquals(base ? base[key] : void 0, canonical)) continue;
+			const storageKey = key === "tombstone" ? "$tombstone" : key;
+			this.metaFlock.put([
+				"m",
+				docId,
+				storageKey
+			], canonical);
+			const stored = cloneJsonValue(canonical) ?? canonical;
+			next[key] = stored;
+			outPatch[key] = cloneJsonValue(stored) ?? stored;
+			changed = true;
+		}
+		if (!changed) {
+			if (!this.metadata.has(docId)) this.metadata.set(docId, next);
+			return;
+		}
+		this.metadata.set(docId, next);
+		await this.persistMeta();
+		this.emit({
+			kind: "doc-metadata",
+			docId,
+			patch: cloneJsonObject(outPatch),
+			by: "local"
+		});
+	}
+	async getDocMeta(docId) {
+		await this.ready();
+		const metadata = this.metadata.get(docId);
+		return metadata ? cloneJsonObject(metadata) : void 0;
+	}
+	async listDoc(query) {
+		await this.ready();
+		const entries = [];
+		for (const [docId, metadata] of this.metadata.entries()) {
+			if (!matchesQuery(docId, metadata, query)) continue;
+			entries.push({
+				docId,
+				meta: cloneJsonObject(metadata)
+			});
+		}
+		entries.sort((a, b) => a.docId < b.docId ? -1 : a.docId > b.docId ? 1 : 0);
+		if (query?.limit !== void 0) return entries.slice(0, query.limit);
+		return entries;
+	}
+	getMetaReplica() {
+		return this.metaFlock;
+	}
+	watch(listener, filter = {}) {
+		const entry = {
+			listener,
+			filter
+		};
+		this.watchers.add(entry);
+		return { unsubscribe: () => {
+			this.watchers.delete(entry);
+		} };
+	}
+	/**
+	* Opens the repo-managed collaborative document, registers it for persistence,
+	* and schedules a doc-level sync so `whenSyncedWithRemote` resolves after remote backfills.
+	*/
+	async openCollaborativeDoc(docId) {
+		const doc = await this.ensureDoc(docId);
+		const refs = this.docRefs.get(docId) ?? 0;
+		this.docRefs.set(docId, refs + 1);
+		return new RepoDocHandleImpl(docId, doc, this.whenDocInSyncWithRemote(docId), async (id, instance) => this.onDocHandleClose(id, instance));
+	}
+	/**
+	* Opens a detached `LoroDoc` snapshot that never registers with the repo, meaning
+	* it neither participates in remote subscriptions nor persists edits back to storage.
+	*/
+	async openDetachedDoc(docId) {
+		await this.ready();
+		return new RepoDocHandleImpl(docId, await this.materializeDetachedDoc(docId), Promise.resolve(), async () => {});
+	}
+	async uploadAsset(params) {
+		await this.ready();
+		const bytes = await assetContentToUint8Array(params.content);
+		const assetId = await computeSha256(bytes);
+		if (params.assetId && params.assetId !== assetId) throw new Error("Provided assetId does not match content digest");
+		const existing = this.assets.get(assetId);
+		if (existing) {
+			if (!existing.data) {
+				const clone = bytes.slice();
+				existing.data = clone;
+				if (this.storage) await this.storage.save({
+					type: "asset",
+					assetId,
+					data: clone.slice()
+				});
+			}
+			let metadataMutated = false;
+			const metadata$1 = { ...existing.metadata };
+			if (params.mime && metadata$1.mime !== params.mime) {
+				metadata$1.mime = params.mime;
+				metadataMutated = true;
+			}
+			if (params.policy && metadata$1.policy !== params.policy) {
+				metadata$1.policy = params.policy;
+				metadataMutated = true;
+			}
+			if (params.tag && metadata$1.tag !== params.tag) {
+				metadata$1.tag = params.tag;
+				metadataMutated = true;
+			}
+			if (params.createdAt !== void 0 && metadata$1.createdAt !== params.createdAt) {
+				metadata$1.createdAt = params.createdAt;
+				metadataMutated = true;
+			}
+			if (metadataMutated) {
+				existing.metadata = metadata$1;
+				this.metaFlock.put(["a", assetId], assetMetaToJson(metadata$1));
+				await this.persistMeta();
+				this.emit({
+					kind: "asset-metadata",
+					asset: this.createAssetDownload(assetId, metadata$1, existing.data),
+					by: "local"
+				});
+			}
+			this.rememberAsset(existing.metadata);
+			return assetId;
+		}
+		const metadata = {
+			assetId,
+			size: bytes.byteLength,
+			createdAt: params.createdAt ?? Date.now(),
+			...params.mime ? { mime: params.mime } : {},
+			...params.policy ? { policy: params.policy } : {},
+			...params.tag ? { tag: params.tag } : {}
+		};
+		if (this.assetTransport) {
+			let shouldUpload = true;
+			if (typeof this.assetTransport.ensure === "function") shouldUpload = !await this.assetTransport.ensure(assetId);
+			if (shouldUpload) await this.assetTransport.upload(assetId, bytes, {
+				mime: params.mime,
+				policy: params.policy,
+				tag: params.tag
+			});
+		}
+		const storedBytes = bytes.slice();
+		if (this.storage) await this.storage.save({
+			type: "asset",
+			assetId,
+			data: storedBytes.slice()
+		});
+		this.rememberAsset(metadata, storedBytes);
+		for (const assets of this.docAssets.values()) if (assets.has(assetId)) assets.set(assetId, metadata);
+		this.metaFlock.put(["a", assetId], assetMetaToJson(metadata));
+		await this.persistMeta();
+		this.emit({
+			kind: "asset-metadata",
+			asset: this.createAssetDownload(assetId, metadata, storedBytes),
+			by: "local"
+		});
+		return assetId;
+	}
+	async whenDocInSyncWithRemote(docId) {
+		await this.ready();
+		await this.ensureDoc(docId);
+		await this.sync({
+			scope: "doc",
+			docIds: [docId]
+		});
+	}
+	async linkAsset(docId, params) {
+		await this.ready();
+		const bytes = await assetContentToUint8Array(params.content);
+		const assetId = await computeSha256(bytes);
+		if (params.assetId && params.assetId !== assetId) throw new Error("Provided assetId does not match content digest");
+		let metadata;
+		let storedBytes;
+		let created = false;
+		const existing = this.assets.get(assetId);
+		if (existing) {
+			metadata = existing.metadata;
+			if (!existing.data) {
+				const clone = bytes.slice();
+				existing.data = clone;
+				if (this.storage) await this.storage.save({
+					type: "asset",
+					assetId,
+					data: clone.slice()
+				});
+			}
+			let nextMetadata = metadata;
+			let metadataMutated = false;
+			if (params.mime && params.mime !== nextMetadata.mime) {
+				nextMetadata = {
+					...nextMetadata,
+					mime: params.mime
+				};
+				metadataMutated = true;
+			}
+			if (params.policy && params.policy !== nextMetadata.policy) {
+				nextMetadata = {
+					...nextMetadata,
+					policy: params.policy
+				};
+				metadataMutated = true;
+			}
+			if (params.tag && params.tag !== nextMetadata.tag) {
+				nextMetadata = {
+					...nextMetadata,
+					tag: params.tag
+				};
+				metadataMutated = true;
+			}
+			if (params.createdAt !== void 0 && params.createdAt !== nextMetadata.createdAt) {
+				nextMetadata = {
+					...nextMetadata,
+					createdAt: params.createdAt
+				};
+				metadataMutated = true;
+			}
+			if (metadataMutated) {
+				existing.metadata = nextMetadata;
+				metadata = nextMetadata;
+				this.metaFlock.put(["a", assetId], assetMetaToJson(metadata));
+				await this.persistMeta();
+				this.emit({
+					kind: "asset-metadata",
+					asset: this.createAssetDownload(assetId, metadata, existing.data),
+					by: "local"
+				});
+			} else metadata = existing.metadata;
+			storedBytes = existing.data;
+			this.rememberAsset(metadata);
+		} else {
+			metadata = {
+				assetId,
+				size: bytes.byteLength,
+				createdAt: params.createdAt ?? Date.now(),
+				...params.mime ? { mime: params.mime } : {},
+				...params.policy ? { policy: params.policy } : {},
+				...params.tag ? { tag: params.tag } : {}
+			};
+			if (this.assetTransport) {
+				let shouldUpload = true;
+				if (typeof this.assetTransport.ensure === "function") shouldUpload = !await this.assetTransport.ensure(assetId);
+				if (shouldUpload) await this.assetTransport.upload(assetId, bytes, {
+					mime: params.mime,
+					policy: params.policy,
+					tag: params.tag
+				});
+			}
+			storedBytes = bytes.slice();
+			if (this.storage) await this.storage.save({
+				type: "asset",
+				assetId,
+				data: storedBytes.slice()
+			});
+			this.rememberAsset(metadata, storedBytes);
+			for (const assets of this.docAssets.values()) if (assets.has(assetId)) assets.set(assetId, metadata);
+			this.metaFlock.put(["a", assetId], assetMetaToJson(metadata));
+			created = true;
+		}
+		const mapping = this.docAssets.get(docId) ?? /* @__PURE__ */ new Map();
+		mapping.set(assetId, metadata);
+		this.docAssets.set(docId, mapping);
+		const refs = this.assetToDocRefs.get(assetId) ?? /* @__PURE__ */ new Set();
+		refs.add(docId);
+		this.assetToDocRefs.set(assetId, refs);
+		this.metaFlock.put([
+			"ld",
+			docId,
+			assetId
+		], true);
+		await this.persistMeta();
+		this.emit({
+			kind: "asset-link",
+			docId,
+			assetId,
+			by: "local"
+		});
+		if (created) this.emit({
+			kind: "asset-metadata",
+			asset: this.createAssetDownload(assetId, metadata, storedBytes ?? bytes),
+			by: "local"
+		});
+		return assetId;
+	}
+	async fetchAsset(assetId) {
+		await this.ready();
+		const { metadata, bytes } = await this.materializeAsset(assetId);
+		return this.createAssetDownload(assetId, metadata, bytes);
+	}
+	async unlinkAsset(docId, assetId) {
+		await this.ready();
+		const mapping = this.docAssets.get(docId);
+		if (!mapping || !mapping.has(assetId)) return;
+		mapping.delete(assetId);
+		if (mapping.size === 0) this.docAssets.delete(docId);
+		this.metaFlock.delete([
+			"ld",
+			docId,
+			assetId
+		]);
+		const refs = this.assetToDocRefs.get(assetId);
+		if (refs) {
+			refs.delete(docId);
+			if (refs.size === 0) {
+				this.assetToDocRefs.delete(assetId);
+				const record = this.assets.get(assetId);
+				if (record) this.orphanedAssets.set(assetId, {
+					metadata: record.metadata,
+					deletedAt: Date.now()
+				});
+				this.metaFlock.delete(["a", assetId]);
+				this.assets.delete(assetId);
+			}
+		}
+		await this.persistMeta();
+		this.emit({
+			kind: "asset-unlink",
+			docId,
+			assetId,
+			by: "local"
+		});
+	}
+	async listAssets(docId) {
+		await this.ready();
+		const mapping = this.docAssets.get(docId);
+		if (!mapping) return [];
+		return Array.from(mapping.values()).map((asset) => ({ ...asset }));
+	}
+	async ensureAsset(assetId) {
+		return this.fetchAsset(assetId);
+	}
+	createAssetDownload(assetId, metadata, initialBytes) {
+		let cached = initialBytes ? initialBytes.slice() : void 0;
+		return {
+			assetId,
+			size: metadata.size,
+			createdAt: metadata.createdAt,
+			mime: metadata.mime,
+			policy: metadata.policy,
+			tag: metadata.tag,
+			content: async () => {
+				if (!cached) cached = (await this.materializeAsset(assetId)).bytes.slice();
+				return toReadableStream(cached.slice());
+			}
+		};
+	}
+	async materializeAsset(assetId) {
+		let record = this.assets.get(assetId);
+		if (record?.data) return {
+			metadata: record.metadata,
+			bytes: record.data.slice()
+		};
+		if (record && this.storage) {
+			const stored = await this.storage.loadAsset(assetId);
+			if (stored) {
+				const clone = stored.slice();
+				record.data = clone.slice();
+				return {
+					metadata: record.metadata,
+					bytes: clone
+				};
+			}
+		}
+		if (!record && this.storage) {
+			const stored = await this.storage.loadAsset(assetId);
+			if (stored) {
+				const metadata$1 = this.getAssetMetadata(assetId);
+				if (!metadata$1) throw new Error(`Missing metadata for asset ${assetId}`);
+				const clone = stored.slice();
+				this.assets.set(assetId, {
+					metadata: metadata$1,
+					data: clone.slice()
+				});
+				this.updateDocAssetMetadata(assetId, metadata$1);
+				return {
+					metadata: metadata$1,
+					bytes: clone
+				};
+			}
+		}
+		if (!this.assetTransport) throw new Error(`Asset ${assetId} is not available locally`);
+		const remote = await this.assetTransport.fetch(assetId);
+		if (!remote) throw new Error(`Asset ${assetId} missing from remote store`);
+		const remoteBytes = await streamToUint8Array(await remote.content());
+		const metadata = {
+			assetId,
+			size: remote.size,
+			createdAt: remote.createdAt,
+			...remote.mime ? { mime: remote.mime } : {},
+			...remote.policy ? { policy: remote.policy } : {},
+			...remote.tag ? { tag: remote.tag } : {}
+		};
+		this.assets.set(assetId, {
+			metadata,
+			data: remoteBytes.slice()
+		});
+		this.updateDocAssetMetadata(assetId, metadata);
+		this.metaFlock.put(["a", assetId], assetMetaToJson(metadata));
+		await this.persistMeta();
+		if (this.storage) await this.storage.save({
+			type: "asset",
+			assetId,
+			data: remoteBytes.slice()
+		});
+		return {
+			metadata,
+			bytes: remoteBytes
+		};
+	}
+	updateDocAssetMetadata(assetId, metadata) {
+		for (const assets of this.docAssets.values()) if (assets.has(assetId)) assets.set(assetId, metadata);
+	}
+	async gcAssets(options = {}) {
+		await this.ready();
+		const { minKeepMs = 0 } = options;
+		const now = Date.now();
+		let removed = 0;
+		for (const [assetId, orphan] of Array.from(this.orphanedAssets.entries())) {
+			if (now - orphan.deletedAt < minKeepMs) continue;
+			this.orphanedAssets.delete(assetId);
+			if (this.storage?.deleteAsset) try {
+				await this.storage.deleteAsset(assetId);
+			} catch (error) {
+				logAsyncError(`asset ${assetId} delete`)(error);
+			}
+			removed += 1;
+		}
+		return removed;
+	}
+	async onDocHandleClose(docId, doc) {
+		const refs = this.docRefs.get(docId) ?? 0;
+		if (refs <= 1) this.docRefs.delete(docId);
+		else this.docRefs.set(docId, refs - 1);
+		await this.persistDocUpdate(docId, doc);
+		if (!await this.flushScheduledDocFrontierUpdate(docId)) await this.updateDocFrontiers(docId, doc, "local");
+	}
+	async ensureDoc(docId) {
+		await this.ready();
+		const cached = this.docs.get(docId);
+		if (cached) {
+			this.ensureDocSubscription(docId, cached);
+			if (!this.docPersistedVersions.has(docId)) this.docPersistedVersions.set(docId, cached.version());
+			return cached;
+		}
+		if (this.storage) {
+			const stored = await this.storage.loadDoc(docId);
+			if (stored) {
+				this.registerDoc(docId, stored);
+				return stored;
+			}
+		}
+		const created = await this.docFactory(docId);
+		this.registerDoc(docId, created);
+		return created;
+	}
+	async materializeDetachedDoc(docId) {
+		const doc = await this.docFactory(docId);
+		const snapshot = await this.exportDocSnapshot(docId);
+		if (snapshot) doc.import(snapshot);
+		return doc;
+	}
+	async exportDocSnapshot(docId) {
+		const cached = this.docs.get(docId);
+		if (cached) return cached.export({ mode: "snapshot" });
+		if (!this.storage) return;
+		return (await this.storage.loadDoc(docId))?.export({ mode: "snapshot" });
+	}
+	async persistMeta() {
+		if (!this.storage) return;
+		const bundle = this.metaFlock.exportJson();
+		const encoded = textEncoder.encode(JSON.stringify(bundle));
+		await this.storage.save({
+			type: "meta",
+			update: encoded
+		});
+	}
+	async persistDoc(docId, doc) {
+		const previousVersion = this.docPersistedVersions.get(docId);
+		const nextVersion = doc.version();
+		if (!this.storage) {
+			this.docPersistedVersions.set(docId, nextVersion);
+			return;
+		}
+		const snapshot = doc.export({ mode: "snapshot" });
+		this.docPersistedVersions.set(docId, nextVersion);
+		try {
+			await this.storage.save({
+				type: "doc-snapshot",
+				docId,
+				snapshot
+			});
+		} catch (error) {
+			if (previousVersion) this.docPersistedVersions.set(docId, previousVersion);
+			else this.docPersistedVersions.delete(docId);
+			throw error;
+		}
+	}
+	async persistDocUpdate(docId, doc) {
+		const previousVersion = this.docPersistedVersions.get(docId);
+		const nextVersion = doc.version();
+		if (!this.storage) {
+			this.docPersistedVersions.set(docId, nextVersion);
+			return;
+		}
+		if (!previousVersion) {
+			await this.persistDoc(docId, doc);
+			this.docPersistedVersions.set(docId, nextVersion);
+			return;
+		}
+		const update = doc.export({
+			mode: "update",
+			from: previousVersion
+		});
+		if (!update.length) {
+			this.docPersistedVersions.set(docId, nextVersion);
+			return;
+		}
+		this.docPersistedVersions.set(docId, nextVersion);
+		try {
+			await this.storage.save({
+				type: "doc-update",
+				docId,
+				update
+			});
+		} catch (error) {
+			this.docPersistedVersions.set(docId, previousVersion);
+			throw error;
+		}
+	}
+	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;
+	}
+	ensureMetaLiveMonitor() {
+		if (this.unsubscribeMetaFlock) return;
+		this.unsubscribeMetaFlock = this.metaFlock.subscribe((batch) => {
+			if (batch.source === "local") return;
+			const by = this.resolveEventBy("live");
+			(async () => {
+				this.applyMetaFlockEvents(batch.events, by);
+				await this.persistMeta();
+			})().catch(logAsyncError("meta live monitor sync"));
+		});
+	}
+	applyMetaFlockEvents(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;
+			if (!Array.isArray(key) || key.length === 0) continue;
+			const root = key[0];
+			if (root === "m") {
+				const docId = key[1];
+				if (typeof docId === "string") docMetadataIds.add(docId);
+			} else if (root === "a") {
+				const assetId = key[1];
+				if (typeof assetId === "string") assetIds.add(assetId);
+			} else if (root === "ld") {
+				const docId = key[1];
+				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.refreshAssetMetadataEntry(assetId, by);
+		for (const docId of docMetadataIds) this.refreshDocMetadataEntry(docId, by);
+		for (const docId of docAssetIds) this.refreshDocAssetsEntry(docId, by);
+		for (const docId of docFrontiersIds) this.refreshDocFrontierKeys(docId);
+	}
+	registerDoc(docId, doc) {
+		this.docs.set(docId, doc);
+		this.docPersistedVersions.set(docId, doc.version());
+		this.ensureDocSubscription(docId, doc);
+	}
+	ensureDocSubscription(docId, doc) {
+		if (this.docSubscriptions.has(docId)) return;
+		const unsubscribe = doc.subscribe((batch) => {
+			const stackBy = this.resolveEventBy("local");
+			const by = stackBy === "local" && batch.by === "import" ? "live" : stackBy;
+			this.onDocEvent(docId, doc, batch, by);
+		});
+		if (typeof unsubscribe === "function") this.docSubscriptions.set(docId, unsubscribe);
+	}
+	rememberAsset(metadata, bytes) {
+		const data = bytes ? bytes.slice() : this.assets.get(metadata.assetId)?.data;
+		this.assets.set(metadata.assetId, {
+			metadata,
+			data
+		});
+		this.orphanedAssets.delete(metadata.assetId);
+	}
+	scheduleDocFrontierUpdate(docId, doc, by) {
+		const existing = this.docFrontierUpdates.get(docId);
+		const effectiveBy = existing ? this.mergeRepoEventBy(existing.by, by) : by;
+		if (existing) clearTimeout(existing.timeout);
+		const delay = this.docFrontierDebounceMs > 0 ? this.docFrontierDebounceMs : 0;
+		const timeout = setTimeout(() => this.runScheduledDocFrontierUpdate(docId), delay);
+		this.docFrontierUpdates.set(docId, {
+			timeout,
+			doc,
+			by: effectiveBy
+		});
+	}
+	mergeRepoEventBy(current, next) {
+		if (current === next) return current;
+		if (current === "live" || next === "live") return "live";
+		if (current === "sync" || next === "sync") return "sync";
+		return "local";
+	}
+	runScheduledDocFrontierUpdate(docId) {
+		const pending = this.docFrontierUpdates.get(docId);
+		if (!pending) return;
+		this.docFrontierUpdates.delete(docId);
+		this.pushEventBy(pending.by);
+		(async () => {
+			try {
+				await this.updateDocFrontiers(docId, pending.doc, pending.by);
+			} finally {
+				this.popEventBy();
+			}
+		})().catch(logAsyncError(`doc ${docId} frontier debounce`));
+	}
+	async flushScheduledDocFrontierUpdate(docId) {
+		const pending = this.docFrontierUpdates.get(docId);
+		if (!pending) return false;
+		clearTimeout(pending.timeout);
+		this.docFrontierUpdates.delete(docId);
+		this.pushEventBy(pending.by);
+		try {
+			await this.updateDocFrontiers(docId, pending.doc, pending.by);
+		} finally {
+			this.popEventBy();
+		}
+		return true;
+	}
+	onDocEvent(docId, doc, _batch, by) {
+		(async () => {
+			const a = this.persistDocUpdate(docId, doc);
+			if (by === "local") {
+				this.scheduleDocFrontierUpdate(docId, doc, by);
+				await a;
+				return;
+			}
+			const b = this.flushScheduledDocFrontierUpdate(docId);
+			const c = this.updateDocFrontiers(docId, doc, by);
+			await Promise.all([
+				a,
+				b,
+				c
+			]);
+		})().catch(logAsyncError(`doc ${docId} event processing`));
+	}
+	getAssetMetadata(assetId) {
+		const record = this.assets.get(assetId);
+		if (record) return record.metadata;
+		for (const assets of this.docAssets.values()) {
+			const metadata = assets.get(assetId);
+			if (metadata) return metadata;
+		}
+	}
+	async updateDocFrontiers(docId, doc, defaultBy = "local") {
+		const { json, key } = canonicalizeVersionVector(computeVersionVector(doc));
+		const existingKeys = this.docFrontierKeys.get(docId) ?? /* @__PURE__ */ new Set();
+		let mutated = false;
+		if (existingKeys.size !== 1 || !existingKeys.has(key)) {
+			for (const entry of existingKeys) this.metaFlock.delete([
+				"f",
+				docId,
+				entry
+			]);
+			this.metaFlock.put([
+				"f",
+				docId,
+				key
+			], json);
+			this.docFrontierKeys.set(docId, new Set([key]));
+			mutated = true;
+		}
+		if (mutated) await this.persistMeta();
+		const by = this.resolveEventBy(defaultBy);
+		const frontiers = getDocFrontiers(doc);
+		this.emit({
+			kind: "doc-frontiers",
+			docId,
+			frontiers,
+			by
+		});
+	}
+	hydrateMetadataFromFlock(by) {
+		const prevMetadata = new Map(this.metadata);
+		const prevDocAssets = new Map(this.docAssets);
+		const prevAssets = new Map(this.assets);
+		const nextMetadata = /* @__PURE__ */ new Map();
+		const metadataRows = this.metaFlock.scan({ prefix: ["m"] });
+		for (const row of metadataRows) {
+			if (!Array.isArray(row.key) || row.key.length < 2) continue;
+			const docId = row.key[1];
+			if (typeof docId !== "string") continue;
+			let docMeta = nextMetadata.get(docId);
+			if (!docMeta) {
+				docMeta = {};
+				nextMetadata.set(docId, docMeta);
+			}
+			if (row.key.length === 2) {
+				const obj = asJsonObject(row.value);
+				if (!obj) continue;
+				for (const [field, value] of Object.entries(obj)) {
+					const cloned = cloneJsonValue(value);
+					if (cloned !== void 0) docMeta[field] = cloned;
+				}
+				continue;
+			}
+			const fieldKey = row.key[2];
+			if (typeof fieldKey !== "string") continue;
+			if (fieldKey === "$tombstone") {
+				docMeta.tombstone = Boolean(row.value);
+				continue;
+			}
+			const jsonValue = cloneJsonValue(row.value);
+			if (jsonValue === void 0) continue;
+			docMeta[fieldKey] = jsonValue;
+		}
+		const nextAssets = /* @__PURE__ */ new Map();
+		const assetRows = this.metaFlock.scan({ prefix: ["a"] });
+		for (const row of assetRows) {
+			if (!Array.isArray(row.key) || row.key.length < 2) continue;
+			const assetId = row.key[1];
+			if (typeof assetId !== "string") continue;
+			const metadata = assetMetaFromJson(row.value);
+			if (!metadata) continue;
+			const existing = this.assets.get(assetId);
+			nextAssets.set(assetId, {
+				metadata,
+				data: existing?.data
+			});
+		}
+		const nextDocAssets = /* @__PURE__ */ new Map();
+		const linkRows = this.metaFlock.scan({ prefix: ["ld"] });
+		for (const row of linkRows) {
+			if (!Array.isArray(row.key) || row.key.length < 3) continue;
+			const docId = row.key[1];
+			const assetId = row.key[2];
+			if (typeof docId !== "string" || typeof assetId !== "string") continue;
+			const metadata = nextAssets.get(assetId)?.metadata;
+			if (!metadata) continue;
+			const mapping = nextDocAssets.get(docId) ?? /* @__PURE__ */ new Map();
+			mapping.set(assetId, metadata);
+			nextDocAssets.set(docId, mapping);
+		}
+		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);
+		}
+		const removedAssets = [];
+		for (const [assetId, record] of prevAssets) if (!nextAssets.has(assetId)) removedAssets.push([assetId, record]);
+		if (removedAssets.length > 0) {
+			const now = Date.now();
+			for (const [assetId, record] of removedAssets) {
+				const deletedAt = this.orphanedAssets.get(assetId)?.deletedAt ?? now;
+				this.orphanedAssets.set(assetId, {
+					metadata: record.metadata,
+					deletedAt
+				});
+			}
+		}
+		this.metadata.clear();
+		for (const [docId, meta] of nextMetadata) this.metadata.set(docId, meta);
+		this.docAssets.clear();
+		for (const [docId, assets] of nextDocAssets) this.docAssets.set(docId, assets);
+		this.assetToDocRefs.clear();
+		for (const [docId, assets] of nextDocAssets) for (const assetId of assets.keys()) {
+			const refs = this.assetToDocRefs.get(assetId) ?? /* @__PURE__ */ new Set();
+			refs.add(docId);
+			this.assetToDocRefs.set(assetId, refs);
+		}
+		this.assets.clear();
+		for (const record of nextAssets.values()) this.rememberAsset(record.metadata, record.data);
+		this.docFrontierKeys.clear();
+		for (const [docId, keys] of nextFrontierKeys) this.docFrontierKeys.set(docId, keys);
+		const docIds = new Set([...prevMetadata.keys(), ...nextMetadata.keys()]);
+		for (const docId of docIds) {
+			const previous = prevMetadata.get(docId);
+			const current = nextMetadata.get(docId);
+			if (!current) {
+				if (previous) this.emit({
+					kind: "doc-metadata",
+					docId,
+					patch: {},
+					by
+				});
+				continue;
+			}
+			const patch = diffJsonObjects(previous, current);
+			if (Object.keys(patch).length > 0) this.emit({
+				kind: "doc-metadata",
+				docId,
+				patch,
+				by
+			});
+		}
+		for (const [assetId, record] of nextAssets) {
+			const previous = prevAssets.get(assetId)?.metadata;
+			if (!assetMetadataEqual(previous, record.metadata)) this.emit({
+				kind: "asset-metadata",
+				asset: this.createAssetDownload(assetId, record.metadata, record.data),
+				by
+			});
+		}
+		for (const [docId, assets] of nextDocAssets) {
+			const previous = prevDocAssets.get(docId);
+			for (const assetId of assets.keys()) if (!previous || !previous.has(assetId)) this.emit({
+				kind: "asset-link",
+				docId,
+				assetId,
+				by
+			});
+		}
+		for (const [docId, assets] of prevDocAssets) {
+			const current = nextDocAssets.get(docId);
+			for (const assetId of assets.keys()) if (!current || !current.has(assetId)) this.emit({
+				kind: "asset-unlink",
+				docId,
+				assetId,
+				by
+			});
+		}
+	}
+	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
+exports.BroadcastChannelTransportAdapter = BroadcastChannelTransportAdapter;
+exports.IndexedDBStorageAdaptor = IndexedDBStorageAdaptor;
+exports.LoroRepo = LoroRepo;
+exports.WebSocketTransportAdapter = WebSocketTransportAdapter;
+//# sourceMappingURL=index.cjs.map