loro-repo 0.5.0 → 0.5.2

package/dist/index.js

@@ -1,1088 +1,6 @@
 import { Flock } from "@loro-dev/flock";
 import { LoroDoc } from "loro-crdt";
-import { promises } from "node:fs";
-import * as path from "node:path";
-import { randomUUID } from "node:crypto";
-import { LoroAdaptor } from "loro-adaptors/loro";
-import { bytesToHex } from "loro-protocol";
-import { LoroWebsocketClient } from "loro-websocket";
-import { FlockAdaptor } from "loro-adaptors/flock";
 
-//#region src/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/debug.ts
-const getEnv = () => {
-	if (typeof globalThis !== "object" || globalThis === null) return;
-	return globalThis.process?.env;
-};
-const rawNamespaceConfig = (getEnv()?.LORO_REPO_DEBUG ?? "").trim();
-const normalizedNamespaces = rawNamespaceConfig.length > 0 ? rawNamespaceConfig.split(/[\s,]+/).map((token) => token.toLowerCase()).filter(Boolean) : [];
-const wildcardTokens = new Set([
-	"*",
-	"1",
-	"true",
-	"all"
-]);
-const namespaceSet = new Set(normalizedNamespaces);
-const hasWildcard = namespaceSet.size > 0 && normalizedNamespaces.some((token) => wildcardTokens.has(token));
-const isDebugEnabled = (namespace) => {
-	if (!namespaceSet.size) return false;
-	if (!namespace) return hasWildcard;
-	const normalized = namespace.toLowerCase();
-	if (hasWildcard) return true;
-	if (namespaceSet.has(normalized)) return true;
-	const [root] = normalized.split(":");
-	return namespaceSet.has(root);
-};
-const createDebugLogger = (namespace) => {
-	const normalized = namespace.toLowerCase();
-	return (...args) => {
-		if (!isDebugEnabled(normalized)) return;
-		const prefix = `[loro-repo:${namespace}]`;
-		if (args.length === 0) {
-			console.info(prefix);
-			return;
-		}
-		console.info(prefix, ...args);
-	};
-};
-
-//#endregion
-//#region src/transport/websocket.ts
-const debug = createDebugLogger("transport:websocket");
-function withTimeout(promise, timeoutMs) {
-	if (!timeoutMs || timeoutMs <= 0) return promise;
-	return new Promise((resolve, reject) => {
-		const timer = setTimeout(() => {
-			reject(/* @__PURE__ */ new Error(`Operation timed out after ${timeoutMs}ms`));
-		}, timeoutMs);
-		promise.then((value) => {
-			clearTimeout(timer);
-			resolve(value);
-		}).catch((error) => {
-			clearTimeout(timer);
-			reject(error);
-		});
-	});
-}
-function normalizeRoomId(roomId, fallback) {
-	if (typeof roomId === "string" && roomId.length > 0) return roomId;
-	if (roomId instanceof Uint8Array && roomId.length > 0) try {
-		return bytesToHex(roomId);
-	} catch {
-		return fallback;
-	}
-	return fallback;
-}
-function bytesEqual(a, b) {
-	if (a === b) return true;
-	if (!a || !b) return false;
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
-	return true;
-}
-/**
-* loro-websocket backed {@link TransportAdapter} implementation for LoroRepo. 
-* It uses loro-protocol as the underlying protocol for the transport.
-*/
-var WebSocketTransportAdapter = class {
-	options;
-	client;
-	metadataSession;
-	docSessions = /* @__PURE__ */ new Map();
-	constructor(options) {
-		this.options = options;
-	}
-	async connect(_options) {
-		const client = this.ensureClient();
-		debug("connect requested", { status: client.getStatus() });
-		try {
-			await client.connect();
-			debug("client.connect resolved");
-			await client.waitConnected();
-			debug("client.waitConnected resolved", { status: client.getStatus() });
-		} catch (error) {
-			debug("connect failed", error);
-			throw error;
-		}
-	}
-	async close() {
-		debug("close requested", {
-			docSessions: this.docSessions.size,
-			metadataSession: Boolean(this.metadataSession)
-		});
-		for (const [docId] of this.docSessions) await this.leaveDocSession(docId).catch(() => {});
-		this.docSessions.clear();
-		await this.teardownMetadataSession().catch(() => {});
-		if (this.client) {
-			const client = this.client;
-			this.client = void 0;
-			client.destroy();
-			debug("websocket client destroyed");
-		}
-		debug("close completed");
-	}
-	isConnected() {
-		return this.client?.getStatus() === "connected";
-	}
-	async syncMeta(flock, options) {
-		debug("syncMeta requested", { roomId: this.options.metadataRoomId });
-		try {
-			let auth;
-			if (this.options.metadataAuth) if (typeof this.options.metadataAuth === "function") auth = await this.options.metadataAuth();
-			else auth = this.options.metadataAuth;
-			await withTimeout((await this.ensureMetadataSession(flock, {
-				roomId: this.options.metadataRoomId ?? "repo:meta",
-				auth
-			})).firstSynced, options?.timeout);
-			debug("syncMeta completed", { roomId: this.options.metadataRoomId });
-			return { ok: true };
-		} catch (error) {
-			debug("syncMeta failed", error);
-			return { ok: false };
-		}
-	}
-	joinMetaRoom(flock, params) {
-		const fallback = this.options.metadataRoomId ?? "";
-		const roomId = normalizeRoomId(params?.roomId, fallback);
-		if (!roomId) throw new Error("Metadata room id not configured");
-		const session = (async () => {
-			let auth;
-			const authWay = params?.auth ?? this.options.metadataAuth;
-			if (typeof authWay === "function") auth = await authWay();
-			else auth = authWay;
-			debug("joinMetaRoom requested", {
-				roomId,
-				hasAuth: Boolean(auth && auth.length)
-			});
-			return this.ensureMetadataSession(flock, {
-				roomId,
-				auth
-			});
-		})();
-		const firstSynced = session.then((session$1) => session$1.firstSynced);
-		const getConnected = () => this.isConnected();
-		const subscription = {
-			unsubscribe: () => {
-				session.then((session$1) => {
-					session$1.refCount = Math.max(0, session$1.refCount - 1);
-					debug("metadata session refCount decremented", {
-						roomId: session$1.roomId,
-						refCount: session$1.refCount
-					});
-					if (session$1.refCount === 0) {
-						debug("tearing down metadata session due to refCount=0", { roomId: session$1.roomId });
-						this.teardownMetadataSession(session$1).catch(() => {});
-					}
-				});
-			},
-			firstSyncedWithRemote: firstSynced,
-			get connected() {
-				return getConnected();
-			}
-		};
-		session.then((session$1) => {
-			session$1.refCount += 1;
-			debug("metadata session refCount incremented", {
-				roomId: session$1.roomId,
-				refCount: session$1.refCount
-			});
-		});
-		return subscription;
-	}
-	async syncDoc(docId, doc, options) {
-		debug("syncDoc requested", { docId });
-		try {
-			const session = await this.ensureDocSession(docId, doc, {});
-			await withTimeout(session.firstSynced, options?.timeout);
-			debug("syncDoc completed", {
-				docId,
-				roomId: session.roomId
-			});
-			return { ok: true };
-		} catch (error) {
-			debug("syncDoc failed", {
-				docId,
-				error
-			});
-			return { ok: false };
-		}
-	}
-	joinDocRoom(docId, doc, params) {
-		debug("joinDocRoom requested", {
-			docId,
-			roomParamType: params?.roomId ? typeof params.roomId === "string" ? "string" : "uint8array" : void 0,
-			hasAuthOverride: Boolean(params?.auth && params.auth.length)
-		});
-		const ensure = this.ensureDocSession(docId, doc, params ?? {});
-		const firstSynced = ensure.then((session) => session.firstSynced);
-		const getConnected = () => this.isConnected();
-		const subscription = {
-			unsubscribe: () => {
-				ensure.then((session) => {
-					session.refCount = Math.max(0, session.refCount - 1);
-					debug("doc session refCount decremented", {
-						docId,
-						roomId: session.roomId,
-						refCount: session.refCount
-					});
-					if (session.refCount === 0) this.leaveDocSession(docId).catch(() => {});
-				});
-			},
-			firstSyncedWithRemote: firstSynced,
-			get connected() {
-				return getConnected();
-			}
-		};
-		ensure.then((session) => {
-			session.refCount += 1;
-			debug("doc session refCount incremented", {
-				docId,
-				roomId: session.roomId,
-				refCount: session.refCount
-			});
-		});
-		return subscription;
-	}
-	ensureClient() {
-		if (this.client) {
-			debug("reusing websocket client", { status: this.client.getStatus() });
-			return this.client;
-		}
-		const { url, client: clientOptions } = this.options;
-		debug("creating websocket client", {
-			url,
-			clientOptionsKeys: clientOptions ? Object.keys(clientOptions) : []
-		});
-		const client = new LoroWebsocketClient({
-			url,
-			...clientOptions
-		});
-		this.client = client;
-		return client;
-	}
-	async ensureMetadataSession(flock, params) {
-		debug("ensureMetadataSession invoked", {
-			roomId: params.roomId,
-			hasAuth: Boolean(params.auth && params.auth.length)
-		});
-		const client = this.ensureClient();
-		await client.waitConnected();
-		debug("websocket client ready for metadata session", { status: client.getStatus() });
-		if (this.metadataSession && this.metadataSession.flock === flock && this.metadataSession.roomId === params.roomId && bytesEqual(this.metadataSession.auth, params.auth)) {
-			debug("reusing metadata session", {
-				roomId: this.metadataSession.roomId,
-				refCount: this.metadataSession.refCount
-			});
-			return this.metadataSession;
-		}
-		if (this.metadataSession) {
-			debug("tearing down previous metadata session", { roomId: this.metadataSession.roomId });
-			await this.teardownMetadataSession(this.metadataSession).catch(() => {});
-		}
-		const adaptor = new FlockAdaptor(flock, this.options.metadataAdaptorConfig);
-		debug("joining metadata room", {
-			roomId: params.roomId,
-			hasAuth: Boolean(params.auth && params.auth.length)
-		});
-		const room = await client.join({
-			roomId: params.roomId,
-			crdtAdaptor: adaptor,
-			auth: params.auth
-		});
-		const firstSynced = room.waitForReachingServerVersion();
-		firstSynced.then(() => {
-			debug("metadata session firstSynced resolved", { roomId: params.roomId });
-		}, (error) => {
-			debug("metadata session firstSynced rejected", {
-				roomId: params.roomId,
-				error
-			});
-		});
-		const session = {
-			adaptor,
-			room,
-			firstSynced,
-			flock,
-			roomId: params.roomId,
-			auth: params.auth,
-			refCount: 0
-		};
-		this.metadataSession = session;
-		return session;
-	}
-	async teardownMetadataSession(session) {
-		const target = session ?? this.metadataSession;
-		if (!target) return;
-		debug("teardownMetadataSession invoked", { roomId: target.roomId });
-		if (this.metadataSession === target) this.metadataSession = void 0;
-		const { adaptor, room } = target;
-		try {
-			await room.leave();
-			debug("metadata room left", { roomId: target.roomId });
-		} catch (error) {
-			debug("metadata room leave failed; destroying", {
-				roomId: target.roomId,
-				error
-			});
-			await room.destroy().catch(() => {});
-		}
-		adaptor.destroy();
-		debug("metadata session destroyed", { roomId: target.roomId });
-	}
-	async ensureDocSession(docId, doc, params) {
-		debug("ensureDocSession invoked", { docId });
-		const client = this.ensureClient();
-		await client.waitConnected();
-		debug("websocket client ready for doc session", {
-			docId,
-			status: client.getStatus()
-		});
-		const existing = this.docSessions.get(docId);
-		const derivedRoomId = this.options.docRoomId?.(docId) ?? docId;
-		const roomId = normalizeRoomId(params.roomId, derivedRoomId);
-		let auth;
-		auth = await (params.auth ?? this.options.docAuth?.(docId));
-		debug("doc session params resolved", {
-			docId,
-			roomId,
-			hasAuth: Boolean(auth && auth.length)
-		});
-		if (existing && existing.doc === doc && existing.roomId === roomId) {
-			debug("reusing doc session", {
-				docId,
-				roomId,
-				refCount: existing.refCount
-			});
-			return existing;
-		}
-		if (existing) {
-			debug("doc session mismatch; leaving existing session", {
-				docId,
-				previousRoomId: existing.roomId,
-				nextRoomId: roomId
-			});
-			await this.leaveDocSession(docId).catch(() => {});
-		}
-		const adaptor = new LoroAdaptor(doc);
-		debug("joining doc room", {
-			docId,
-			roomId,
-			hasAuth: Boolean(auth && auth.length)
-		});
-		const room = await client.join({
-			roomId,
-			crdtAdaptor: adaptor,
-			auth
-		});
-		const firstSynced = room.waitForReachingServerVersion();
-		firstSynced.then(() => {
-			debug("doc session firstSynced resolved", {
-				docId,
-				roomId
-			});
-		}, (error) => {
-			debug("doc session firstSynced rejected", {
-				docId,
-				roomId,
-				error
-			});
-		});
-		const session = {
-			adaptor,
-			room,
-			firstSynced,
-			doc,
-			roomId,
-			refCount: 0
-		};
-		this.docSessions.set(docId, session);
-		return session;
-	}
-	async leaveDocSession(docId) {
-		const session = this.docSessions.get(docId);
-		if (!session) {
-			debug("leaveDocSession invoked but no session found", { docId });
-			return;
-		}
-		this.docSessions.delete(docId);
-		debug("leaving doc session", {
-			docId,
-			roomId: session.roomId
-		});
-		try {
-			await session.room.leave();
-			debug("doc room left", {
-				docId,
-				roomId: session.roomId
-			});
-		} catch (error) {
-			debug("doc room leave failed; destroying", {
-				docId,
-				roomId: session.roomId,
-				error
-			});
-			await session.room.destroy().catch(() => {});
-		}
-		session.adaptor.destroy();
-		debug("doc session destroyed", {
-			docId,
-			roomId: session.roomId
-		});
-	}
-};
-
-//#endregion
 //#region src/internal/event-bus.ts
 var RepoEventBus = class {
 	watchers = /* @__PURE__ */ new Set();
@@ -1262,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();
@@ -1435,14 +353,14 @@ async function assetContentToUint8Array(content) {
 	if (typeof ReadableStream !== "undefined" && content instanceof ReadableStream) return streamToUint8Array(content);
 	throw new TypeError("Unsupported asset content type");
 }
-function bytesToHex$1(bytes) {
+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$1(new Uint8Array(digest));
+		return bytesToHex(new Uint8Array(digest));
 	}
 	try {
 		const { createHash } = await import("node:crypto");
@@ -1596,8 +514,7 @@ var MetadataManager = class {
 		return this.state.metadata.entries();
 	}
 	get(docId) {
-		const metadata = this.state.metadata.get(docId);
-		return metadata ? cloneJsonObject(metadata) : void 0;
+		return this.state.metadata.get(docId);
 	}
 	listDoc(query) {
 		if (query?.limit !== void 0 && query.limit <= 0) return [];
@@ -1642,20 +559,16 @@ var MetadataManager = class {
 		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;
+			if (jsonEquals(base ? base[key] : void 0, rawValue)) continue;
 			const storageKey = key === "tombstone" ? "$tombstone" : key;
+			console.log("upserting", rawValue);
 			this.metaFlock.put([
 				"m",
 				docId,
 				storageKey
-			], canonical);
-			const stored = cloneJsonValue(canonical) ?? canonical;
-			next[key] = stored;
-			outPatch[key] = cloneJsonValue(stored) ?? stored;
+			], rawValue);
+			next[key] = rawValue;
+			outPatch[key] = rawValue;
 			changed = true;
 		}
 		if (!changed) {
@@ -1667,7 +580,7 @@ var MetadataManager = class {
 		this.eventBus.emit({
 			kind: "doc-metadata",
 			docId,
-			patch: cloneJsonObject(outPatch),
+			patch: outPatch,
 			by: "local"
 		});
 	}
@@ -2828,5 +1741,5 @@ var LoroRepo = class LoroRepo {
 };
 
 //#endregion
-export { BroadcastChannelTransportAdapter, FileSystemStorageAdaptor, IndexedDBStorageAdaptor, LoroRepo, WebSocketTransportAdapter };
+export { LoroRepo };
 //# sourceMappingURL=index.js.map