json-patch-to-crdt 0.0.0

package/dist/merge-DikOFBWc.mjs

@@ -0,0 +1,1435 @@
+//#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
+export { newReg as A, rgaPrevForInsertAtIndex as B, getAtJson as C, ROOT_KEY as D, stringifyJsonPointer as E, HEAD as F, cloneClock as G, dotToElemId as H, rgaDelete as I, observeDot as J, createClock as K, rgaIdAtIndex as L, objRemove as M, objSet as N, lwwSet as O, materialize as P, rgaInsertAfter as R, diffJsonPatch as S, parseJsonPointer as T, vvHasDot as U, compareDot as V, vvMerge as W, docFromJson as _, serializeDoc as a, jsonPatchToCrdtSafe as b, applyPatch as c, createState as d, toJson as f, crdtToJsonPatch as g, crdtToFullReplace as h, deserializeState as i, newSeq as j, newObj as k, applyPatchAsActor as l, cloneDoc as m, mergeState as n, serializeState as o, applyIntentsToCrdt as p, nextDotForActor as q, deserializeDoc as r, PatchError as s, mergeDoc as t, applyPatchInPlace as u, docFromJsonWithDot as v, jsonEquals as w, compileJsonPatchToIntent as x, jsonPatchToCrdt as y, rgaLinearizeIds as z };