@haklex/rich-collab-loro 0.44.0

package/dist/binding.d.ts

@@ -0,0 +1,15 @@
+import { LexicalEditor, NodeKey } from 'lexical';
+import { LoroDoc, TreeID } from 'loro-crdt';
+export declare const COLLAB_TAG = "collab";
+export declare const TREE_NAME = "lexical";
+export interface LoroBinding {
+    dispose: () => void;
+    idOf: (key: NodeKey) => TreeID | undefined;
+    import: (bytes: Uint8Array) => void;
+    keyOf: (id: TreeID) => NodeKey | undefined;
+}
+export interface LoroBindingOptions {
+    commitMessage?: string;
+}
+export declare function createLoroBinding(editor: LexicalEditor, doc: LoroDoc, options?: LoroBindingOptions): LoroBinding;
+//# sourceMappingURL=binding.d.ts.map

package/dist/binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../src/binding.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,aAAa,EAElB,KAAK,OAAO,EAGb,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,KAAK,OAAO,EAA+B,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAMnF,eAAO,MAAM,UAAU,WAAW,CAAC;AACnC,eAAO,MAAM,SAAS,YAAY,CAAC;AAGnC,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,IAAI,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC;IAC3C,MAAM,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IACpC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAC;CAC5C;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAmBD,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,OAAO,EACZ,OAAO,GAAE,kBAAuB,GAC/B,WAAW,CA4Nb"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { COLLAB_TAG, createLoroBinding, type LoroBinding, type LoroBindingOptions, TREE_NAME, } from './binding';
+export { $reconcileRoot, editAtVersion } from './reconcile';
+export { type Frame, type FrameFocus, planFrames, streamAtVersion, type StreamStep, } from './stream';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,SAAS,GACV,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EACL,KAAK,KAAK,EACV,KAAK,UAAU,EACf,UAAU,EACV,eAAe,EACf,KAAK,UAAU,GAChB,MAAM,UAAU,CAAC"}

package/dist/index.mjs

@@ -0,0 +1,516 @@
+import { $getNodeByKey, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $isTextNode, $parseSerializedNode } from "lexical";
+import { LoroText } from "loro-crdt";
+//#region src/offset.ts
+function transformOffset(previous, next, offset) {
+	const limit = Math.min(previous.length, next.length);
+	let prefix = 0;
+	while (prefix < limit && previous[prefix] === next[prefix]) prefix++;
+	let suffix = 0;
+	while (suffix < limit - prefix && previous[previous.length - 1 - suffix] === next[next.length - 1 - suffix]) suffix++;
+	if (offset <= prefix) return offset;
+	if (offset >= previous.length - suffix) return offset + next.length - previous.length;
+	return next.length - suffix;
+}
+//#endregion
+//#region src/stable.ts
+function stable(value) {
+	if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.keys(value).filter((key) => value[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${stable(value[key])}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+//#endregion
+//#region src/reconcile.ts
+var DERIVED_KEYS = { listitem: ["value"] };
+function withoutDerived(json) {
+	const { children: _children, text: _text, ...rest } = json;
+	for (const key of DERIVED_KEYS[json.type] ?? []) delete rest[key];
+	return rest;
+}
+function shallow(json) {
+	return stable(withoutDerived(json));
+}
+function $serialize(node) {
+	const json = node.exportJSON();
+	if ($isElementNode(node)) json.children = node.getChildren().map($serialize);
+	return json;
+}
+function lcs(a, b) {
+	const table = Array.from({ length: a.length + 1 }, () => new Uint32Array(b.length + 1));
+	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) table[i][j] = a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+	const pairs = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) if (a[i] === b[j]) pairs.push([i++, j++]);
+	else if (table[i + 1][j] >= table[i][j + 1]) i++;
+	else j++;
+	return pairs;
+}
+function $updateInPlace(node, target) {
+	const props = withoutDerived(target);
+	node.updateFromJSON(props);
+	return shallow(node.exportJSON()) === shallow(target);
+}
+function $update(node, current, target) {
+	if ($isTextNode(node)) {
+		if (shallow(current) !== shallow(target)) node.updateFromJSON({
+			...target,
+			text: node.getTextContent()
+		});
+		if (node.getTextContent() !== target.text) node.setTextContent(target.text ?? "");
+		return node;
+	}
+	if ($isElementNode(node)) {
+		let element = node;
+		if (shallow(current) !== shallow(target) && !$updateInPlace(node, target)) {
+			const replacement = $parseSerializedNode({
+				...target,
+				children: []
+			});
+			if (!$isElementNode(replacement)) return node;
+			node.replace(replacement, true);
+			element = replacement;
+		}
+		$reconcileChildren(element, target.children ?? []);
+		return element;
+	}
+	if (stable(current) === stable(target) || $updateInPlace(node, target)) return node;
+	const replacement = $parseSerializedNode(target);
+	node.replace(replacement);
+	return replacement;
+}
+function pairable(current, target) {
+	if (current.type !== target.type) return false;
+	const a = current.$?.blockId;
+	const b = target.$?.blockId;
+	return a === void 0 || b === void 0 || a === b;
+}
+function $reconcileChildren(parent, targets) {
+	const current = parent.getChildren();
+	const currentJson = current.map($serialize);
+	const pairs = lcs(currentJson.map(stable), targets.map(stable));
+	const result = [];
+	let ci = 0;
+	let tj = 0;
+	for (const [i, j] of [...pairs, [current.length, targets.length]]) {
+		const pending = Array.from({ length: i - ci }, (_, k) => ci + k);
+		for (let t = tj; t < j; t++) {
+			const target = targets[t];
+			const blockId = target.$?.blockId;
+			let slot = blockId === void 0 ? -1 : pending.findIndex((c) => currentJson[c].$?.blockId === blockId && pairable(currentJson[c], target));
+			if (slot === -1) slot = pending.findIndex((c) => pairable(currentJson[c], target));
+			if (slot === -1) result.push($parseSerializedNode(target));
+			else {
+				const [c] = pending.splice(slot, 1);
+				result.push($update(current[c], currentJson[c], target));
+			}
+		}
+		if (i < current.length) result.push(current[i]);
+		ci = i + 1;
+		tj = j + 1;
+	}
+	const kept = new Set(result.map((node) => node.getKey()));
+	for (const node of parent.getChildren()) if (!kept.has(node.getKey())) node.remove(true);
+	result.forEach((node, index) => {
+		const at = parent.getChildAtIndex(index);
+		if (at && at.is(node)) return;
+		if (index === 0) {
+			const first = parent.getFirstChild();
+			if (first) first.insertBefore(node);
+			else parent.append(node);
+		} else result[index - 1].insertAfter(node);
+	});
+}
+function $reconcileRoot(target) {
+	const root = $getRoot();
+	const targetJson = target;
+	if (shallow($serialize(root)) !== shallow(targetJson)) root.updateFromJSON(target);
+	$reconcileChildren(root, (targetJson.children ?? []).map((child) => $serialize($parseSerializedNode(child))));
+}
+function editAtVersion(doc, frontiers, createEditor, target, commitMessage) {
+	const fork = doc.forkAt(frontiers);
+	const editor = createEditor();
+	const binding = createLoroBinding(editor, fork, { commitMessage });
+	const from = fork.oplogVersion();
+	editor.update(() => $reconcileRoot(target.root), { discrete: true });
+	binding.dispose();
+	return fork.export({
+		from,
+		mode: "update"
+	});
+}
+//#endregion
+//#region src/binding.ts
+var COLLAB_TAG = "collab";
+var TREE_NAME = "lexical";
+var TEXT_KEY = "#text";
+function sameValue(a, b) {
+	return a === b || stable(a) === stable(b);
+}
+function nodeProps(node) {
+	const { children: _children, ...props } = node.exportJSON();
+	if ($isTextNode(node)) delete props.text;
+	return props;
+}
+function storedProps(treeNode) {
+	const { [TEXT_KEY]: _text, ...props } = treeNode.data.toJSON();
+	return props;
+}
+function createLoroBinding(editor, doc, options = {}) {
+	const tree = doc.getTree(TREE_NAME);
+	tree.enableFractionalIndex(0);
+	const keyToId = /* @__PURE__ */ new Map();
+	const idToKey = /* @__PURE__ */ new Map();
+	const link = (key, id) => {
+		const previousId = keyToId.get(key);
+		if (previousId !== void 0) idToKey.delete(previousId);
+		const previousKey = idToKey.get(id);
+		if (previousKey !== void 0) keyToId.delete(previousKey);
+		keyToId.set(key, id);
+		idToKey.set(id, key);
+	};
+	const alive = (id) => id !== void 0 && tree.has(id) && !tree.isNodeDeleted(id);
+	const synced = /* @__PURE__ */ new Map();
+	const readBaseline = /* @__PURE__ */ new Map();
+	const writeNode = (node, treeNode) => {
+		const data = treeNode.data;
+		const props = nodeProps(node);
+		const previous = synced.get(node.getKey()) ?? {};
+		let wrote = false;
+		for (const key of /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(props)])) {
+			const value = props[key];
+			if (sameValue(previous[key], value) && (value === void 0 || data.get(key) !== void 0)) continue;
+			if (value === void 0) {
+				if (data.get(key) !== void 0) {
+					data.delete(key);
+					wrote = true;
+				}
+			} else if (!sameValue(data.get(key), value)) {
+				data.set(key, value);
+				wrote = true;
+			}
+		}
+		synced.set(node.getKey(), props);
+		if (wrote) readBaseline.set(treeNode.id, stable(storedProps(treeNode)));
+		if ($isTextNode(node)) {
+			const text = data.getOrCreateContainer(TEXT_KEY, new LoroText());
+			const next = node.getTextContent();
+			if (text.toString() !== next) text.update(next);
+		}
+	};
+	const writeChildren = (parent, parentId, visited) => {
+		parent.getChildren().forEach((child, index) => {
+			let id = keyToId.get(child.getKey());
+			if (alive(id)) {
+				const current = tree.getNodeByID(id);
+				if (current.parent()?.id !== parentId || current.index() !== index) tree.move(id, parentId, index);
+			} else {
+				id = tree.createNode(parentId, index).id;
+				link(child.getKey(), id);
+			}
+			visited.add(id);
+			writeNode(child, tree.getNodeByID(id));
+			if ($isElementNode(child)) writeChildren(child, id, visited);
+		});
+	};
+	const pushToDoc = () => {
+		editor.getEditorState().read(() => {
+			let rootId = keyToId.get("root");
+			if (!alive(rootId)) {
+				rootId = tree.roots()[0]?.id ?? tree.createNode().id;
+				link("root", rootId);
+			}
+			const visited = /* @__PURE__ */ new Set([rootId]);
+			writeNode($getRoot(), tree.getNodeByID(rootId));
+			writeChildren($getRoot(), rootId, visited);
+			for (const treeNode of tree.nodes()) if (!visited.has(treeNode.id) && alive(treeNode.id)) {
+				tree.delete(treeNode.id);
+				const key = idToKey.get(treeNode.id);
+				if (key !== void 0) keyToId.delete(key);
+				idToKey.delete(treeNode.id);
+			}
+		});
+		doc.commit({ message: options.commitMessage });
+	};
+	const applyText = (node, next) => {
+		const previous = node.getTextContent();
+		if (previous === next) return;
+		const selection = $getSelection();
+		const points = $isRangeSelection(selection) ? [selection.anchor, selection.focus].filter((point) => point.type === "text" && point.key === node.getKey()) : [];
+		const offsets = points.map((point) => transformOffset(previous, next, point.offset));
+		node.setTextContent(next);
+		points.forEach((point, index) => point.set(node.getKey(), offsets[index], "text"));
+	};
+	const readNode = (treeNode) => {
+		const node = readNodeUnsynced(treeNode);
+		synced.set(node.getKey(), nodeProps(node));
+		return node;
+	};
+	const readNodeUnsynced = (treeNode) => {
+		const props = storedProps(treeNode);
+		const text = $isTextLike(props) ? String(treeNode.data.get(TEXT_KEY) ?? "") : void 0;
+		const key = idToKey.get(treeNode.id);
+		const existing = key === void 0 ? null : $getNodeByKey(key);
+		if (existing && existing.getType() === props.type) {
+			if ($isTextNode(existing)) {
+				if (!sameValue(nodeProps(existing), props)) existing.updateFromJSON({
+					...props,
+					text: existing.getTextContent()
+				});
+				applyText(existing, text ?? "");
+				return existing;
+			}
+			const storedKey = stable(props);
+			if (readBaseline.get(treeNode.id) === storedKey || sameValue(nodeProps(existing), props)) {
+				readBaseline.set(treeNode.id, storedKey);
+				return existing;
+			}
+			if ($updateInPlace(existing, props)) {
+				readBaseline.set(treeNode.id, storedKey);
+				return existing;
+			}
+			readBaseline.set(treeNode.id, storedKey);
+			const replacement = $parseSerializedNode({
+				...props,
+				children: []
+			});
+			existing.replace(replacement, $isElementNode(existing) && $isElementNode(replacement));
+			link(replacement.getKey(), treeNode.id);
+			return replacement;
+		}
+		const created = $parseSerializedNode({
+			...props,
+			...text === void 0 ? {} : { text },
+			children: []
+		});
+		readBaseline.set(treeNode.id, stable(props));
+		link(created.getKey(), treeNode.id);
+		return created;
+	};
+	const readChildren = (parent, treeNode, visited) => {
+		(treeNode.children() ?? []).forEach((child, index) => {
+			const node = readNode(child);
+			visited.add(node.getKey());
+			const current = parent.getChildAtIndex(index);
+			if (!current || !current.is(node)) {
+				if (index === 0) {
+					const first = parent.getFirstChild();
+					if (first) first.insertBefore(node);
+					else parent.append(node);
+				} else parent.getChildAtIndex(index - 1).insertAfter(node);
+			}
+			if ($isElementNode(node)) readChildren(node, child, visited);
+		});
+	};
+	const $collectDescendants = (node, out) => {
+		for (const child of node.getChildren()) {
+			out.push(child);
+			if ($isElementNode(child)) $collectDescendants(child, out);
+		}
+	};
+	const pullFromDoc = () => {
+		editor.update(() => {
+			const rootTreeNode = tree.roots()[0];
+			if (!rootTreeNode) return;
+			link("root", rootTreeNode.id);
+			const rootProps = storedProps(rootTreeNode);
+			if (rootProps.type === "root" && !sameValue(nodeProps($getRoot()), rootProps)) $getRoot().updateFromJSON(rootProps);
+			synced.set("root", nodeProps($getRoot()));
+			const visited = /* @__PURE__ */ new Set(["root"]);
+			readChildren($getRoot(), rootTreeNode, visited);
+			const all = [];
+			$collectDescendants($getRoot(), all);
+			for (const node of all) if (!visited.has(node.getKey()) && node.isAttached()) node.remove();
+		}, {
+			discrete: true,
+			tag: COLLAB_TAG
+		});
+	};
+	if (tree.roots().length > 0) pullFromDoc();
+	else pushToDoc();
+	return {
+		dispose: editor.registerUpdateListener(({ dirtyElements, dirtyLeaves }) => {
+			if (dirtyElements.size === 0 && dirtyLeaves.size === 0) return;
+			pushToDoc();
+		}),
+		idOf: (key) => keyToId.get(key),
+		keyOf: (id) => idToKey.get(id),
+		import: (bytes) => {
+			doc.import(bytes);
+			pullFromDoc();
+		}
+	};
+}
+function $isTextLike(props) {
+	return typeof props.format === "number" && typeof props.detail === "number" && "mode" in props;
+}
+//#endregion
+//#region src/stream.ts
+var TYPING_FRAME_BUDGET = 120;
+var MAX_FRAMES_PER_BLOCK = 24;
+var isFlat = (block) => !block || (block.children ?? []).every((child) => child.type === "text");
+var textOf = (block) => (block?.children ?? []).map((child) => child.text ?? "").join("");
+function sliceRuns(runs, start, end) {
+	const out = [];
+	let offset = 0;
+	for (const run of runs) {
+		const text = run.text ?? "";
+		const from = Math.max(start, offset);
+		const to = Math.min(end, offset + text.length);
+		if (to > from) out.push({
+			...run,
+			text: text.slice(from - offset, to - offset)
+		});
+		offset += text.length;
+	}
+	return out;
+}
+function typingSpan(item) {
+	const before = textOf(item.old);
+	const after = textOf(item.next);
+	const limit = Math.min(before.length, after.length);
+	let prefix = 0;
+	while (prefix < limit && before[prefix] === after[prefix]) prefix++;
+	let suffix = 0;
+	while (suffix < limit - prefix && before[before.length - 1 - suffix] === after[after.length - 1 - suffix]) suffix++;
+	return {
+		after,
+		prefix,
+		suffix,
+		middle: after.length - prefix - suffix
+	};
+}
+function pairGap(dels, adds) {
+	const pending = [...dels];
+	return adds.map((next) => {
+		const blockId = next.$?.blockId;
+		let slot = blockId === void 0 ? -1 : pending.findIndex((old) => old.$?.blockId === blockId);
+		if (slot === -1) slot = pending.findIndex((old) => pairable(old, next));
+		return {
+			next,
+			old: slot === -1 ? null : pending.splice(slot, 1)[0]
+		};
+	});
+}
+function planFrames(base, target) {
+	const before = base.children ?? [];
+	const after = target.children ?? [];
+	const gaps = [];
+	let ci = 0;
+	let tj = 0;
+	for (const [i, j] of [...lcs(before.map(stable), after.map(stable)), [before.length, after.length]]) {
+		gaps.push({
+			dels: before.slice(ci, i),
+			items: pairGap(before.slice(ci, i), after.slice(tj, j)),
+			matched: after[j] ?? null
+		});
+		ci = i + 1;
+		tj = j + 1;
+	}
+	const typingItems = gaps.flatMap((gap) => gap.items).filter((item) => isFlat(item.old) && isFlat(item.next) && typingSpan(item).middle > 0);
+	const perBlock = Math.min(MAX_FRAMES_PER_BLOCK, Math.max(1, Math.floor(TYPING_FRAME_BUDGET / Math.max(1, typingItems.length))));
+	const regions = gaps.map((gap) => [...gap.dels]);
+	const frames = [];
+	const render = () => ({
+		...target,
+		children: gaps.flatMap((gap, g) => [...regions[g], ...gap.matched ? [gap.matched] : []])
+	});
+	const regionStart = (g) => gaps.slice(0, g).reduce((sum, gap, k) => sum + regions[k].length + (gap.matched ? 1 : 0), 0);
+	const push = (focus) => frames.push({
+		focus,
+		root: render()
+	});
+	gaps.forEach((gap, g) => {
+		const kept = gap.items.flatMap((item) => item.old ? [item.old] : []);
+		if (stable(kept) !== stable(regions[g])) {
+			regions[g] = kept;
+			push(null);
+		}
+		gap.items.forEach((item, k) => {
+			const region = regions[g];
+			const place = (block, offset, first) => {
+				region.splice(k, first && !item.old ? 0 : 1, block);
+				push({
+					offset,
+					path: [regionStart(g) + k]
+				});
+			};
+			const span = typingSpan(item);
+			if (!isFlat(item.old) || !isFlat(item.next) || span.middle === 0) {
+				place(item.next, item.old ? span.prefix : 0, true);
+				return;
+			}
+			const runs = item.next.children ?? [];
+			const count = Math.min(perBlock, span.middle);
+			const chunk = Math.ceil(span.middle / count);
+			let first = true;
+			for (let revealed = chunk; revealed < span.middle; revealed += chunk) {
+				const cut = span.prefix + revealed;
+				place({
+					...item.next,
+					children: [...sliceRuns(runs, 0, cut), ...sliceRuns(runs, span.after.length - span.suffix, span.after.length)]
+				}, cut, first);
+				first = false;
+			}
+			place(item.next, span.prefix + span.middle, first);
+		});
+	});
+	return frames;
+}
+function $locate(focus) {
+	if (!focus) return null;
+	const block = $getRoot().getChildAtIndex(focus.path[0]);
+	if (!block) return null;
+	if (!$isElementNode(block)) return {
+		key: block.getKey(),
+		offset: 0
+	};
+	let remaining = focus.offset;
+	const texts = block.getChildren().filter($isTextNode);
+	for (const text of texts) {
+		const size = text.getTextContentSize();
+		if (remaining <= size) return {
+			key: text.getKey(),
+			offset: remaining
+		};
+		remaining -= size;
+	}
+	const last = texts.at(-1);
+	return last ? {
+		key: last.getKey(),
+		offset: last.getTextContentSize()
+	} : {
+		key: block.getKey(),
+		offset: 0
+	};
+}
+function streamAtVersion(doc, frontiers, createEditor, base, target, commitMessage) {
+	const fork = doc.forkAt(frontiers);
+	const editor = createEditor();
+	const binding = createLoroBinding(editor, fork, { commitMessage });
+	const steps = [];
+	let from = fork.oplogVersion();
+	for (const frame of planFrames(base.root, target.root)) {
+		editor.update(() => $reconcileRoot(frame.root), { discrete: true });
+		const at = editor.getEditorState().read(() => $locate(frame.focus));
+		const id = at ? binding.idOf(at.key) : void 0;
+		const update = fork.export({
+			from,
+			mode: "update"
+		});
+		from = fork.oplogVersion();
+		steps.push({
+			cursor: id && at ? {
+				id,
+				offset: at.offset
+			} : null,
+			update
+		});
+	}
+	binding.dispose();
+	return {
+		frontiers: fork.frontiers(),
+		steps
+	};
+}
+//#endregion
+export { $reconcileRoot, COLLAB_TAG, TREE_NAME, createLoroBinding, editAtVersion, planFrames, streamAtVersion };

package/dist/offset.d.ts

@@ -0,0 +1,2 @@
+export declare function transformOffset(previous: string, next: string, offset: number): number;
+//# sourceMappingURL=offset.d.ts.map

package/dist/offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offset.d.ts","sourceRoot":"","sources":["../src/offset.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CActF"}

package/dist/reconcile.d.ts

@@ -0,0 +1,16 @@
+import { LexicalEditor, LexicalNode, SerializedEditorState, SerializedLexicalNode } from 'lexical';
+import { LoroDoc } from 'loro-crdt';
+export type Json = SerializedLexicalNode & {
+    $?: {
+        blockId?: string;
+    };
+    children?: Json[];
+    text?: string;
+};
+export type Frontiers = ReturnType<LoroDoc['frontiers']>;
+export declare function lcs(a: string[], b: string[]): Array<[number, number]>;
+export declare function $updateInPlace(node: LexicalNode, target: Json): boolean;
+export declare function pairable(current: Json, target: Json): boolean;
+export declare function $reconcileRoot(target: SerializedEditorState['root']): void;
+export declare function editAtVersion(doc: LoroDoc, frontiers: Frontiers, createEditor: () => LexicalEditor, target: SerializedEditorState, commitMessage?: string): Uint8Array;
+//# sourceMappingURL=reconcile.d.ts.map

package/dist/reconcile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile.d.ts","sourceRoot":"","sources":["../src/reconcile.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC3B,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKzC,MAAM,MAAM,IAAI,GAAG,qBAAqB,GAAG;IACzC,CAAC,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzB,QAAQ,CAAC,EAAE,IAAI,EAAE,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;AAqBzD,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiBrE;AAID,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO,CAIvE;AA2BD,wBAAgB,QAAQ,CAAC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,OAAO,CAK7D;AAiDD,wBAAgB,cAAc,CAAC,MAAM,EAAE,qBAAqB,CAAC,MAAM,CAAC,GAAG,IAAI,CAQ1E;AAED,wBAAgB,aAAa,CAC3B,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,MAAM,aAAa,EACjC,MAAM,EAAE,qBAAqB,EAC7B,aAAa,CAAC,EAAE,MAAM,GACrB,UAAU,CAQZ"}

package/dist/stable.d.ts

@@ -0,0 +1,2 @@
+export declare function stable(value: unknown): string;
+//# sourceMappingURL=stable.d.ts.map

package/dist/stable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stable.d.ts","sourceRoot":"","sources":["../src/stable.ts"],"names":[],"mappings":"AAAA,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAU7C"}

package/dist/stream.d.ts

@@ -0,0 +1,24 @@
+import { LexicalEditor, SerializedEditorState } from 'lexical';
+import { LoroDoc, TreeID } from 'loro-crdt';
+import { Frontiers, Json } from './reconcile';
+export interface FrameFocus {
+    offset: number;
+    path: number[];
+}
+export interface Frame {
+    focus: FrameFocus | null;
+    root: Json;
+}
+export interface StreamStep {
+    cursor: {
+        id: TreeID;
+        offset: number;
+    } | null;
+    update: Uint8Array;
+}
+export declare function planFrames(base: Json, target: Json): Frame[];
+export declare function streamAtVersion(doc: LoroDoc, frontiers: Frontiers, createEditor: () => LexicalEditor, base: SerializedEditorState, target: SerializedEditorState, commitMessage?: string): {
+    frontiers: Frontiers;
+    steps: StreamStep[];
+};
+//# sourceMappingURL=stream.d.ts.map

package/dist/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAElB,KAAK,qBAAqB,EAC3B,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGjD,OAAO,EAAkB,KAAK,SAAS,EAAE,KAAK,IAAI,EAAiB,MAAM,aAAa,CAAC;AAGvF,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,KAAK;IACpB,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACzB,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC9C,MAAM,EAAE,UAAU,CAAC;CACpB;AA6DD,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAG,KAAK,EAAE,CA6E5D;AAoBD,wBAAgB,eAAe,CAC7B,GAAG,EAAE,OAAO,EACZ,SAAS,EAAE,SAAS,EACpB,YAAY,EAAE,MAAM,aAAa,EACjC,IAAI,EAAE,qBAAqB,EAC3B,MAAM,EAAE,qBAAqB,EAC7B,aAAa,CAAC,EAAE,MAAM,GACrB;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,UAAU,EAAE,CAAA;CAAE,CAgB/C"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@haklex/rich-collab-loro",
+  "version": "0.44.0",
+  "description": "Loro CRDT binding for Lexical — bidirectional LoroTree sync for real-time collaboration and history",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Innei/haklex.git",
+    "directory": "packages/rich-collab-loro"
+  },
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "devDependencies": {
+    "@lexical/headless": "^0.49.0",
+    "lexical": "^0.49.0",
+    "loro-crdt": "^1.16.3",
+    "typescript": "^7.0.2",
+    "unplugin-dts": "^1.0.3",
+    "vite": "^8.2.2",
+    "@haklex/rich-headless": "0.44.0",
+    "@haklex/rich-litexml": "0.44.0"
+  },
+  "peerDependencies": {
+    "lexical": "^0.49.0",
+    "loro-crdt": "^1.16.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vite build",
+    "dev:build": "vite build --watch"
+  },
+  "types": "./dist/index.d.ts"
+}