json-patch-to-crdt 0.1.1 → 0.1.2

package/dist/{merge-CKcP1ZPt.mjs → compact-BJBGW9tC.mjs}

@@ -39,6 +39,33 @@ function observeDot(vv, dot) {
 	if ((vv[dot.actor] ?? 0) < dot.ctr) vv[dot.actor] = dot.ctr;
 }
 
+//#endregion
+//#region src/depth.ts
+const MAX_TRAVERSAL_DEPTH = 16384;
+var TraversalDepthError = class extends Error {
+	code = 409;
+	reason = "MAX_DEPTH_EXCEEDED";
+	depth;
+	maxDepth;
+	constructor(depth, maxDepth = MAX_TRAVERSAL_DEPTH) {
+		super(`maximum nesting depth ${maxDepth} exceeded at depth ${depth}`);
+		this.name = "TraversalDepthError";
+		this.depth = depth;
+		this.maxDepth = maxDepth;
+	}
+};
+function assertTraversalDepth(depth, maxDepth = MAX_TRAVERSAL_DEPTH) {
+	if (depth > maxDepth) throw new TraversalDepthError(depth, maxDepth);
+}
+function toDepthApplyError(error) {
+	return {
+		ok: false,
+		code: error.code,
+		reason: error.reason,
+		message: error.message
+	};
+}
+
 //#endregion
 //#region src/dot.ts
 function compareDot(a, b) {
@@ -84,15 +111,26 @@ function rgaLinearizeIds(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);
+	const stack = [];
+	const rootChildren = idx.get(HEAD);
+	if (rootChildren) stack.push({
+		children: rootChildren,
+		index: 0
+	});
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		if (frame.index >= frame.children.length) {
+			stack.pop();
+			continue;
 		}
+		const child = frame.children[frame.index++];
+		if (!child.tombstone) out.push(child.id);
+		const grandchildren = idx.get(child.id);
+		if (grandchildren) stack.push({
+			children: grandchildren,
+			index: 0
+		});
 	}
-	walk(HEAD);
 	linearCache.set(seq, {
 		version: ver,
 		ids: out
@@ -117,6 +155,61 @@ function rgaDelete(seq, id) {
 	e.tombstone = true;
 	bumpVersion(seq);
 }
+/**
+* Prune tombstoned elements that are causally stable and have no live descendants
+* depending on them for sequence traversal.
+*
+* Returns the number of removed elements.
+*/
+function rgaCompactTombstones(seq, isStable) {
+	if (seq.elems.size === 0) return 0;
+	const children = /* @__PURE__ */ new Map();
+	const roots = [];
+	for (const elem of seq.elems.values()) {
+		const byPrev = children.get(elem.prev);
+		if (byPrev) byPrev.push(elem.id);
+		else children.set(elem.prev, [elem.id]);
+		if (elem.prev === HEAD || !seq.elems.has(elem.prev)) roots.push(elem.id);
+	}
+	const removable = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const stack = [];
+	const pushRoot = (id) => {
+		if (!visited.has(id)) stack.push({
+			id,
+			expanded: false
+		});
+	};
+	for (const id of roots) pushRoot(id);
+	for (const id of seq.elems.keys()) pushRoot(id);
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		if (!frame.expanded) {
+			if (visited.has(frame.id)) continue;
+			visited.add(frame.id);
+			stack.push({
+				id: frame.id,
+				expanded: true
+			});
+			const childIds = children.get(frame.id);
+			if (childIds) {
+				for (const childId of childIds) if (!visited.has(childId)) stack.push({
+					id: childId,
+					expanded: false
+				});
+			}
+			continue;
+		}
+		const elem = seq.elems.get(frame.id);
+		if (!elem || !elem.tombstone || !isStable(elem.insDot)) continue;
+		const childIds = children.get(frame.id);
+		if (!childIds || childIds.every((childId) => removable.has(childId))) removable.add(frame.id);
+	}
+	if (removable.size === 0) return 0;
+	for (const id of removable) seq.elems.delete(id);
+	bumpVersion(seq);
+	return removable.size;
+}
 function rgaIdAtIndex(seq, index) {
 	return rgaLinearizeIds(seq)[index];
 }
@@ -128,17 +221,100 @@ function rgaPrevForInsertAtIndex(seq, index) {
 
 //#endregion
 //#region src/materialize.ts
-/** Recursively convert a CRDT node graph into a plain JSON value. */
+/** Convert a CRDT node graph into a plain JSON value using an explicit stack. */
 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;
+	if (node.kind === "lww") return node.value;
+	const root = node.kind === "obj" ? {} : [];
+	const stack = [];
+	if (node.kind === "obj") stack.push({
+		kind: "obj",
+		depth: 0,
+		entries: Array.from(node.entries.entries(), ([key, value]) => [key, value.node]),
+		index: 0,
+		out: root
+	});
+	else stack.push({
+		kind: "seq",
+		depth: 0,
+		ids: rgaLinearizeIds(node),
+		index: 0,
+		seq: node,
+		out: root
+	});
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		if (frame.kind === "obj") {
+			if (frame.index >= frame.entries.length) {
+				stack.pop();
+				continue;
+			}
+			const [key, child] = frame.entries[frame.index++];
+			const childDepth = frame.depth + 1;
+			assertTraversalDepth(childDepth);
+			if (child.kind === "lww") {
+				frame.out[key] = child.value;
+				continue;
+			}
+			if (child.kind === "obj") {
+				const outObj = {};
+				frame.out[key] = outObj;
+				stack.push({
+					kind: "obj",
+					depth: childDepth,
+					entries: Array.from(child.entries.entries(), ([childKey, value]) => [childKey, value.node]),
+					index: 0,
+					out: outObj
+				});
+				continue;
+			}
+			const outArr = [];
+			frame.out[key] = outArr;
+			stack.push({
+				kind: "seq",
+				depth: childDepth,
+				ids: rgaLinearizeIds(child),
+				index: 0,
+				seq: child,
+				out: outArr
+			});
+			continue;
+		}
+		if (frame.index >= frame.ids.length) {
+			stack.pop();
+			continue;
+		}
+		const id = frame.ids[frame.index++];
+		const child = frame.seq.elems.get(id).value;
+		const childDepth = frame.depth + 1;
+		assertTraversalDepth(childDepth);
+		if (child.kind === "lww") {
+			frame.out.push(child.value);
+			continue;
+		}
+		if (child.kind === "obj") {
+			const outObj = {};
+			frame.out.push(outObj);
+			stack.push({
+				kind: "obj",
+				depth: childDepth,
+				entries: Array.from(child.entries.entries(), ([key, value]) => [key, value.node]),
+				index: 0,
+				out: outObj
+			});
+			continue;
 		}
-		case "seq": return rgaLinearizeIds(node).map((id) => materialize(node.elems.get(id).value));
+		const outArr = [];
+		frame.out.push(outArr);
+		stack.push({
+			kind: "seq",
+			depth: childDepth,
+			ids: rgaLinearizeIds(child),
+			index: 0,
+			seq: child,
+			out: outArr
+		});
 	}
+	return root;
 }
 
 //#endregion
@@ -183,6 +359,19 @@ function objRemove(obj, key, dot) {
 	if (!curDel || compareDot(curDel, dot) <= 0) obj.tombstone.set(key, dot);
 	obj.entries.delete(key);
 }
+/**
+* Prune object tombstones that satisfy a caller-provided stability predicate.
+* Returns the number of removed tombstone records.
+*/
+function objCompactTombstones(obj, isStable) {
+	let removed = 0;
+	for (const [key, dot] of obj.tombstone.entries()) {
+		if (!isStable(dot)) continue;
+		obj.tombstone.delete(key);
+		removed += 1;
+	}
+	return removed;
+}
 
 //#endregion
 //#region src/types.ts
@@ -194,6 +383,7 @@ const ROOT_KEY = "@@crdt/root";
 
 //#endregion
 //#region src/patch.ts
+const DEFAULT_LCS_MAX_CELLS = 25e4;
 /** Structured compile error used to map patch validation failures to typed reasons. */
 var PatchCompileError = class extends Error {
 	reason;
@@ -207,6 +397,17 @@ var PatchCompileError = class extends Error {
 		this.opIndex = opIndex;
 	}
 };
+/** Structured lookup error thrown by `getAtJson`. */
+var JsonLookupError = class extends Error {
+	code;
+	segment;
+	constructor(code, segment, message) {
+		super(message);
+		this.name = "JsonLookupError";
+		this.code = code;
+		this.segment = segment;
+	}
+};
 /**
 * 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 `""`).
@@ -253,14 +454,14 @@ function unescapeJsonPointerToken(token) {
 function getAtJson(base, path) {
 	let cur = base;
 	for (const seg of path) if (Array.isArray(cur)) {
-		if (!ARRAY_INDEX_TOKEN_PATTERN.test(seg)) throw new Error(`Expected array index, got ${seg}`);
+		if (!ARRAY_INDEX_TOKEN_PATTERN.test(seg)) throw new JsonLookupError("EXPECTED_ARRAY_INDEX", seg, `Expected array index, got '${seg}'`);
 		const idx = Number(seg);
-		if (idx < 0 || idx >= cur.length) throw new Error(`Index out of bounds at ${seg}`);
+		if (idx < 0 || idx >= cur.length) throw new JsonLookupError("INDEX_OUT_OF_BOUNDS", seg, `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}`);
+		if (!(seg in cur)) throw new JsonLookupError("MISSING_KEY", seg, `Missing key '${seg}'`);
 		cur = cur[seg];
-	} else throw new Error(`Cannot traverse into non-container at ${seg}`);
+	} else throw new JsonLookupError("NON_CONTAINER", seg, `Cannot traverse into non-container at '${seg}'`);
 	return cur;
 }
 /**
@@ -301,7 +502,15 @@ 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);
+			if (!shouldUseLcsDiff(base.length, next.length, options.lcsMaxCells)) {
+				ops.push({
+					op: "replace",
+					path: stringifyJsonPointer(path),
+					value: next
+				});
+				return;
+			}
+			diffArray(path, base, next, ops);
 			return;
 		}
 		ops.push({
@@ -337,7 +546,7 @@ function diffValue(path, base, next, ops, options) {
 	}
 	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) {
+function diffArray(path, base, next, ops) {
 	const n = base.length;
 	const m = next.length;
 	const lcs = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
@@ -377,6 +586,12 @@ function diffArray(path, base, next, ops, _options) {
 	}
 	ops.push(...compactArrayOps(localOps));
 }
+function shouldUseLcsDiff(baseLength, nextLength, lcsMaxCells) {
+	if (lcsMaxCells === Number.POSITIVE_INFINITY) return true;
+	const cap = lcsMaxCells ?? DEFAULT_LCS_MAX_CELLS;
+	if (!Number.isFinite(cap) || cap < 1) return false;
+	return (baseLength + 1) * (nextLength + 1) <= cap;
+}
 function compactArrayOps(ops) {
 	const out = [];
 	for (let i = 0; i < ops.length; i++) {
@@ -614,26 +829,31 @@ function compileErrorFromLookup(error, path, opIndex) {
 	return compileError(mapped.reason, mapped.message, path, opIndex);
 }
 function mapLookupErrorToPatchReason(error) {
-	const message = error instanceof Error ? error.message : "invalid path";
-	if (message.includes("Expected array index")) return {
-		reason: "INVALID_POINTER",
-		message
-	};
-	if (message.includes("Index out of bounds")) return {
-		reason: "OUT_OF_BOUNDS",
-		message
-	};
-	if (message.includes("Missing key")) return {
-		reason: "MISSING_PARENT",
-		message
-	};
-	if (message.includes("Cannot traverse into non-container")) return {
-		reason: "INVALID_TARGET",
-		message
-	};
+	if (error instanceof JsonLookupError) switch (error.code) {
+		case "EXPECTED_ARRAY_INDEX": return {
+			reason: "INVALID_POINTER",
+			message: error.message
+		};
+		case "INDEX_OUT_OF_BOUNDS": return {
+			reason: "OUT_OF_BOUNDS",
+			message: error.message
+		};
+		case "MISSING_KEY": return {
+			reason: "MISSING_PARENT",
+			message: error.message
+		};
+		case "NON_CONTAINER": return {
+			reason: "INVALID_TARGET",
+			message: error.message
+		};
+		default: return {
+			reason: "INVALID_PATCH",
+			message: error.message
+		};
+	}
 	return {
 		reason: "INVALID_PATCH",
-		message
+		message: error instanceof Error ? error.message : "invalid path"
 	};
 }
 function compileError(reason, message, path, opIndex) {
@@ -751,6 +971,10 @@ function ensureSeqAtPath(head, path, dotForCreate) {
 	return head.root;
 }
 function deepNodeFromJson(value, dot) {
+	return deepNodeFromJsonWithDepth(value, dot, 0);
+}
+function deepNodeFromJsonWithDepth(value, dot, depth) {
+	assertTraversalDepth(depth);
 	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return newReg(value, dot);
 	if (Array.isArray(value)) {
 		const seq = newSeq();
@@ -762,40 +986,123 @@ function deepNodeFromJson(value, dot) {
 				ctr: ++ctr
 			};
 			const id = dotToElemId(childDot);
-			rgaInsertAfter(seq, prev, id, childDot, deepNodeFromJson(v, childDot));
+			rgaInsertAfter(seq, prev, id, childDot, deepNodeFromJsonWithDepth(v, childDot, depth + 1));
 			prev = id;
 		}
 		return seq;
 	}
 	const obj = newObj();
-	for (const [k, v] of Object.entries(value)) objSet(obj, k, deepNodeFromJson(v, dot), dot);
+	for (const [k, v] of Object.entries(value)) objSet(obj, k, deepNodeFromJsonWithDepth(v, dot, depth + 1), 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;
+	if (isJsonPrimitive(value)) return newReg(value, nextDot());
+	const root = Array.isArray(value) ? newSeq() : newObj();
+	const stack = [];
+	if (Array.isArray(value)) stack.push({
+		kind: "seq",
+		depth: 0,
+		values: value,
+		index: 0,
+		prev: HEAD,
+		target: root
+	});
+	else stack.push({
+		kind: "obj",
+		depth: 0,
+		entries: Object.entries(value),
+		index: 0,
+		target: root
+	});
+	while (stack.length > 0) {
+		const frame = stack[stack.length - 1];
+		if (frame.kind === "obj") {
+			if (frame.index >= frame.entries.length) {
+				stack.pop();
+				continue;
+			}
+			const [key, childValue] = frame.entries[frame.index++];
+			const childDepth = frame.depth + 1;
+			assertTraversalDepth(childDepth);
+			const entryDot = nextDot();
+			if (isJsonPrimitive(childValue)) {
+				objSet(frame.target, key, newReg(childValue, nextDot()), entryDot);
+				continue;
+			}
+			if (Array.isArray(childValue)) {
+				const childSeq = newSeq();
+				objSet(frame.target, key, childSeq, entryDot);
+				stack.push({
+					kind: "seq",
+					depth: childDepth,
+					values: childValue,
+					index: 0,
+					prev: HEAD,
+					target: childSeq
+				});
+				continue;
+			}
+			const childObj = newObj();
+			objSet(frame.target, key, childObj, entryDot);
+			stack.push({
+				kind: "obj",
+				depth: childDepth,
+				entries: Object.entries(childValue),
+				index: 0,
+				target: childObj
+			});
+			continue;
 		}
-		return seq;
-	}
-	const obj = newObj();
-	for (const [k, v] of Object.entries(value)) {
-		const entryDot = nextDot();
-		objSet(obj, k, nodeFromJson(v, nextDot), entryDot);
+		if (frame.index >= frame.values.length) {
+			stack.pop();
+			continue;
+		}
+		const childValue = frame.values[frame.index++];
+		const childDepth = frame.depth + 1;
+		assertTraversalDepth(childDepth);
+		const insDot = nextDot();
+		const id = dotToElemId(insDot);
+		if (isJsonPrimitive(childValue)) {
+			rgaInsertAfter(frame.target, frame.prev, id, insDot, newReg(childValue, nextDot()));
+			frame.prev = id;
+			continue;
+		}
+		if (Array.isArray(childValue)) {
+			const childSeq = newSeq();
+			rgaInsertAfter(frame.target, frame.prev, id, insDot, childSeq);
+			frame.prev = id;
+			stack.push({
+				kind: "seq",
+				depth: childDepth,
+				values: childValue,
+				index: 0,
+				prev: HEAD,
+				target: childSeq
+			});
+			continue;
+		}
+		const childObj = newObj();
+		rgaInsertAfter(frame.target, frame.prev, id, insDot, childObj);
+		frame.prev = id;
+		stack.push({
+			kind: "obj",
+			depth: childDepth,
+			entries: Object.entries(childValue),
+			index: 0,
+			target: childObj
+		});
 	}
-	return obj;
+	return root;
 }
 /** Deep-clone a CRDT document. The clone is fully independent of the original. */
 function cloneDoc(doc) {
 	return { root: cloneNode(doc.root) };
 }
 function cloneNode(node) {
+	return cloneNodeAtDepth(node, 0);
+}
+function cloneNodeAtDepth(node, depth) {
+	assertTraversalDepth(depth);
 	if (node.kind === "lww") return {
 		kind: "lww",
 		value: structuredClone(node.value),
@@ -807,7 +1114,7 @@ function cloneNode(node) {
 	if (node.kind === "obj") {
 		const entries = /* @__PURE__ */ new Map();
 		for (const [k, v] of node.entries.entries()) entries.set(k, {
-			node: cloneNode(v.node),
+			node: cloneNodeAtDepth(v.node, depth + 1),
 			dot: {
 				actor: v.dot.actor,
 				ctr: v.dot.ctr
@@ -829,7 +1136,7 @@ function cloneNode(node) {
 		id: e.id,
 		prev: e.prev,
 		tombstone: e.tombstone,
-		value: cloneNode(e.value),
+		value: cloneNodeAtDepth(e.value, depth + 1),
 		insDot: {
 			actor: e.insDot.actor,
 			ctr: e.insDot.ctr
@@ -840,6 +1147,9 @@ function cloneNode(node) {
 		elems
 	};
 }
+function isJsonPrimitive(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
 function applyTest(base, head, it, evalTestAgainst) {
 	const snapshot = evalTestAgainst === "head" ? materialize(head.root) : materialize(base.root);
 	let got;
@@ -910,12 +1220,15 @@ function applyObjRemove(head, it, newDot) {
 	return null;
 }
 function applyArrInsert(base, head, it, newDot, bumpCounterAbove) {
+	const pointer = `/${it.path.join("/")}`;
 	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);
+			const dotRes = nextInsertDotForPrev(headSeq, prev, newDot, pointer, bumpCounterAbove);
+			if (!dotRes.ok) return dotRes;
+			const d = dotRes.dot;
 			rgaInsertAfter(headSeq, prev, dotToElemId(d), d, nodeFromJson(it.value, newDot));
 			return null;
 		}
@@ -924,7 +1237,7 @@ function applyArrInsert(base, head, it, newDot, bumpCounterAbove) {
 			code: 409,
 			reason: "MISSING_PARENT",
 			message: `base array missing at /${it.path.join("/")}`,
-			path: `/${it.path.join("/")}`
+			path: pointer
 		};
 	}
 	const headSeq = ensureSeqAtPath(head, it.path, newDot());
@@ -938,20 +1251,38 @@ function applyArrInsert(base, head, it, newDot, bumpCounterAbove) {
 		path: `/${it.path.join("/")}/${it.index}`
 	};
 	const prev = idx === 0 ? HEAD : rgaIdAtIndex(baseSeq, idx - 1) ?? HEAD;
-	const d = nextInsertDotForPrev(headSeq, prev, newDot, bumpCounterAbove);
+	const dotRes = nextInsertDotForPrev(headSeq, prev, newDot, pointer, bumpCounterAbove);
+	if (!dotRes.ok) return dotRes;
+	const d = dotRes.dot;
 	rgaInsertAfter(headSeq, prev, dotToElemId(d), d, nodeFromJson(it.value, newDot));
 	return null;
 }
-function nextInsertDotForPrev(seq, prev, newDot, bumpCounterAbove) {
+function nextInsertDotForPrev(seq, prev, newDot, path, bumpCounterAbove) {
+	const MAX_INSERT_DOT_ATTEMPTS = 1024;
 	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;
+	if (!maxSiblingDot) return {
+		ok: true,
+		dot: newDot()
+	};
+	for (let attempts = 0; attempts < MAX_INSERT_DOT_ATTEMPTS; attempts++) {
+		const candidate = newDot();
+		if (compareDot(candidate, maxSiblingDot) > 0) return {
+			ok: true,
+			dot: candidate
+		};
+	}
+	return {
+		ok: false,
+		code: 409,
+		reason: "DOT_GENERATION_EXHAUSTED",
+		message: `failed to generate insert dot within ${MAX_INSERT_DOT_ATTEMPTS} attempts`,
+		path
+	};
 }
 function applyArrDelete(base, head, it, newDot) {
 	const d = newDot();
@@ -1183,6 +1514,7 @@ function isJsonPatchToCrdtOptions(value) {
 	return typeof value === "object" && value !== null && "base" in value && "head" in value && "patch" in value && "newDot" in value;
 }
 function toApplyError$1(error) {
+	if (error instanceof TraversalDepthError) return toDepthApplyError(error);
 	if (error instanceof PatchCompileError) return {
 		ok: false,
 		code: 409,
@@ -1288,11 +1620,18 @@ function tryApplyPatch(state, patch, options = {}) {
 		doc: cloneDoc(state.doc),
 		clock: cloneClock(state.clock)
 	};
-	const result = applyPatchInternal(nextState, patch, options);
-	if (!result.ok) return {
-		ok: false,
-		error: result
-	};
+	try {
+		const result = applyPatchInternal(nextState, patch, options);
+		if (!result.ok) return {
+			ok: false,
+			error: result
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: toApplyError(error)
+		};
+	}
 	return {
 		ok: true,
 		state: nextState
@@ -1308,11 +1647,18 @@ function tryApplyPatchInPlace(state, patch, options = {}) {
 		state.clock = next.state.clock;
 		return { ok: true };
 	}
-	const result = applyPatchInternal(state, patch, applyOptions);
-	if (!result.ok) return {
-		ok: false,
-		error: result
-	};
+	try {
+		const result = applyPatchInternal(state, patch, applyOptions);
+		if (!result.ok) return {
+			ok: false,
+			error: result
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: toApplyError(error)
+		};
+	}
 	return { ok: true };
 }
 /**
@@ -1362,7 +1708,7 @@ function applyPatchInternal(state, patch, options) {
 			clock: createClock("__base__", 0)
 		} : null;
 		for (const [opIndex, op] of patch.entries()) {
-			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : cloneDoc(state.doc), opIndex);
+			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : state.doc, opIndex);
 			if (!step.ok) return step;
 			if (explicitBaseState && op.op !== "test") {
 				const baseStep = applyPatchInternal(explicitBaseState, [op], {
@@ -1385,12 +1731,13 @@ function applyPatchOpSequential(state, op, options, baseDoc, opIndex) {
 		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
 		if (!fromResolved.ok) return fromResolved;
 		const fromValue = fromResolved.value;
-		const removeRes = applySinglePatchOp(state, baseDoc, {
+		const removeRes = applySinglePatchOp(state, baseDoc, baseJson, {
 			op: "remove",
 			path: op.from
 		}, options);
 		if (!removeRes.ok) return removeRes;
-		return applySinglePatchOp(state, cloneDoc(state.doc), {
+		const addBase = state.doc;
+		return applySinglePatchOp(state, addBase, materialize(addBase.root), {
 			op: "add",
 			path: op.path,
 			value: fromValue
@@ -1400,13 +1747,13 @@ function applyPatchOpSequential(state, op, options, baseDoc, opIndex) {
 		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
 		if (!fromResolved.ok) return fromResolved;
 		const fromValue = fromResolved.value;
-		return applySinglePatchOp(state, baseDoc, {
+		return applySinglePatchOp(state, baseDoc, baseJson, {
 			op: "add",
 			path: op.path,
 			value: fromValue
 		}, options);
 	}
-	return applySinglePatchOp(state, baseDoc, op, options);
+	return applySinglePatchOp(state, baseDoc, baseJson, op, options);
 }
 function resolveValueAtPointer(baseJson, pointer, opIndex) {
 	let path;
@@ -1424,8 +1771,8 @@ function resolveValueAtPointer(baseJson, pointer, opIndex) {
 		return toPointerLookupApplyError(error, pointer, opIndex);
 	}
 }
-function applySinglePatchOp(state, baseDoc, op, options) {
-	const compiled = compileIntents(materialize(baseDoc.root), [op], "sequential");
+function applySinglePatchOp(state, baseDoc, baseJson, op, options) {
+	const compiled = compileIntents(baseJson, [op], "sequential");
 	if (!compiled.ok) return compiled;
 	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr));
 }
@@ -1443,30 +1790,41 @@ function compileIntents(baseJson, patch, semantics = "sequential") {
 	}
 }
 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()) {
+	let best = 0;
+	const stack = [{
+		node,
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (frame.node.kind === "lww") {
+			if (frame.node.dot.actor === actor && frame.node.dot.ctr > best) best = frame.node.dot.ctr;
+			continue;
+		}
+		if (frame.node.kind === "obj") {
+			for (const entry of frame.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;
+				stack.push({
+					node: entry.node,
+					depth: frame.depth + 1
+				});
 			}
-			for (const tomb of node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
-			return best;
+			for (const tomb of frame.node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
+			continue;
 		}
-		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;
+		for (const elem of frame.node.elems.values()) {
+			if (elem.insDot.actor === actor && elem.insDot.ctr > best) best = elem.insDot.ctr;
+			stack.push({
+				node: elem.value,
+				depth: frame.depth + 1
+			});
 		}
 	}
+	return best;
 }
 function toApplyError(error) {
+	if (error instanceof TraversalDepthError) return toDepthApplyError(error);
 	if (error instanceof PatchCompileError) return {
 		ok: false,
 		code: 409,
@@ -1506,13 +1864,27 @@ function toPointerLookupApplyError(error, pointer, opIndex) {
 
 //#endregion
 //#region src/serialize.ts
+const HEAD_ELEM_ID = "HEAD";
+var DeserializeError = class extends Error {
+	code = 409;
+	reason;
+	path;
+	constructor(reason, path, message) {
+		super(message);
+		this.name = "DeserializeError";
+		this.reason = reason;
+		this.path = path;
+	}
+};
 /** 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) };
+	if (!isRecord(data)) fail("INVALID_SERIALIZED_SHAPE", "/", "serialized doc must be an object");
+	if (!("root" in data)) fail("INVALID_SERIALIZED_SHAPE", "/root", "serialized doc is missing root");
+	return { root: deserializeNode(data.root, "/root", 0) };
 }
 /** Serialize a full CRDT state (document + clock) to a JSON-safe representation. */
 function serializeState(state) {
@@ -1526,7 +1898,11 @@ function serializeState(state) {
 }
 /** Reconstruct a full CRDT state from its serialized form, restoring the clock. */
 function deserializeState(data) {
-	const clock = createClock(data.clock.actor, data.clock.ctr);
+	if (!isRecord(data)) fail("INVALID_SERIALIZED_SHAPE", "/", "serialized state must be an object");
+	if (!("doc" in data)) fail("INVALID_SERIALIZED_SHAPE", "/doc", "serialized state is missing doc");
+	if (!("clock" in data)) fail("INVALID_SERIALIZED_SHAPE", "/clock", "serialized state is missing clock");
+	const clockRaw = asRecord(data.clock, "/clock");
+	const clock = createClock(readActor(clockRaw.actor, "/clock/actor"), readCounter(clockRaw.ctr, "/clock/ctr"));
 	return {
 		doc: deserializeDoc(data.doc),
 		clock
@@ -1577,54 +1953,132 @@ function serializeNode(node) {
 		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") {
+function deserializeNode(node, path, depth) {
+	assertTraversalDepth(depth);
+	const raw = asRecord(node, path);
+	const kind = readString(raw.kind, `${path}/kind`);
+	if (kind === "lww") {
+		if (!("value" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/value`, "lww node is missing value");
+		if (!("dot" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/dot`, "lww node is missing dot");
+		return {
+			kind: "lww",
+			value: structuredClone(readJsonValue(raw.value, `${path}/value`, depth + 1)),
+			dot: readDot(raw.dot, `${path}/dot`)
+		};
+	}
+	if (kind === "obj") {
+		const entriesRaw = asRecord(raw.entries, `${path}/entries`);
+		const tombstoneRaw = asRecord(raw.tombstone, `${path}/tombstone`);
 		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
-			}
-		});
+		for (const [k, v] of Object.entries(entriesRaw)) {
+			const entryPath = `${path}/entries/${k}`;
+			const entryRaw = asRecord(v, entryPath);
+			entries.set(k, {
+				node: deserializeNode(entryRaw.node, `${entryPath}/node`, depth + 1),
+				dot: readDot(entryRaw.dot, `${entryPath}/dot`)
+			});
+		}
 		const tombstone = /* @__PURE__ */ new Map();
-		for (const [k, d] of Object.entries(node.tombstone)) tombstone.set(k, {
-			actor: d.actor,
-			ctr: d.ctr
-		});
+		for (const [k, d] of Object.entries(tombstoneRaw)) tombstone.set(k, readDot(d, `${path}/tombstone/${k}`));
 		return {
 			kind: "obj",
 			entries,
 			tombstone
 		};
 	}
+	if (kind !== "seq") fail("INVALID_SERIALIZED_SHAPE", `${path}/kind`, `unsupported node kind '${kind}'`);
+	const elemsRaw = asRecord(raw.elems, `${path}/elems`);
 	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
-		}
-	});
+	for (const [id, rawElem] of Object.entries(elemsRaw)) {
+		const elemPath = `${path}/elems/${id}`;
+		const elem = asRecord(rawElem, elemPath);
+		const elemId = readString(elem.id, `${elemPath}/id`);
+		if (elemId !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/id`, `sequence element id '${elemId}' does not match key '${id}'`);
+		const prev = readString(elem.prev, `${elemPath}/prev`);
+		const tombstone = readBoolean(elem.tombstone, `${elemPath}/tombstone`);
+		const value = deserializeNode(elem.value, `${elemPath}/value`, depth + 1);
+		const insDot = readDot(elem.insDot, `${elemPath}/insDot`);
+		if (dotToElemId(insDot) !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/insDot`, "sequence element id must match its insertion dot");
+		elems.set(id, {
+			id,
+			prev,
+			tombstone,
+			value,
+			insDot
+		});
+	}
+	for (const elem of elems.values()) {
+		if (elem.prev === elem.id) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${elem.id}/prev`, "sequence element cannot reference itself as predecessor");
+		if (elem.prev !== HEAD_ELEM_ID && !elems.has(elem.prev)) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${elem.id}/prev`, `sequence predecessor '${elem.prev}' does not exist`);
+	}
 	return {
 		kind: "seq",
 		elems
 	};
 }
+function asRecord(value, path) {
+	if (!isRecord(value)) fail("INVALID_SERIALIZED_SHAPE", path, "expected object");
+	return value;
+}
+function readDot(value, path) {
+	const raw = asRecord(value, path);
+	return {
+		actor: readActor(raw.actor, `${path}/actor`),
+		ctr: readCounter(raw.ctr, `${path}/ctr`)
+	};
+}
+function readActor(value, path) {
+	const actor = readString(value, path);
+	if (actor.length === 0) fail("INVALID_SERIALIZED_SHAPE", path, "actor must not be empty");
+	return actor;
+}
+function readCounter(value, path) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) fail("INVALID_SERIALIZED_SHAPE", path, "counter must be a non-negative safe integer");
+	return value;
+}
+function readString(value, path) {
+	if (typeof value !== "string") fail("INVALID_SERIALIZED_SHAPE", path, "expected string");
+	return value;
+}
+function readBoolean(value, path) {
+	if (typeof value !== "boolean") fail("INVALID_SERIALIZED_SHAPE", path, "expected boolean");
+	return value;
+}
+function readJsonValue(value, path, depth) {
+	assertJsonValue(value, path, depth);
+	return value;
+}
+function assertJsonValue(value, path, depth) {
+	assertTraversalDepth(depth);
+	if (value === null || typeof value === "string" || typeof value === "boolean") return;
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) fail("INVALID_SERIALIZED_SHAPE", path, "json number must be finite");
+		return;
+	}
+	if (Array.isArray(value)) {
+		for (const [index, item] of value.entries()) assertJsonValue(item, `${path}/${index}`, depth + 1);
+		return;
+	}
+	if (!isRecord(value)) fail("INVALID_SERIALIZED_SHAPE", path, "expected JSON value");
+	for (const [key, child] of Object.entries(value)) assertJsonValue(child, `${path}/${key}`, depth + 1);
+}
+function fail(reason, path, message) {
+	throw new DeserializeError(reason, path, message);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 //#endregion
 //#region src/merge.ts
+var SharedElementMetadataMismatchError = class extends Error {
+	path;
+	constructor(path, id, field) {
+		super(`shared RGA element '${id}' has conflicting ${field} metadata`);
+		this.name = "SharedElementMetadataMismatchError";
+		this.path = path;
+	}
+};
 /** Error thrown by throwing merge helpers (`mergeDoc` / `mergeState`). */
 var MergeError = class extends Error {
 	code;
@@ -1634,7 +2088,7 @@ var MergeError = class extends Error {
 		super(error.message);
 		this.name = "MergeError";
 		this.code = error.code;
-		this.reason = "LINEAGE_MISMATCH";
+		this.reason = error.reason;
 		this.path = error.path;
 	}
 };
@@ -1658,21 +2112,39 @@ function mergeDoc(a, b, options = {}) {
 }
 /** Non-throwing `mergeDoc` variant with structured conflict details. */
 function tryMergeDoc(a, b, options = {}) {
-	const mismatchPath = options.requireSharedOrigin ?? true ? findSeqLineageMismatch(a.root, b.root, []) : null;
-	if (mismatchPath) return {
-		ok: false,
-		error: {
+	try {
+		const mismatchPath = options.requireSharedOrigin ?? true ? findSeqLineageMismatch(a.root, b.root, []) : null;
+		if (mismatchPath) return {
 			ok: false,
-			code: 409,
-			reason: "LINEAGE_MISMATCH",
-			message: `merge requires shared array origin at ${mismatchPath}`,
-			path: mismatchPath
-		}
-	};
-	return {
-		ok: true,
-		doc: { root: mergeNode(a.root, b.root) }
-	};
+			error: {
+				ok: false,
+				code: 409,
+				reason: "LINEAGE_MISMATCH",
+				message: `merge requires shared array origin at ${mismatchPath}`,
+				path: mismatchPath
+			}
+		};
+		return {
+			ok: true,
+			doc: { root: mergeNode(a.root, b.root) }
+		};
+	} catch (error) {
+		if (error instanceof SharedElementMetadataMismatchError) return {
+			ok: false,
+			error: {
+				ok: false,
+				code: 409,
+				reason: "LINEAGE_MISMATCH",
+				message: error.message,
+				path: error.path
+			}
+		};
+		if (error instanceof TraversalDepthError) return {
+			ok: false,
+			error: toDepthApplyError(error)
+		};
+		throw error;
+	}
 }
 /**
 * Merge two CRDT states.
@@ -1705,25 +2177,42 @@ function tryMergeState(a, b, options = {}) {
 	};
 }
 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;
+	const stack = [{
+		a,
+		b,
+		path,
+		depth: path.length
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (frame.a.kind === "seq" && frame.b.kind === "seq") {
+			const hasElemsA = frame.a.elems.size > 0;
+			const hasElemsB = frame.b.elems.size > 0;
+			if (hasElemsA && hasElemsB) {
+				let shared = false;
+				for (const id of frame.a.elems.keys()) if (frame.b.elems.has(id)) {
+					shared = true;
+					break;
+				}
+				if (!shared) return `/${frame.path.join("/")}`;
 			}
-			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;
+		if (frame.a.kind === "obj" && frame.b.kind === "obj") {
+			const left = frame.a;
+			const right = frame.b;
+			const sharedKeys = [...left.entries.keys()].filter((key) => right.entries.has(key));
+			for (let i = sharedKeys.length - 1; i >= 0; i--) {
+				const key = sharedKeys[i];
+				const nextA = left.entries.get(key).node;
+				const nextB = right.entries.get(key).node;
+				stack.push({
+					a: nextA,
+					b: nextB,
+					path: [...frame.path, key],
+					depth: frame.depth + 1
+				});
+			}
 		}
 	}
 	return null;
@@ -1735,28 +2224,38 @@ function maxObservedCtrForActor(doc, actor, a, b) {
 	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()) {
+	let best = 0;
+	const stack = [{
+		node,
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (frame.node.kind === "lww") {
+			if (frame.node.dot.actor === actor && frame.node.dot.ctr > best) best = frame.node.dot.ctr;
+			continue;
+		}
+		if (frame.node.kind === "obj") {
+			for (const entry of frame.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;
+				stack.push({
+					node: entry.node,
+					depth: frame.depth + 1
+				});
 			}
-			for (const tomb of node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
-			return best;
+			for (const tomb of frame.node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
+			continue;
 		}
-		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;
+		for (const elem of frame.node.elems.values()) {
+			if (elem.insDot.actor === actor && elem.insDot.ctr > best) best = elem.insDot.ctr;
+			stack.push({
+				node: elem.value,
+				depth: frame.depth + 1
+			});
 		}
 	}
+	return best;
 }
 function repDot(node) {
 	switch (node.kind) {
@@ -1781,11 +2280,15 @@ function repDot(node) {
 	}
 }
 function mergeNode(a, b) {
+	return mergeNodeAtDepth(a, b, 0, []);
+}
+function mergeNodeAtDepth(a, b, depth, path) {
+	assertTraversalDepth(depth);
 	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);
+	if (a.kind === "obj" && b.kind === "obj") return mergeObj(a, b, depth + 1, path);
+	if (a.kind === "seq" && b.kind === "seq") return mergeSeq(a, b, depth + 1, path);
+	if (compareDot(repDot(a), repDot(b)) >= 0) return cloneNodeShallow(a, depth + 1);
+	return cloneNodeShallow(b, depth + 1);
 }
 function mergeLww(a, b) {
 	if (compareDot(a.dot, b.dot) >= 0) return {
@@ -1799,7 +2302,8 @@ function mergeLww(a, b) {
 		dot: { ...b.dot }
 	};
 }
-function mergeObj(a, b) {
+function mergeObj(a, b, depth, path) {
+	assertTraversalDepth(depth);
 	const entries = /* @__PURE__ */ new Map();
 	const tombstone = /* @__PURE__ */ new Map();
 	const allTombKeys = new Set([...a.tombstone.keys(), ...b.tombstone.keys()]);
@@ -1816,15 +2320,15 @@ function mergeObj(a, b) {
 		const eb = b.entries.get(key);
 		let merged;
 		if (ea && eb) merged = {
-			node: mergeNode(ea.node, eb.node),
+			node: mergeNodeAtDepth(ea.node, eb.node, depth + 1, [...path, key]),
 			dot: compareDot(ea.dot, eb.dot) >= 0 ? { ...ea.dot } : { ...eb.dot }
 		};
 		else if (ea) merged = {
-			node: cloneNodeShallow(ea.node),
+			node: cloneNodeShallow(ea.node, depth + 1),
 			dot: { ...ea.dot }
 		};
 		else merged = {
-			node: cloneNodeShallow(eb.node),
+			node: cloneNodeShallow(eb.node, depth + 1),
 			dot: { ...eb.dot }
 		};
 		const td = tombstone.get(key);
@@ -1837,14 +2341,17 @@ function mergeObj(a, b) {
 		tombstone
 	};
 }
-function mergeSeq(a, b) {
+function mergeSeq(a, b, depth, path) {
+	assertTraversalDepth(depth);
 	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);
+			if (ea.prev !== eb.prev) throw new SharedElementMetadataMismatchError(toPointer(path), id, "prev");
+			if (!sameDot(ea.insDot, eb.insDot)) throw new SharedElementMetadataMismatchError(toPointer(path), id, "insDot");
+			const mergedValue = mergeNodeAtDepth(ea.value, eb.value, depth + 1, [...path, id]);
 			elems.set(id, {
 				id,
 				prev: ea.prev,
@@ -1852,24 +2359,33 @@ function mergeSeq(a, b) {
 				value: mergedValue,
 				insDot: { ...ea.insDot }
 			});
-		} else if (ea) elems.set(id, cloneElem(ea));
-		else elems.set(id, cloneElem(eb));
+		} else if (ea) elems.set(id, cloneElem(ea, depth + 1));
+		else elems.set(id, cloneElem(eb, depth + 1));
 	}
 	return {
 		kind: "seq",
 		elems
 	};
 }
-function cloneElem(e) {
+function sameDot(a, b) {
+	return a.actor === b.actor && a.ctr === b.ctr;
+}
+function toPointer(path) {
+	if (path.length === 0) return "/";
+	return `/${path.join("/")}`;
+}
+function cloneElem(e, depth) {
+	assertTraversalDepth(depth);
 	return {
 		id: e.id,
 		prev: e.prev,
 		tombstone: e.tombstone,
-		value: cloneNodeShallow(e.value),
+		value: cloneNodeShallow(e.value, depth + 1),
 		insDot: { ...e.insDot }
 	};
 }
-function cloneNodeShallow(node) {
+function cloneNodeShallow(node, depth) {
+	assertTraversalDepth(depth);
 	switch (node.kind) {
 		case "lww": return {
 			kind: "lww",
@@ -1879,7 +2395,7 @@ function cloneNodeShallow(node) {
 		case "obj": {
 			const entries = /* @__PURE__ */ new Map();
 			for (const [k, v] of node.entries) entries.set(k, {
-				node: cloneNodeShallow(v.node),
+				node: cloneNodeShallow(v.node, depth + 1),
 				dot: { ...v.dot }
 			});
 			const tombstone = /* @__PURE__ */ new Map();
@@ -1892,7 +2408,7 @@ function cloneNodeShallow(node) {
 		}
 		case "seq": {
 			const elems = /* @__PURE__ */ new Map();
-			for (const [id, e] of node.elems) elems.set(id, cloneElem(e));
+			for (const [id, e] of node.elems) elems.set(id, cloneElem(e, depth + 1));
 			return {
 				kind: "seq",
 				elems
@@ -1902,4 +2418,83 @@ function cloneNodeShallow(node) {
 }
 
 //#endregion
-export { vvMerge as $, compileJsonPatchToIntent as A, newSeq as B, crdtToJsonPatch as C, jsonPatchToCrdtSafe as D, jsonPatchToCrdt as E, stringifyJsonPointer as F, rgaDelete as G, objSet as H, ROOT_KEY as I, rgaLinearizeIds as J, rgaIdAtIndex as K, lwwSet as L, getAtJson as M, jsonEquals as N, tryJsonPatchToCrdt as O, parseJsonPointer as P, vvHasDot as Q, newObj as R, crdtToFullReplace as S, docFromJsonWithDot as T, materialize as U, objRemove as V, HEAD as W, compareDot as X, rgaPrevForInsertAtIndex as Y, dotToElemId as Z, tryApplyPatch as _, tryMergeState as a, applyIntentsToCrdt as b, serializeDoc as c, applyPatch as d, cloneClock as et, applyPatchAsActor as f, toJson as g, forkState as h, tryMergeDoc as i, diffJsonPatch as j, PatchCompileError as k, serializeState as l, createState as m, mergeDoc as n, nextDotForActor as nt, deserializeDoc as o, applyPatchInPlace as p, rgaInsertAfter as q, mergeState as r, observeDot as rt, deserializeState as s, MergeError as t, createClock as tt, PatchError as u, tryApplyPatchInPlace as v, docFromJson as w, cloneDoc as x, validateJsonPatch as y, newReg as z };
+//#region src/compact.ts
+function isDotStable(stable, dot) {
+	return (stable[dot.actor] ?? 0) >= dot.ctr;
+}
+/**
+* Compact causally-stable tombstones in a document.
+*
+* Safety note:
+* - Only compact at checkpoints that are causally stable across all peers you
+*   may still merge with.
+* - Do not merge this compacted document with replicas that might be behind
+*   the provided checkpoint.
+*/
+function compactDocTombstones(doc, options) {
+	const targetDoc = options.mutate ? doc : cloneDoc(doc);
+	const stats = {
+		objectTombstonesRemoved: 0,
+		sequenceTombstonesRemoved: 0
+	};
+	const stable = options.stable;
+	const stack = [{
+		node: targetDoc.root,
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (frame.node.kind === "obj") {
+			stats.objectTombstonesRemoved += objCompactTombstones(frame.node, (dot) => isDotStable(stable, dot));
+			for (const entry of frame.node.entries.values()) stack.push({
+				node: entry.node,
+				depth: frame.depth + 1
+			});
+			continue;
+		}
+		if (frame.node.kind === "seq") {
+			stats.sequenceTombstonesRemoved += rgaCompactTombstones(frame.node, (dot) => isDotStable(stable, dot));
+			for (const elem of frame.node.elems.values()) stack.push({
+				node: elem.value,
+				depth: frame.depth + 1
+			});
+		}
+	}
+	return {
+		doc: targetDoc,
+		stats
+	};
+}
+/**
+* Compact causally-stable tombstones in a state document.
+*
+* Safety note:
+* - Only compact at checkpoints that are causally stable across all peers you
+*   may still merge with.
+* - Do not merge this compacted state with replicas that might be behind the
+*   provided checkpoint.
+*/
+function compactStateTombstones(state, options) {
+	if (options.mutate) return {
+		state,
+		stats: compactDocTombstones(state.doc, {
+			stable: options.stable,
+			mutate: true
+		}).stats
+	};
+	const nextState = {
+		doc: cloneDoc(state.doc),
+		clock: cloneClock(state.clock)
+	};
+	return {
+		state: nextState,
+		stats: compactDocTombstones(nextState.doc, {
+			stable: options.stable,
+			mutate: true
+		}).stats
+	};
+}
+
+//#endregion
+export { rgaLinearizeIds as $, jsonPatchToCrdtSafe as A, lwwSet as B, applyIntentsToCrdt as C, docFromJson as D, crdtToJsonPatch as E, getAtJson as F, objRemove as G, newReg as H, jsonEquals as I, HEAD as J, objSet as K, parseJsonPointer as L, PatchCompileError as M, compileJsonPatchToIntent as N, docFromJsonWithDot as O, diffJsonPatch as P, rgaInsertAfter as Q, stringifyJsonPointer as R, validateJsonPatch as S, crdtToFullReplace as T, newSeq as U, newObj as V, objCompactTombstones as W, rgaDelete as X, rgaCompactTombstones as Y, rgaIdAtIndex as Z, createState as _, mergeState as a, MAX_TRAVERSAL_DEPTH as at, tryApplyPatch as b, DeserializeError as c, createClock as ct, serializeDoc as d, rgaPrevForInsertAtIndex as et, serializeState as f, applyPatchInPlace as g, applyPatchAsActor as h, mergeDoc as i, vvMerge as it, tryJsonPatchToCrdt as j, jsonPatchToCrdt as k, deserializeDoc as l, nextDotForActor as lt, applyPatch as m, compactStateTombstones as n, dotToElemId as nt, tryMergeDoc as o, TraversalDepthError as ot, PatchError as p, materialize as q, MergeError as r, vvHasDot as rt, tryMergeState as s, cloneClock as st, compactDocTombstones as t, compareDot as tt, deserializeState as u, observeDot as ut, forkState as v, cloneDoc as w, tryApplyPatchInPlace as x, toJson as y, ROOT_KEY as z };