json-patch-to-crdt 0.0.0

package/dist/merge-B1BFMhJJ.js

@@ -0,0 +1,1723 @@
+
+//#region src/clock.ts
+/**
+* Create a new clock for the given actor. Each call to `clock.next()` yields a fresh `Dot`.
+* @param actor - Unique identifier for this peer.
+* @param start - Initial counter value (defaults to 0).
+*/
+function createClock(actor, start = 0) {
+	const clock = {
+		actor,
+		ctr: start,
+		next() {
+			clock.ctr += 1;
+			return {
+				actor: clock.actor,
+				ctr: clock.ctr
+			};
+		}
+	};
+	return clock;
+}
+/** Create an independent copy of a clock at the same counter position. */
+function cloneClock(clock) {
+	return createClock(clock.actor, clock.ctr);
+}
+/**
+* Generate the next per-actor dot from a mutable version vector.
+* Useful when a server needs to mint dots for many actors.
+*/
+function nextDotForActor(vv, actor) {
+	const ctr = (vv[actor] ?? 0) + 1;
+	vv[actor] = ctr;
+	return {
+		actor,
+		ctr
+	};
+}
+/** Record an observed dot in a version vector. */
+function observeDot(vv, dot) {
+	if ((vv[dot.actor] ?? 0) < dot.ctr) vv[dot.actor] = dot.ctr;
+}
+
+//#endregion
+//#region src/dot.ts
+function compareDot(a, b) {
+	if (a.ctr !== b.ctr) return a.ctr - b.ctr;
+	return a.actor < b.actor ? -1 : a.actor > b.actor ? 1 : 0;
+}
+function vvHasDot(vv, d) {
+	return (vv[d.actor] ?? 0) >= d.ctr;
+}
+function vvMerge(a, b) {
+	const out = { ...a };
+	for (const [actor, ctr] of Object.entries(b)) out[actor] = Math.max(out[actor] ?? 0, ctr);
+	return out;
+}
+function dotToElemId(d) {
+	return `${d.actor}:${d.ctr}`;
+}
+
+//#endregion
+//#region src/rga.ts
+const HEAD = "HEAD";
+const linearCache = /* @__PURE__ */ new WeakMap();
+const seqVersion = /* @__PURE__ */ new WeakMap();
+function getVersion(seq) {
+	return seqVersion.get(seq) ?? 0;
+}
+function bumpVersion(seq) {
+	seqVersion.set(seq, getVersion(seq) + 1);
+}
+function rgaChildrenIndex(seq) {
+	const idx = /* @__PURE__ */ new Map();
+	for (const e of seq.elems.values()) {
+		const arr = idx.get(e.prev) ?? [];
+		arr.push(e);
+		idx.set(e.prev, arr);
+	}
+	for (const arr of idx.values()) arr.sort((a, b) => compareDot(b.insDot, a.insDot));
+	return idx;
+}
+function rgaLinearizeIds(seq) {
+	const ver = getVersion(seq);
+	const cached = linearCache.get(seq);
+	if (cached && cached.version === ver) return cached.ids;
+	const idx = rgaChildrenIndex(seq);
+	const out = [];
+	function walk(prev) {
+		const children = idx.get(prev);
+		if (!children) return;
+		for (const c of children) {
+			if (!c.tombstone) out.push(c.id);
+			walk(c.id);
+		}
+	}
+	walk(HEAD);
+	linearCache.set(seq, {
+		version: ver,
+		ids: out
+	});
+	return out;
+}
+function rgaInsertAfter(seq, prev, id, insDot, value) {
+	if (seq.elems.has(id)) return;
+	seq.elems.set(id, {
+		id,
+		prev,
+		tombstone: false,
+		value,
+		insDot
+	});
+	bumpVersion(seq);
+}
+function rgaDelete(seq, id) {
+	const e = seq.elems.get(id);
+	if (!e) return;
+	if (e.tombstone) return;
+	e.tombstone = true;
+	bumpVersion(seq);
+}
+function rgaIdAtIndex(seq, index) {
+	return rgaLinearizeIds(seq)[index];
+}
+function rgaPrevForInsertAtIndex(seq, index) {
+	if (index <= 0) return HEAD;
+	const ids = rgaLinearizeIds(seq);
+	return ids[index - 1] ?? (ids.length ? ids[ids.length - 1] : HEAD);
+}
+
+//#endregion
+//#region src/materialize.ts
+/** Recursively convert a CRDT node graph into a plain JSON value. */
+function materialize(node) {
+	switch (node.kind) {
+		case "lww": return node.value;
+		case "obj": {
+			const out = {};
+			for (const [k, { node: child }] of node.entries.entries()) out[k] = materialize(child);
+			return out;
+		}
+		case "seq": return rgaLinearizeIds(node).map((id) => materialize(node.elems.get(id).value));
+	}
+}
+
+//#endregion
+//#region src/nodes.ts
+function newObj() {
+	return {
+		kind: "obj",
+		entries: /* @__PURE__ */ new Map(),
+		tombstone: /* @__PURE__ */ new Map()
+	};
+}
+function newSeq() {
+	return {
+		kind: "seq",
+		elems: /* @__PURE__ */ new Map()
+	};
+}
+function newReg(value, dot) {
+	return {
+		kind: "lww",
+		value,
+		dot
+	};
+}
+function lwwSet(reg, value, dot) {
+	if (compareDot(reg.dot, dot) <= 0) {
+		reg.value = value;
+		reg.dot = dot;
+	}
+}
+function objSet(obj, key, node, dot) {
+	const delDot = obj.tombstone.get(key);
+	if (delDot && compareDot(delDot, dot) >= 0) return;
+	const cur = obj.entries.get(key);
+	if (!cur || compareDot(cur.dot, dot) <= 0) obj.entries.set(key, {
+		node,
+		dot
+	});
+}
+function objRemove(obj, key, dot) {
+	const curDel = obj.tombstone.get(key);
+	if (!curDel || compareDot(curDel, dot) <= 0) obj.tombstone.set(key, dot);
+	obj.entries.delete(key);
+}
+
+//#endregion
+//#region src/types.ts
+/**
+* Internal sentinel key used in `IntentOp` to represent root-level operations.
+* Namespaced to avoid collision with user data keys.
+*/
+const ROOT_KEY = "@@crdt/root";
+
+//#endregion
+//#region src/patch.ts
+/**
+* Parse an RFC 6901 JSON Pointer into a path array, unescaping `~1` and `~0`.
+* @param ptr - A JSON Pointer string (e.g. `"/a/b"` or `""`).
+* @returns An array of path segments.
+*/
+function parseJsonPointer(ptr) {
+	if (ptr === "") return [];
+	if (!ptr.startsWith("/")) throw new Error(`Invalid pointer: ${ptr}`);
+	return ptr.slice(1).split("/").map((s) => s.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+/** Convert a path array back to an RFC 6901 JSON Pointer string. */
+function stringifyJsonPointer(path) {
+	if (path.length === 0) return "";
+	return `/${path.map(escapeJsonPointer).join("/")}`;
+}
+/**
+* Navigate a JSON value by path and return the value at that location.
+* Throws if the path is invalid, out of bounds, or traverses a non-container.
+*/
+function getAtJson(base, path) {
+	let cur = base;
+	for (const seg of path) if (Array.isArray(cur)) {
+		const idx = seg === "-" ? cur.length : Number(seg);
+		if (!Number.isInteger(idx)) throw new Error(`Expected array index, got ${seg}`);
+		if (idx < 0 || idx >= cur.length) throw new Error(`Index out of bounds at ${seg}`);
+		cur = cur[idx];
+	} else if (cur && typeof cur === "object") {
+		if (!(seg in cur)) throw new Error(`Missing key ${seg}`);
+		cur = cur[seg];
+	} else throw new Error(`Cannot traverse into non-container at ${seg}`);
+	return cur;
+}
+/**
+* Compile RFC 6902 JSON Patch operations into CRDT intent operations.
+* `move`/`copy` are expanded to `add` + optional `remove`. Array indices
+* and the `"-"` append token are resolved against the base JSON.
+* @param baseJson - The base JSON value for resolving paths.
+* @param patch - Array of JSON Patch operations.
+* @returns An array of `IntentOp` ready for `applyIntentsToCrdt`.
+*/
+function compileJsonPatchToIntent(baseJson, patch) {
+	const intents = [];
+	for (const op of patch) {
+		if (op.op === "test") {
+			intents.push({
+				t: "Test",
+				path: parseJsonPointer(op.path),
+				value: op.value
+			});
+			continue;
+		}
+		if (op.op === "copy" || op.op === "move") {
+			const val = getAtJson(baseJson, parseJsonPointer(op.from));
+			intents.push(...compileJsonPatchToIntent(baseJson, [{
+				op: "add",
+				path: op.path,
+				value: val
+			}]));
+			if (op.op === "move") intents.push(...compileJsonPatchToIntent(baseJson, [{
+				op: "remove",
+				path: op.from
+			}]));
+			continue;
+		}
+		const path = parseJsonPointer(op.path);
+		const parent = path.slice(0, -1);
+		const last = path[path.length - 1];
+		if (path.length === 0) {
+			if (op.op === "replace" || op.op === "add") intents.push({
+				t: "ObjSet",
+				path: [],
+				key: ROOT_KEY,
+				value: op.value
+			});
+			else if (op.op === "remove") intents.push({
+				t: "ObjSet",
+				path: [],
+				key: ROOT_KEY,
+				value: null
+			});
+			continue;
+		}
+		const isIndexLike = (s) => s === "-" || /^[0-9]+$/.test(s);
+		if (isIndexLike(last)) {
+			const index = last === "-" ? Number.POSITIVE_INFINITY : Number(last);
+			if (op.op === "add") intents.push({
+				t: "ArrInsert",
+				path: parent,
+				index,
+				value: op.value
+			});
+			else if (op.op === "remove") intents.push({
+				t: "ArrDelete",
+				path: parent,
+				index
+			});
+			else if (op.op === "replace") intents.push({
+				t: "ArrReplace",
+				path: parent,
+				index,
+				value: op.value
+			});
+			else assertNever$1(op, "Unsupported op at array index path");
+		} else {
+			const parentValue = pathValueAt(baseJson, parent);
+			if (!isPlainObject(parentValue)) throw new Error(`Expected object parent at ${stringifyJsonPointer(parent)}`);
+			if ((op.op === "replace" || op.op === "remove") && !hasOwn(parentValue, last)) throw new Error(`Missing key ${last} at ${stringifyJsonPointer(parent)}`);
+			if (op.op === "add") intents.push({
+				t: "ObjSet",
+				path: parent,
+				key: last,
+				value: op.value,
+				mode: "add"
+			});
+			else if (op.op === "replace") intents.push({
+				t: "ObjSet",
+				path: parent,
+				key: last,
+				value: op.value,
+				mode: "replace"
+			});
+			else if (op.op === "remove") intents.push({
+				t: "ObjRemove",
+				path: parent,
+				key: last
+			});
+			else assertNever$1(op, "Unsupported op");
+		}
+	}
+	return intents;
+}
+/**
+* Compute a JSON Patch delta between two JSON values.
+* By default arrays use a deterministic LCS strategy.
+* Pass `{ arrayStrategy: "atomic" }` for single-op array replacement.
+* @param base - The original JSON value.
+* @param next - The target JSON value.
+* @param options - Diff options.
+* @returns An array of JSON Patch operations that transform `base` into `next`.
+*/
+function diffJsonPatch(base, next, options = {}) {
+	const ops = [];
+	diffValue([], base, next, ops, options);
+	return ops;
+}
+function diffValue(path, base, next, ops, options) {
+	if (jsonEquals(base, next)) return;
+	if (Array.isArray(base) || Array.isArray(next)) {
+		if ((options.arrayStrategy ?? "lcs") === "lcs" && Array.isArray(base) && Array.isArray(next)) {
+			diffArray(path, base, next, ops, options);
+			return;
+		}
+		ops.push({
+			op: "replace",
+			path: stringifyJsonPointer(path),
+			value: next
+		});
+		return;
+	}
+	if (!isPlainObject(base) || !isPlainObject(next)) {
+		ops.push({
+			op: "replace",
+			path: stringifyJsonPointer(path),
+			value: next
+		});
+		return;
+	}
+	const baseKeys = Object.keys(base).sort();
+	const nextKeys = Object.keys(next).sort();
+	const baseSet = new Set(baseKeys);
+	const nextSet = new Set(nextKeys);
+	for (const key of baseKeys) if (!nextSet.has(key)) ops.push({
+		op: "remove",
+		path: stringifyJsonPointer([...path, key])
+	});
+	for (const key of nextKeys) if (!baseSet.has(key)) {
+		const nextValue = next[key];
+		ops.push({
+			op: "add",
+			path: stringifyJsonPointer([...path, key]),
+			value: nextValue
+		});
+	}
+	for (const key of baseKeys) if (nextSet.has(key)) diffValue([...path, key], base[key], next[key], ops, options);
+}
+function diffArray(path, base, next, ops, _options) {
+	const n = base.length;
+	const m = next.length;
+	const lcs = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
+	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) if (jsonEquals(base[i], next[j])) lcs[i][j] = 1 + lcs[i + 1][j + 1];
+	else lcs[i][j] = Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+	const localOps = [];
+	let i = 0;
+	let j = 0;
+	let index = 0;
+	while (i < n || j < m) {
+		if (i < n && j < m && jsonEquals(base[i], next[j])) {
+			i += 1;
+			j += 1;
+			index += 1;
+			continue;
+		}
+		const lcsDown = i < n ? lcs[i + 1][j] : -1;
+		const lcsRight = j < m ? lcs[i][j + 1] : -1;
+		if (j < m && (i === n || lcsRight > lcsDown)) {
+			localOps.push({
+				op: "add",
+				path: stringifyJsonPointer([...path, String(index)]),
+				value: next[j]
+			});
+			j += 1;
+			index += 1;
+			continue;
+		}
+		if (i < n) {
+			localOps.push({
+				op: "remove",
+				path: stringifyJsonPointer([...path, String(index)])
+			});
+			i += 1;
+			continue;
+		}
+	}
+	ops.push(...compactArrayOps(localOps));
+}
+function compactArrayOps(ops) {
+	const out = [];
+	for (let i = 0; i < ops.length; i++) {
+		const op = ops[i];
+		const next = ops[i + 1];
+		if (op.op === "remove" && next && next.op === "add" && op.path === next.path) {
+			out.push({
+				op: "replace",
+				path: op.path,
+				value: next.value
+			});
+			i += 1;
+			continue;
+		}
+		out.push(op);
+	}
+	return out;
+}
+function escapeJsonPointer(token) {
+	return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+/** Deep equality check for JSON values (null-safe, handles arrays and objects). */
+function jsonEquals(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null) return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!Array.isArray(a) || !Array.isArray(b)) return false;
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!jsonEquals(a[i], b[i])) return false;
+		return true;
+	}
+	if (!isPlainObject(a) || !isPlainObject(b)) return false;
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	for (const key of aKeys) {
+		if (!(key in b)) return false;
+		if (!jsonEquals(a[key], b[key])) return false;
+	}
+	return true;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+function pathValueAt(base, path) {
+	if (path.length === 0) return base;
+	return getAtJson(base, path);
+}
+function assertNever$1(_value, message) {
+	throw new Error(message);
+}
+
+//#endregion
+//#region src/doc.ts
+/**
+* Create a CRDT document from a JSON value, using fresh dots for each node.
+* @param value - The JSON value to convert.
+* @param nextDot - A function that generates a unique `Dot` on each call.
+* @returns A new CRDT `Doc`.
+*/
+function docFromJson(value, nextDot) {
+	return { root: nodeFromJson(value, nextDot) };
+}
+/**
+* Legacy: create a doc using a single dot with counter offsets for array children.
+* Prefer `docFromJson(value, nextDot)` to ensure unique dots per node.
+*/
+function docFromJsonWithDot(value, dot) {
+	return { root: deepNodeFromJson(value, dot) };
+}
+function getSeqAtPath(doc, path) {
+	let cur = doc.root;
+	for (const seg of path) {
+		if (cur.kind !== "obj") return;
+		const ent = cur.entries.get(seg);
+		if (!ent) return;
+		cur = ent.node;
+	}
+	return cur.kind === "seq" ? cur : void 0;
+}
+function getObjAtPathStrict(doc, path) {
+	let cur = doc.root;
+	const seen = [];
+	if (path.length === 0) {
+		if (cur.kind !== "obj") return {
+			ok: false,
+			message: "expected object at /"
+		};
+		return {
+			ok: true,
+			obj: cur
+		};
+	}
+	for (const seg of path) {
+		if (cur.kind !== "obj") return {
+			ok: false,
+			message: `expected object at /${seen.join("/")}`
+		};
+		const entry = cur.entries.get(seg);
+		seen.push(seg);
+		if (!entry || entry.node.kind !== "obj") return {
+			ok: false,
+			message: `expected object at /${seen.join("/")}`
+		};
+		cur = entry.node;
+	}
+	return {
+		ok: true,
+		obj: cur
+	};
+}
+function ensureSeqAtPath(head, path, dotForCreate) {
+	let cur = head.root;
+	let parent = null;
+	let parentKey = null;
+	if (path.length === 0) {
+		if (head.root.kind !== "seq") head.root = newSeq();
+		return head.root;
+	}
+	for (let i = 0; i < path.length; i++) {
+		const seg = path[i];
+		if (cur.kind !== "obj") {
+			const replacement = newObj();
+			if (parent && parentKey !== null) objSet(parent, parentKey, replacement, dotForCreate);
+			else head.root = replacement;
+			cur = replacement;
+		}
+		const obj = cur;
+		const ent = obj.entries.get(seg);
+		if (i === path.length - 1) {
+			if (!ent || ent.node.kind !== "seq") {
+				const seq = newSeq();
+				objSet(obj, seg, seq, dotForCreate);
+				return seq;
+			}
+			return ent.node;
+		}
+		if (!ent || ent.node.kind !== "obj") {
+			const child = newObj();
+			objSet(obj, seg, child, dotForCreate);
+			parent = obj;
+			parentKey = seg;
+			cur = child;
+		} else {
+			parent = obj;
+			parentKey = seg;
+			cur = ent.node;
+		}
+	}
+	if (head.root.kind !== "seq") head.root = newSeq();
+	return head.root;
+}
+function deepNodeFromJson(value, dot) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return newReg(value, dot);
+	if (Array.isArray(value)) {
+		const seq = newSeq();
+		let prev = HEAD;
+		let ctr = dot.ctr;
+		for (const v of value) {
+			const childDot = {
+				actor: dot.actor,
+				ctr: ++ctr
+			};
+			const id = dotToElemId(childDot);
+			rgaInsertAfter(seq, prev, id, childDot, deepNodeFromJson(v, childDot));
+			prev = id;
+		}
+		return seq;
+	}
+	const obj = newObj();
+	for (const [k, v] of Object.entries(value)) objSet(obj, k, deepNodeFromJson(v, dot), dot);
+	return obj;
+}
+function nodeFromJson(value, nextDot) {
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return newReg(value, nextDot());
+	if (Array.isArray(value)) {
+		const seq = newSeq();
+		let prev = HEAD;
+		for (const v of value) {
+			const insDot = nextDot();
+			const id = dotToElemId(insDot);
+			rgaInsertAfter(seq, prev, id, insDot, nodeFromJson(v, nextDot));
+			prev = id;
+		}
+		return seq;
+	}
+	const obj = newObj();
+	for (const [k, v] of Object.entries(value)) {
+		const entryDot = nextDot();
+		objSet(obj, k, nodeFromJson(v, nextDot), entryDot);
+	}
+	return obj;
+}
+/** Deep-clone a CRDT document. The clone is fully independent of the original. */
+function cloneDoc(doc) {
+	return { root: cloneNode(doc.root) };
+}
+function cloneNode(node) {
+	if (node.kind === "lww") return {
+		kind: "lww",
+		value: structuredClone(node.value),
+		dot: {
+			actor: node.dot.actor,
+			ctr: node.dot.ctr
+		}
+	};
+	if (node.kind === "obj") {
+		const entries = /* @__PURE__ */ new Map();
+		for (const [k, v] of node.entries.entries()) entries.set(k, {
+			node: cloneNode(v.node),
+			dot: {
+				actor: v.dot.actor,
+				ctr: v.dot.ctr
+			}
+		});
+		const tombstone = /* @__PURE__ */ new Map();
+		for (const [k, d] of node.tombstone.entries()) tombstone.set(k, {
+			actor: d.actor,
+			ctr: d.ctr
+		});
+		return {
+			kind: "obj",
+			entries,
+			tombstone
+		};
+	}
+	const elems = /* @__PURE__ */ new Map();
+	for (const [id, e] of node.elems.entries()) elems.set(id, {
+		id: e.id,
+		prev: e.prev,
+		tombstone: e.tombstone,
+		value: cloneNode(e.value),
+		insDot: {
+			actor: e.insDot.actor,
+			ctr: e.insDot.ctr
+		}
+	});
+	return {
+		kind: "seq",
+		elems
+	};
+}
+function applyTest(base, head, it, evalTestAgainst) {
+	const snapshot = evalTestAgainst === "head" ? materialize(head.root) : materialize(base.root);
+	let got;
+	try {
+		got = getAtJson(snapshot, it.path);
+	} catch {
+		return {
+			ok: false,
+			code: 409,
+			message: `test path missing at /${it.path.join("/")}`
+		};
+	}
+	if (!jsonEquals(got, it.value)) return {
+		ok: false,
+		code: 409,
+		message: `test failed at /${it.path.join("/")}`
+	};
+	return null;
+}
+function applyObjSet(head, it, newDot) {
+	if (it.path.length === 0 && it.key === ROOT_KEY) {
+		head.root = nodeFromJson(it.value, newDot);
+		return null;
+	}
+	const parentRes = getObjAtPathStrict(head, it.path);
+	if (!parentRes.ok) return {
+		ok: false,
+		code: 409,
+		message: parentRes.message
+	};
+	if (it.mode === "replace" && !parentRes.obj.entries.has(it.key)) return {
+		ok: false,
+		code: 409,
+		message: `no value at /${[...it.path, it.key].join("/")}`
+	};
+	const d = newDot();
+	const parentObj = parentRes.obj;
+	objSet(parentObj, it.key, nodeFromJson(it.value, newDot), d);
+	return null;
+}
+function applyObjRemove(head, it, newDot) {
+	const parentRes = getObjAtPathStrict(head, it.path);
+	if (!parentRes.ok) return {
+		ok: false,
+		code: 409,
+		message: parentRes.message
+	};
+	if (!parentRes.obj.entries.has(it.key)) return {
+		ok: false,
+		code: 409,
+		message: `no value at /${[...it.path, it.key].join("/")}`
+	};
+	const d = newDot();
+	const parentObj = parentRes.obj;
+	objRemove(parentObj, it.key, d);
+	return null;
+}
+function applyArrInsert(base, head, it, newDot, bumpCounterAbove) {
+	const baseSeq = getSeqAtPath(base, it.path);
+	if (!baseSeq) {
+		if (it.index === 0 || it.index === Number.POSITIVE_INFINITY) {
+			const headSeq = ensureSeqAtPath(head, it.path, newDot());
+			const prev = it.index === 0 ? HEAD : rgaPrevForInsertAtIndex(headSeq, Number.MAX_SAFE_INTEGER);
+			const d = nextInsertDotForPrev(headSeq, prev, newDot, bumpCounterAbove);
+			rgaInsertAfter(headSeq, prev, dotToElemId(d), d, nodeFromJson(it.value, newDot));
+			return null;
+		}
+		return {
+			ok: false,
+			code: 409,
+			message: `base array missing at /${it.path.join("/")}`
+		};
+	}
+	const headSeq = ensureSeqAtPath(head, it.path, newDot());
+	const idx = it.index === Number.POSITIVE_INFINITY ? rgaLinearizeIds(baseSeq).length : it.index;
+	const baseLen = rgaLinearizeIds(baseSeq).length;
+	if (idx < 0 || idx > baseLen) return {
+		ok: false,
+		code: 409,
+		message: `index out of bounds at /${it.path.join("/")}/${it.index}`
+	};
+	const prev = idx === 0 ? HEAD : rgaIdAtIndex(baseSeq, idx - 1) ?? HEAD;
+	const d = nextInsertDotForPrev(headSeq, prev, newDot, bumpCounterAbove);
+	rgaInsertAfter(headSeq, prev, dotToElemId(d), d, nodeFromJson(it.value, newDot));
+	return null;
+}
+function nextInsertDotForPrev(seq, prev, newDot, bumpCounterAbove) {
+	let maxSiblingDot = null;
+	for (const elem of seq.elems.values()) {
+		if (elem.prev !== prev) continue;
+		if (!maxSiblingDot || compareDot(elem.insDot, maxSiblingDot) > 0) maxSiblingDot = elem.insDot;
+	}
+	if (maxSiblingDot) bumpCounterAbove?.(maxSiblingDot.ctr);
+	let candidate = newDot();
+	while (maxSiblingDot && compareDot(candidate, maxSiblingDot) <= 0) candidate = newDot();
+	return candidate;
+}
+function applyArrDelete(base, head, it, newDot) {
+	const d = newDot();
+	const baseSeq = getSeqAtPath(base, it.path);
+	if (!baseSeq) return {
+		ok: false,
+		code: 409,
+		message: `base array missing at /${it.path.join("/")}`
+	};
+	const headSeq = ensureSeqAtPath(head, it.path, d);
+	const baseId = rgaIdAtIndex(baseSeq, it.index);
+	if (!baseId) return {
+		ok: false,
+		code: 409,
+		message: `no base element at index ${it.index}`
+	};
+	rgaDelete(headSeq, baseId);
+	return null;
+}
+function applyArrReplace(base, head, it, newDot) {
+	const d = newDot();
+	const baseSeq = getSeqAtPath(base, it.path);
+	if (!baseSeq) return {
+		ok: false,
+		code: 409,
+		message: `base array missing at /${it.path.join("/")}`
+	};
+	const headSeq = ensureSeqAtPath(head, it.path, d);
+	const baseId = rgaIdAtIndex(baseSeq, it.index);
+	if (!baseId) return {
+		ok: false,
+		code: 409,
+		message: `no base element at index ${it.index}`
+	};
+	const e = headSeq.elems.get(baseId);
+	if (!e || e.tombstone) return {
+		ok: false,
+		code: 409,
+		message: `element already deleted at index ${it.index}`
+	};
+	e.value = nodeFromJson(it.value, newDot);
+	return null;
+}
+/**
+* Apply compiled intent operations to a CRDT document.
+* Array indices are resolved against the base document.
+* @param base - The base document snapshot used for index mapping and test evaluation.
+* @param head - The target document to mutate.
+* @param intents - Compiled intent operations from `compileJsonPatchToIntent`.
+* @param newDot - A function that generates a unique `Dot` per mutation.
+* @param evalTestAgainst - Whether `test` ops are evaluated against `"head"` or `"base"`.
+* @param bumpCounterAbove - Optional hook that can fast-forward the underlying counter before inserts.
+* @returns `{ ok: true }` on success, or `{ ok: false, code: 409, message }` on conflict.
+*/
+function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head", bumpCounterAbove) {
+	for (const it of intents) {
+		let fail = null;
+		switch (it.t) {
+			case "Test":
+				fail = applyTest(base, head, it, evalTestAgainst);
+				break;
+			case "ObjSet":
+				fail = applyObjSet(head, it, newDot);
+				break;
+			case "ObjRemove":
+				fail = applyObjRemove(head, it, newDot);
+				break;
+			case "ArrInsert":
+				fail = applyArrInsert(base, head, it, newDot, bumpCounterAbove);
+				break;
+			case "ArrDelete":
+				fail = applyArrDelete(base, head, it, newDot);
+				break;
+			case "ArrReplace":
+				fail = applyArrReplace(base, head, it, newDot);
+				break;
+			default: assertNever(it, "Unhandled intent type");
+		}
+		if (fail) return fail;
+	}
+	return { ok: true };
+}
+/**
+* Convenience wrapper: compile a JSON Patch and apply it to a CRDT document.
+* @param base - The base document for index resolution.
+* @param head - The target document to mutate.
+* @param patch - Array of RFC 6902 JSON Patch operations.
+* @param newDot - A function that generates a unique `Dot` per mutation.
+* @param evalTestAgainst - Whether `test` ops evaluate against `"head"` or `"base"`.
+* @param bumpCounterAbove - Optional hook that can fast-forward the underlying counter before inserts.
+* @returns `{ ok: true }` on success, or `{ ok: false, code: 409, message }` on conflict.
+*/
+function jsonPatchToCrdt(base, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove) {
+	return applyIntentsToCrdt(base, head, compileJsonPatchToIntent(materialize(base.root), patch), newDot, evalTestAgainst, bumpCounterAbove);
+}
+/**
+* Safe wrapper around `jsonPatchToCrdt` that converts compile-time errors into `409` results.
+* This function never throws for malformed/invalid patch paths.
+*/
+function jsonPatchToCrdtSafe(base, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove) {
+	try {
+		return jsonPatchToCrdt(base, head, patch, newDot, evalTestAgainst, bumpCounterAbove);
+	} catch (error) {
+		return {
+			ok: false,
+			code: 409,
+			message: error instanceof Error ? error.message : "failed to compile patch"
+		};
+	}
+}
+/**
+* Generate a JSON Patch delta between two CRDT documents.
+* @param base - The base document snapshot.
+* @param head - The current document state.
+* @param options - Diff options (e.g. `{ arrayStrategy: "lcs" }`).
+* @returns An array of JSON Patch operations that transform base into head.
+*/
+function crdtToJsonPatch(base, head, options) {
+	return diffJsonPatch(materialize(base.root), materialize(head.root), options);
+}
+/**
+* Emit a single root `replace` patch representing the full document state.
+* Use `crdtToJsonPatch(base, head)` for delta patches instead.
+*/
+function crdtToFullReplace(doc) {
+	return [{
+		op: "replace",
+		path: "",
+		value: materialize(doc.root)
+	}];
+}
+function assertNever(_value, message) {
+	throw new Error(message);
+}
+
+//#endregion
+//#region src/state.ts
+/** Error thrown when a JSON Patch cannot be applied. Includes a numeric `.code` (409 for conflicts). */
+var PatchError = class extends Error {
+	code;
+	constructor(message, code = 409) {
+		super(message);
+		this.name = "PatchError";
+		this.code = code;
+	}
+};
+/**
+* Create a new CRDT state from an initial JSON value.
+* @param initial - The initial JSON document.
+* @param options - Actor ID and optional starting counter.
+* @returns A new `CrdtState` containing the document and clock.
+*/
+function createState(initial, options) {
+	const clock = createClock(options.actor, options.start ?? 0);
+	return {
+		doc: docFromJson(initial, clock.next),
+		clock
+	};
+}
+/**
+* Materialize a CRDT document or state back to a plain JSON value.
+* @param target - A `Doc` or `CrdtState` to materialize.
+* @returns The JSON representation of the current document.
+*/
+function toJson(target) {
+	if ("doc" in target) return materialize(target.doc.root);
+	return materialize(target.root);
+}
+/**
+* Apply a JSON Patch to the state, returning a new immutable state.
+* Throws `PatchError` on conflict (e.g. out-of-bounds index, failed test op).
+* @param state - The current CRDT state.
+* @param patch - Array of RFC 6902 JSON Patch operations.
+* @param options - Optional base document and test evaluation mode.
+* @returns A new `CrdtState` with the patch applied.
+*/
+function applyPatch(state, patch, options = {}) {
+	const nextState = {
+		doc: cloneDoc(state.doc),
+		clock: cloneClock(state.clock)
+	};
+	const result = applyPatchInternal(nextState, patch, options);
+	if (!result.ok) throw new PatchError(result.message, result.code);
+	return nextState;
+}
+/**
+* Apply a JSON Patch to the state in place, mutating the existing state.
+* Throws `PatchError` on conflict.
+* @param state - The CRDT state to mutate.
+* @param patch - Array of RFC 6902 JSON Patch operations.
+* @param options - Optional base document and test evaluation mode.
+*/
+function applyPatchInPlace(state, patch, options = {}) {
+	if (options.atomic ?? true) {
+		const next = applyPatch(state, patch, options);
+		state.doc = next.doc;
+		state.clock = next.clock;
+		return;
+	}
+	const result = applyPatchInternal(state, patch, options);
+	if (!result.ok) throw new PatchError(result.message, result.code);
+}
+/**
+* Apply a JSON Patch as a specific actor while maintaining an external version vector.
+* Returns the updated state and a new version vector snapshot.
+*/
+function applyPatchAsActor(doc, vv, actor, patch, options = {}) {
+	const observedCtr = maxCtrInNodeForActor$1(doc.root, actor);
+	const state = applyPatch({
+		doc,
+		clock: createClock(actor, Math.max(vv[actor] ?? 0, observedCtr))
+	}, patch, options);
+	return {
+		state,
+		vv: {
+			...vv,
+			[actor]: Math.max(vv[actor] ?? 0, state.clock.ctr)
+		}
+	};
+}
+function applyPatchInternal(state, patch, options) {
+	if ((options.semantics ?? "base") === "sequential") {
+		const explicitBaseState = options.base ? {
+			doc: cloneDoc(options.base),
+			clock: createClock("__base__", 0)
+		} : null;
+		for (const op of patch) {
+			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : cloneDoc(state.doc));
+			if (!step.ok) return step;
+			if (explicitBaseState) {
+				const baseStep = applyPatchInternal(explicitBaseState, [op], {
+					semantics: "sequential",
+					testAgainst: options.testAgainst
+				});
+				if (!baseStep.ok) return baseStep;
+			}
+		}
+		return { ok: true };
+	}
+	const baseDoc = options.base ? options.base : cloneDoc(state.doc);
+	const compiled = compileIntents(materialize(baseDoc.root), patch);
+	if (!compiled.ok) return compiled;
+	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr));
+}
+function applyPatchOpSequential(state, op, options, baseDoc) {
+	const baseJson = materialize(baseDoc.root);
+	if (op.op === "move") {
+		const fromValue = getAtJson(baseJson, parseJsonPointer(op.from));
+		const removeRes = applySinglePatchOp(state, baseDoc, {
+			op: "remove",
+			path: op.from
+		}, options);
+		if (!removeRes.ok) return removeRes;
+		return applySinglePatchOp(state, cloneDoc(state.doc), {
+			op: "add",
+			path: op.path,
+			value: fromValue
+		}, options);
+	}
+	if (op.op === "copy") {
+		const fromValue = getAtJson(baseJson, parseJsonPointer(op.from));
+		return applySinglePatchOp(state, baseDoc, {
+			op: "add",
+			path: op.path,
+			value: fromValue
+		}, options);
+	}
+	return applySinglePatchOp(state, baseDoc, op, options);
+}
+function applySinglePatchOp(state, baseDoc, op, options) {
+	const compiled = compileIntents(materialize(baseDoc.root), [op]);
+	if (!compiled.ok) return compiled;
+	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr));
+}
+function bumpClockCounter(state, ctr) {
+	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
+}
+function compileIntents(baseJson, patch) {
+	try {
+		return {
+			ok: true,
+			intents: compileJsonPatchToIntent(baseJson, patch)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			code: 409,
+			message: error instanceof Error ? error.message : "failed to compile patch"
+		};
+	}
+}
+function maxCtrInNodeForActor$1(node, actor) {
+	switch (node.kind) {
+		case "lww": return node.dot.actor === actor ? node.dot.ctr : 0;
+		case "obj": {
+			let best = 0;
+			for (const entry of node.entries.values()) {
+				if (entry.dot.actor === actor && entry.dot.ctr > best) best = entry.dot.ctr;
+				const childBest = maxCtrInNodeForActor$1(entry.node, actor);
+				if (childBest > best) best = childBest;
+			}
+			for (const tomb of node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
+			return best;
+		}
+		case "seq": {
+			let best = 0;
+			for (const elem of node.elems.values()) {
+				if (elem.insDot.actor === actor && elem.insDot.ctr > best) best = elem.insDot.ctr;
+				const childBest = maxCtrInNodeForActor$1(elem.value, actor);
+				if (childBest > best) best = childBest;
+			}
+			return best;
+		}
+	}
+}
+
+//#endregion
+//#region src/serialize.ts
+/** Serialize a CRDT document to a JSON-safe representation (Maps become plain objects). */
+function serializeDoc(doc) {
+	return { root: serializeNode(doc.root) };
+}
+/** Reconstruct a CRDT document from its serialized form. */
+function deserializeDoc(data) {
+	return { root: deserializeNode(data.root) };
+}
+/** Serialize a full CRDT state (document + clock) to a JSON-safe representation. */
+function serializeState(state) {
+	return {
+		doc: serializeDoc(state.doc),
+		clock: {
+			actor: state.clock.actor,
+			ctr: state.clock.ctr
+		}
+	};
+}
+/** Reconstruct a full CRDT state from its serialized form, restoring the clock. */
+function deserializeState(data) {
+	const clock = createClock(data.clock.actor, data.clock.ctr);
+	return {
+		doc: deserializeDoc(data.doc),
+		clock
+	};
+}
+function serializeNode(node) {
+	if (node.kind === "lww") return {
+		kind: "lww",
+		value: structuredClone(node.value),
+		dot: {
+			actor: node.dot.actor,
+			ctr: node.dot.ctr
+		}
+	};
+	if (node.kind === "obj") {
+		const entries = {};
+		for (const [k, v] of node.entries.entries()) entries[k] = {
+			node: serializeNode(v.node),
+			dot: {
+				actor: v.dot.actor,
+				ctr: v.dot.ctr
+			}
+		};
+		const tombstone = {};
+		for (const [k, d] of node.tombstone.entries()) tombstone[k] = {
+			actor: d.actor,
+			ctr: d.ctr
+		};
+		return {
+			kind: "obj",
+			entries,
+			tombstone
+		};
+	}
+	const elems = {};
+	for (const [id, e] of node.elems.entries()) elems[id] = {
+		id: e.id,
+		prev: e.prev,
+		tombstone: e.tombstone,
+		value: serializeNode(e.value),
+		insDot: {
+			actor: e.insDot.actor,
+			ctr: e.insDot.ctr
+		}
+	};
+	return {
+		kind: "seq",
+		elems
+	};
+}
+function deserializeNode(node) {
+	if (node.kind === "lww") return {
+		kind: "lww",
+		value: structuredClone(node.value),
+		dot: {
+			actor: node.dot.actor,
+			ctr: node.dot.ctr
+		}
+	};
+	if (node.kind === "obj") {
+		const entries = /* @__PURE__ */ new Map();
+		for (const [k, v] of Object.entries(node.entries)) entries.set(k, {
+			node: deserializeNode(v.node),
+			dot: {
+				actor: v.dot.actor,
+				ctr: v.dot.ctr
+			}
+		});
+		const tombstone = /* @__PURE__ */ new Map();
+		for (const [k, d] of Object.entries(node.tombstone)) tombstone.set(k, {
+			actor: d.actor,
+			ctr: d.ctr
+		});
+		return {
+			kind: "obj",
+			entries,
+			tombstone
+		};
+	}
+	const elems = /* @__PURE__ */ new Map();
+	for (const [id, e] of Object.entries(node.elems)) elems.set(id, {
+		id: e.id,
+		prev: e.prev,
+		tombstone: e.tombstone,
+		value: deserializeNode(e.value),
+		insDot: {
+			actor: e.insDot.actor,
+			ctr: e.insDot.ctr
+		}
+	});
+	return {
+		kind: "seq",
+		elems
+	};
+}
+
+//#endregion
+//#region src/merge.ts
+/**
+* Merge two CRDT documents from different peers into one.
+* By default this requires shared array lineage for non-empty sequences.
+*
+* Resolution rules:
+* - **LwwReg**: the register with the higher dot wins (total order by counter then actor).
+* - **ObjNode**: entries are merged key-by-key; tombstones use max-dot-per-key.
+*   If both sides have a live entry for the same key, the entry nodes are merged recursively.
+*   Delete-wins: if a tombstone dot >= an entry dot, the entry is removed.
+* - **RgaSeq**: elements from both sides are unioned by element ID.
+*   If both sides have the same element, tombstone wins (delete bias) and values are merged recursively.
+* - **Kind mismatch**: the node with the higher "representative dot" wins and replaces the other entirely.
+*/
+function mergeDoc(a, b, options = {}) {
+	const mismatchPath = options.requireSharedOrigin ?? true ? findSeqLineageMismatch(a.root, b.root, []) : null;
+	if (mismatchPath) throw new Error(`merge requires shared array origin at ${mismatchPath}`);
+	return { root: mergeNode(a.root, b.root) };
+}
+/**
+* Merge two CRDT states.
+*
+* The merged clock keeps a stable actor identity:
+* - defaults to the actor from the first argument (`a`)
+* - can be overridden via `options.actor`
+* - optional `options.requireSharedOrigin` controls merge lineage checks
+*
+* The merged counter is lifted to the highest counter already observed for
+* that actor across both input clocks and the merged document dots.
+*/
+function mergeState(a, b, options = {}) {
+	const doc = mergeDoc(a.doc, b.doc, { requireSharedOrigin: options.requireSharedOrigin });
+	const actor = options.actor ?? a.clock.actor;
+	return {
+		doc,
+		clock: createClock(actor, maxObservedCtrForActor(doc, actor, a, b))
+	};
+}
+function findSeqLineageMismatch(a, b, path) {
+	if (a.kind === "seq" && b.kind === "seq") {
+		const hasElemsA = a.elems.size > 0;
+		const hasElemsB = b.elems.size > 0;
+		if (hasElemsA && hasElemsB) {
+			let shared = false;
+			for (const id of a.elems.keys()) if (b.elems.has(id)) {
+				shared = true;
+				break;
+			}
+			if (!shared) return `/${path.join("/")}`;
+		}
+	}
+	if (a.kind === "obj" && b.kind === "obj") {
+		const sharedKeys = new Set([...a.entries.keys()].filter((key) => b.entries.has(key)));
+		for (const key of sharedKeys) {
+			const nextA = a.entries.get(key).node;
+			const nextB = b.entries.get(key).node;
+			const mismatch = findSeqLineageMismatch(nextA, nextB, [...path, key]);
+			if (mismatch) return mismatch;
+		}
+	}
+	return null;
+}
+function maxObservedCtrForActor(doc, actor, a, b) {
+	let best = maxCtrInNodeForActor(doc.root, actor);
+	if (a.clock.actor === actor && a.clock.ctr > best) best = a.clock.ctr;
+	if (b.clock.actor === actor && b.clock.ctr > best) best = b.clock.ctr;
+	return best;
+}
+function maxCtrInNodeForActor(node, actor) {
+	switch (node.kind) {
+		case "lww": return node.dot.actor === actor ? node.dot.ctr : 0;
+		case "obj": {
+			let best = 0;
+			for (const entry of node.entries.values()) {
+				if (entry.dot.actor === actor && entry.dot.ctr > best) best = entry.dot.ctr;
+				const childBest = maxCtrInNodeForActor(entry.node, actor);
+				if (childBest > best) best = childBest;
+			}
+			for (const tomb of node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
+			return best;
+		}
+		case "seq": {
+			let best = 0;
+			for (const elem of node.elems.values()) {
+				if (elem.insDot.actor === actor && elem.insDot.ctr > best) best = elem.insDot.ctr;
+				const childBest = maxCtrInNodeForActor(elem.value, actor);
+				if (childBest > best) best = childBest;
+			}
+			return best;
+		}
+	}
+}
+function repDot(node) {
+	switch (node.kind) {
+		case "lww": return node.dot;
+		case "obj": {
+			let best = {
+				actor: "",
+				ctr: 0
+			};
+			for (const entry of node.entries.values()) if (compareDot(entry.dot, best) > 0) best = entry.dot;
+			for (const d of node.tombstone.values()) if (compareDot(d, best) > 0) best = d;
+			return best;
+		}
+		case "seq": {
+			let best = {
+				actor: "",
+				ctr: 0
+			};
+			for (const e of node.elems.values()) if (compareDot(e.insDot, best) > 0) best = e.insDot;
+			return best;
+		}
+	}
+}
+function mergeNode(a, b) {
+	if (a.kind === "lww" && b.kind === "lww") return mergeLww(a, b);
+	if (a.kind === "obj" && b.kind === "obj") return mergeObj(a, b);
+	if (a.kind === "seq" && b.kind === "seq") return mergeSeq(a, b);
+	if (compareDot(repDot(a), repDot(b)) >= 0) return cloneNodeShallow(a);
+	return cloneNodeShallow(b);
+}
+function mergeLww(a, b) {
+	if (compareDot(a.dot, b.dot) >= 0) return {
+		kind: "lww",
+		value: structuredClone(a.value),
+		dot: { ...a.dot }
+	};
+	return {
+		kind: "lww",
+		value: structuredClone(b.value),
+		dot: { ...b.dot }
+	};
+}
+function mergeObj(a, b) {
+	const entries = /* @__PURE__ */ new Map();
+	const tombstone = /* @__PURE__ */ new Map();
+	const allTombKeys = new Set([...a.tombstone.keys(), ...b.tombstone.keys()]);
+	for (const key of allTombKeys) {
+		const da = a.tombstone.get(key);
+		const db = b.tombstone.get(key);
+		if (da && db) tombstone.set(key, compareDot(da, db) >= 0 ? { ...da } : { ...db });
+		else if (da) tombstone.set(key, { ...da });
+		else tombstone.set(key, { ...db });
+	}
+	const allKeys = new Set([...a.entries.keys(), ...b.entries.keys()]);
+	for (const key of allKeys) {
+		const ea = a.entries.get(key);
+		const eb = b.entries.get(key);
+		let merged;
+		if (ea && eb) merged = {
+			node: mergeNode(ea.node, eb.node),
+			dot: compareDot(ea.dot, eb.dot) >= 0 ? { ...ea.dot } : { ...eb.dot }
+		};
+		else if (ea) merged = {
+			node: cloneNodeShallow(ea.node),
+			dot: { ...ea.dot }
+		};
+		else merged = {
+			node: cloneNodeShallow(eb.node),
+			dot: { ...eb.dot }
+		};
+		const td = tombstone.get(key);
+		if (td && compareDot(td, merged.dot) >= 0) continue;
+		entries.set(key, merged);
+	}
+	return {
+		kind: "obj",
+		entries,
+		tombstone
+	};
+}
+function mergeSeq(a, b) {
+	const elems = /* @__PURE__ */ new Map();
+	const allIds = new Set([...a.elems.keys(), ...b.elems.keys()]);
+	for (const id of allIds) {
+		const ea = a.elems.get(id);
+		const eb = b.elems.get(id);
+		if (ea && eb) {
+			const mergedValue = mergeNode(ea.value, eb.value);
+			elems.set(id, {
+				id,
+				prev: ea.prev,
+				tombstone: ea.tombstone || eb.tombstone,
+				value: mergedValue,
+				insDot: { ...ea.insDot }
+			});
+		} else if (ea) elems.set(id, cloneElem(ea));
+		else elems.set(id, cloneElem(eb));
+	}
+	return {
+		kind: "seq",
+		elems
+	};
+}
+function cloneElem(e) {
+	return {
+		id: e.id,
+		prev: e.prev,
+		tombstone: e.tombstone,
+		value: cloneNodeShallow(e.value),
+		insDot: { ...e.insDot }
+	};
+}
+function cloneNodeShallow(node) {
+	switch (node.kind) {
+		case "lww": return {
+			kind: "lww",
+			value: structuredClone(node.value),
+			dot: { ...node.dot }
+		};
+		case "obj": {
+			const entries = /* @__PURE__ */ new Map();
+			for (const [k, v] of node.entries) entries.set(k, {
+				node: cloneNodeShallow(v.node),
+				dot: { ...v.dot }
+			});
+			const tombstone = /* @__PURE__ */ new Map();
+			for (const [k, d] of node.tombstone) tombstone.set(k, { ...d });
+			return {
+				kind: "obj",
+				entries,
+				tombstone
+			};
+		}
+		case "seq": {
+			const elems = /* @__PURE__ */ new Map();
+			for (const [id, e] of node.elems) elems.set(id, cloneElem(e));
+			return {
+				kind: "seq",
+				elems
+			};
+		}
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'HEAD', {
+  enumerable: true,
+  get: function () {
+    return HEAD;
+  }
+});
+Object.defineProperty(exports, 'PatchError', {
+  enumerable: true,
+  get: function () {
+    return PatchError;
+  }
+});
+Object.defineProperty(exports, 'ROOT_KEY', {
+  enumerable: true,
+  get: function () {
+    return ROOT_KEY;
+  }
+});
+Object.defineProperty(exports, 'applyIntentsToCrdt', {
+  enumerable: true,
+  get: function () {
+    return applyIntentsToCrdt;
+  }
+});
+Object.defineProperty(exports, 'applyPatch', {
+  enumerable: true,
+  get: function () {
+    return applyPatch;
+  }
+});
+Object.defineProperty(exports, 'applyPatchAsActor', {
+  enumerable: true,
+  get: function () {
+    return applyPatchAsActor;
+  }
+});
+Object.defineProperty(exports, 'applyPatchInPlace', {
+  enumerable: true,
+  get: function () {
+    return applyPatchInPlace;
+  }
+});
+Object.defineProperty(exports, 'cloneClock', {
+  enumerable: true,
+  get: function () {
+    return cloneClock;
+  }
+});
+Object.defineProperty(exports, 'cloneDoc', {
+  enumerable: true,
+  get: function () {
+    return cloneDoc;
+  }
+});
+Object.defineProperty(exports, 'compareDot', {
+  enumerable: true,
+  get: function () {
+    return compareDot;
+  }
+});
+Object.defineProperty(exports, 'compileJsonPatchToIntent', {
+  enumerable: true,
+  get: function () {
+    return compileJsonPatchToIntent;
+  }
+});
+Object.defineProperty(exports, 'crdtToFullReplace', {
+  enumerable: true,
+  get: function () {
+    return crdtToFullReplace;
+  }
+});
+Object.defineProperty(exports, 'crdtToJsonPatch', {
+  enumerable: true,
+  get: function () {
+    return crdtToJsonPatch;
+  }
+});
+Object.defineProperty(exports, 'createClock', {
+  enumerable: true,
+  get: function () {
+    return createClock;
+  }
+});
+Object.defineProperty(exports, 'createState', {
+  enumerable: true,
+  get: function () {
+    return createState;
+  }
+});
+Object.defineProperty(exports, 'deserializeDoc', {
+  enumerable: true,
+  get: function () {
+    return deserializeDoc;
+  }
+});
+Object.defineProperty(exports, 'deserializeState', {
+  enumerable: true,
+  get: function () {
+    return deserializeState;
+  }
+});
+Object.defineProperty(exports, 'diffJsonPatch', {
+  enumerable: true,
+  get: function () {
+    return diffJsonPatch;
+  }
+});
+Object.defineProperty(exports, 'docFromJson', {
+  enumerable: true,
+  get: function () {
+    return docFromJson;
+  }
+});
+Object.defineProperty(exports, 'docFromJsonWithDot', {
+  enumerable: true,
+  get: function () {
+    return docFromJsonWithDot;
+  }
+});
+Object.defineProperty(exports, 'dotToElemId', {
+  enumerable: true,
+  get: function () {
+    return dotToElemId;
+  }
+});
+Object.defineProperty(exports, 'getAtJson', {
+  enumerable: true,
+  get: function () {
+    return getAtJson;
+  }
+});
+Object.defineProperty(exports, 'jsonEquals', {
+  enumerable: true,
+  get: function () {
+    return jsonEquals;
+  }
+});
+Object.defineProperty(exports, 'jsonPatchToCrdt', {
+  enumerable: true,
+  get: function () {
+    return jsonPatchToCrdt;
+  }
+});
+Object.defineProperty(exports, 'jsonPatchToCrdtSafe', {
+  enumerable: true,
+  get: function () {
+    return jsonPatchToCrdtSafe;
+  }
+});
+Object.defineProperty(exports, 'lwwSet', {
+  enumerable: true,
+  get: function () {
+    return lwwSet;
+  }
+});
+Object.defineProperty(exports, 'materialize', {
+  enumerable: true,
+  get: function () {
+    return materialize;
+  }
+});
+Object.defineProperty(exports, 'mergeDoc', {
+  enumerable: true,
+  get: function () {
+    return mergeDoc;
+  }
+});
+Object.defineProperty(exports, 'mergeState', {
+  enumerable: true,
+  get: function () {
+    return mergeState;
+  }
+});
+Object.defineProperty(exports, 'newObj', {
+  enumerable: true,
+  get: function () {
+    return newObj;
+  }
+});
+Object.defineProperty(exports, 'newReg', {
+  enumerable: true,
+  get: function () {
+    return newReg;
+  }
+});
+Object.defineProperty(exports, 'newSeq', {
+  enumerable: true,
+  get: function () {
+    return newSeq;
+  }
+});
+Object.defineProperty(exports, 'nextDotForActor', {
+  enumerable: true,
+  get: function () {
+    return nextDotForActor;
+  }
+});
+Object.defineProperty(exports, 'objRemove', {
+  enumerable: true,
+  get: function () {
+    return objRemove;
+  }
+});
+Object.defineProperty(exports, 'objSet', {
+  enumerable: true,
+  get: function () {
+    return objSet;
+  }
+});
+Object.defineProperty(exports, 'observeDot', {
+  enumerable: true,
+  get: function () {
+    return observeDot;
+  }
+});
+Object.defineProperty(exports, 'parseJsonPointer', {
+  enumerable: true,
+  get: function () {
+    return parseJsonPointer;
+  }
+});
+Object.defineProperty(exports, 'rgaDelete', {
+  enumerable: true,
+  get: function () {
+    return rgaDelete;
+  }
+});
+Object.defineProperty(exports, 'rgaIdAtIndex', {
+  enumerable: true,
+  get: function () {
+    return rgaIdAtIndex;
+  }
+});
+Object.defineProperty(exports, 'rgaInsertAfter', {
+  enumerable: true,
+  get: function () {
+    return rgaInsertAfter;
+  }
+});
+Object.defineProperty(exports, 'rgaLinearizeIds', {
+  enumerable: true,
+  get: function () {
+    return rgaLinearizeIds;
+  }
+});
+Object.defineProperty(exports, 'rgaPrevForInsertAtIndex', {
+  enumerable: true,
+  get: function () {
+    return rgaPrevForInsertAtIndex;
+  }
+});
+Object.defineProperty(exports, 'serializeDoc', {
+  enumerable: true,
+  get: function () {
+    return serializeDoc;
+  }
+});
+Object.defineProperty(exports, 'serializeState', {
+  enumerable: true,
+  get: function () {
+    return serializeState;
+  }
+});
+Object.defineProperty(exports, 'stringifyJsonPointer', {
+  enumerable: true,
+  get: function () {
+    return stringifyJsonPointer;
+  }
+});
+Object.defineProperty(exports, 'toJson', {
+  enumerable: true,
+  get: function () {
+    return toJson;
+  }
+});
+Object.defineProperty(exports, 'vvHasDot', {
+  enumerable: true,
+  get: function () {
+    return vvHasDot;
+  }
+});
+Object.defineProperty(exports, 'vvMerge', {
+  enumerable: true,
+  get: function () {
+    return vvMerge;
+  }
+});