json-patch-to-crdt 0.1.0 → 0.1.2

package/dist/{merge-BqROEw61.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;
 		}
-		case "seq": return rgaLinearizeIds(node).map((id) => materialize(node.elems.get(id).value));
+		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;
+		}
+		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 `""`).
@@ -215,13 +416,37 @@ var PatchCompileError = class extends Error {
 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, "~"));
+	return ptr.slice(1).split("/").map(unescapeJsonPointerToken);
 }
 /** 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("/")}`;
 }
+function unescapeJsonPointerToken(token) {
+	let out = "";
+	for (let i = 0; i < token.length; i++) {
+		const ch = token[i];
+		if (ch !== "~") {
+			out += ch;
+			continue;
+		}
+		const esc = token[i + 1];
+		if (esc === "0") {
+			out += "~";
+			i += 1;
+			continue;
+		}
+		if (esc === "1") {
+			out += "/";
+			i += 1;
+			continue;
+		}
+		const sequence = esc === void 0 ? "~" : `~${esc}`;
+		throw new Error(`Invalid pointer escape sequence '${sequence}'`);
+	}
+	return out;
+}
 /**
 * 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.
@@ -229,14 +454,14 @@ function stringifyJsonPointer(path) {
 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}`);
+		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 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;
 }
 /**
@@ -254,7 +479,7 @@ function compileJsonPatchToIntent(baseJson, patch, options = {}) {
 	for (let opIndex = 0; opIndex < patch.length; opIndex++) {
 		const op = patch[opIndex];
 		const compileBase = semantics === "sequential" ? workingBase : baseJson;
-		intents.push(...compileSingleOp(compileBase, op, opIndex));
+		intents.push(...compileSingleOp(compileBase, op, opIndex, semantics));
 		if (semantics === "sequential") workingBase = applyPatchOpToJson(workingBase, op, opIndex);
 	}
 	return intents;
@@ -277,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({
@@ -313,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));
@@ -353,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++) {
@@ -397,6 +636,7 @@ function jsonEquals(a, b) {
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+const ARRAY_INDEX_TOKEN_PATTERN = /^(0|[1-9][0-9]*)$/;
 function hasOwn(value, key) {
 	return Object.prototype.hasOwnProperty.call(value, key);
 }
@@ -407,7 +647,7 @@ function pathValueAt(base, path) {
 function assertNever$1(_value, message) {
 	throw new Error(message);
 }
-function compileSingleOp(baseJson, op, opIndex) {
+function compileSingleOp(baseJson, op, opIndex, semantics) {
 	if (op.op === "test") return [{
 		t: "Test",
 		path: parsePointerOrThrow(op.path, op.path, opIndex),
@@ -418,15 +658,29 @@ function compileSingleOp(baseJson, op, opIndex) {
 		const toPath = parsePointerOrThrow(op.path, op.path, opIndex);
 		if (op.op === "move" && isStrictDescendantPath(fromPath, toPath)) throw compileError("INVALID_MOVE", `cannot move a value into one of its descendants at ${op.path}`, op.path, opIndex);
 		const val = lookupValueOrThrow(baseJson, fromPath, op.from, opIndex);
+		if (op.op === "move" && isSamePath(fromPath, toPath)) return [];
+		if (op.op === "move" && semantics === "sequential") {
+			const removeOp = {
+				op: "remove",
+				path: op.from
+			};
+			const addOp = {
+				op: "add",
+				path: op.path,
+				value: val
+			};
+			const baseAfterRemove = applyPatchOpToJson(baseJson, removeOp, opIndex);
+			return [...compileSingleOp(baseJson, removeOp, opIndex, semantics), ...compileSingleOp(baseAfterRemove, addOp, opIndex, semantics)];
+		}
 		const out = compileSingleOp(baseJson, {
 			op: "add",
 			path: op.path,
 			value: val
-		}, opIndex);
+		}, opIndex, semantics);
 		if (op.op === "move") out.push(...compileSingleOp(baseJson, {
 			op: "remove",
 			path: op.from
-		}, opIndex));
+		}, opIndex, semantics));
 		return out;
 	}
 	const path = parsePointerOrThrow(op.path, op.path, opIndex);
@@ -562,7 +816,7 @@ function parseArrayIndexToken(token, op, arrLength, path, opIndex) {
 		if (op !== "add") throw compileError("INVALID_POINTER", `'-' index is only valid for add at ${path}`, path, opIndex);
 		return Number.POSITIVE_INFINITY;
 	}
-	if (!/^[0-9]+$/.test(token)) throw compileError("INVALID_POINTER", `expected array index at ${path}`, path, opIndex);
+	if (!ARRAY_INDEX_TOKEN_PATTERN.test(token)) throw compileError("INVALID_POINTER", `expected array index at ${path}`, path, opIndex);
 	const index = Number(token);
 	if (!Number.isSafeInteger(index)) throw compileError("OUT_OF_BOUNDS", `array index is too large at ${path}`, path, opIndex);
 	if (op === "add") {
@@ -571,12 +825,36 @@ function parseArrayIndexToken(token, op, arrLength, path, opIndex) {
 	return index;
 }
 function compileErrorFromLookup(error, path, opIndex) {
-	const message = error instanceof Error ? error.message : "invalid path";
-	if (message.includes("Expected array index")) return compileError("INVALID_POINTER", message, path, opIndex);
-	if (message.includes("Index out of bounds")) return compileError("OUT_OF_BOUNDS", message, path, opIndex);
-	if (message.includes("Missing key")) return compileError("MISSING_PARENT", message, path, opIndex);
-	if (message.includes("Cannot traverse into non-container")) return compileError("INVALID_TARGET", message, path, opIndex);
-	return compileError("INVALID_PATCH", message, path, opIndex);
+	const mapped = mapLookupErrorToPatchReason(error);
+	return compileError(mapped.reason, mapped.message, path, opIndex);
+}
+function mapLookupErrorToPatchReason(error) {
+	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: error instanceof Error ? error.message : "invalid path"
+	};
 }
 function compileError(reason, message, path, opIndex) {
 	return new PatchCompileError(reason, message, path, opIndex);
@@ -586,6 +864,11 @@ function isStrictDescendantPath(from, to) {
 	for (let i = 0; i < from.length; i++) if (from[i] !== to[i]) return false;
 	return true;
 }
+function isSamePath(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
 
 //#endregion
 //#region src/doc.ts
@@ -688,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();
@@ -699,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),
@@ -744,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
@@ -766,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
@@ -777,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;
@@ -847,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;
 		}
@@ -861,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());
@@ -875,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();
@@ -1056,8 +1450,7 @@ function jsonPatchToCrdtInternal(options) {
 	const shadowBump = (ctr) => {
 		if (shadowCtr < ctr) shadowCtr = ctr;
 	};
-	for (let opIndex = 0; opIndex < options.patch.length; opIndex++) {
-		const op = options.patch[opIndex];
+	const applySequentialOp = (op, opIndex) => {
 		const baseJson = materialize(shadowBase.root);
 		let intents;
 		try {
@@ -1071,6 +1464,42 @@ function jsonPatchToCrdtInternal(options) {
 			const shadowStep = applyIntentsToCrdt(shadowBase, shadowBase, intents, shadowDot, "base", shadowBump);
 			if (!shadowStep.ok) return withOpIndex(shadowStep, opIndex);
 		} else shadowBase = cloneDoc(options.head);
+		return { ok: true };
+	};
+	for (let opIndex = 0; opIndex < options.patch.length; opIndex++) {
+		const op = options.patch[opIndex];
+		if (op.op === "move") {
+			const baseJson = materialize(shadowBase.root);
+			let fromValue;
+			try {
+				fromValue = structuredClone(getAtJson(baseJson, parseJsonPointer(op.from)));
+			} catch {
+				try {
+					compileJsonPatchToIntent(baseJson, [{
+						op: "remove",
+						path: op.from
+					}], { semantics: "sequential" });
+				} catch (error) {
+					return withOpIndex(toApplyError$1(error), opIndex);
+				}
+				return withOpIndex(toApplyError$1(/* @__PURE__ */ new Error(`failed to resolve move source at ${op.from}`)), opIndex);
+			}
+			if (op.from === op.path) continue;
+			const removeStep = applySequentialOp({
+				op: "remove",
+				path: op.from
+			}, opIndex);
+			if (!removeStep.ok) return removeStep;
+			const addStep = applySequentialOp({
+				op: "add",
+				path: op.path,
+				value: fromValue
+			}, opIndex);
+			if (!addStep.ok) return addStep;
+			continue;
+		}
+		const step = applySequentialOp(op, opIndex);
+		if (!step.ok) return step;
 	}
 	return { ok: true };
 }
@@ -1085,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,
@@ -1142,8 +1572,10 @@ function createState(initial, options) {
 /**
 * Fork a replica from a shared origin state while assigning a new local actor ID.
 * The forked state has an independent document clone and clock.
+* By default this rejects actor reuse to prevent duplicate-dot collisions across peers.
 */
-function forkState(origin, actor) {
+function forkState(origin, actor, options = {}) {
+	if (actor === origin.clock.actor && !options.allowActorReuse) throw new Error(`forkState actor must be unique; refusing to reuse origin actor '${actor}'`);
 	return {
 		doc: cloneDoc(origin.doc),
 		clock: createClock(actor, origin.clock.ctr)
@@ -1188,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
@@ -1208,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 };
 }
 /**
@@ -1261,8 +1707,8 @@ function applyPatchInternal(state, patch, options) {
 			doc: cloneDoc(options.base.doc),
 			clock: createClock("__base__", 0)
 		} : null;
-		for (const op of patch) {
-			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : cloneDoc(state.doc));
+		for (const [opIndex, op] of patch.entries()) {
+			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], {
@@ -1279,33 +1725,54 @@ function applyPatchInternal(state, patch, options) {
 	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) {
+function applyPatchOpSequential(state, op, options, baseDoc, opIndex) {
 	const baseJson = materialize(baseDoc.root);
 	if (op.op === "move") {
-		const fromValue = getAtJson(baseJson, parseJsonPointer(op.from));
-		const removeRes = applySinglePatchOp(state, baseDoc, {
+		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
+		if (!fromResolved.ok) return fromResolved;
+		const fromValue = fromResolved.value;
+		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
 		}, options);
 	}
 	if (op.op === "copy") {
-		const fromValue = getAtJson(baseJson, parseJsonPointer(op.from));
-		return applySinglePatchOp(state, baseDoc, {
+		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
+		if (!fromResolved.ok) return fromResolved;
+		const fromValue = fromResolved.value;
+		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 applySinglePatchOp(state, baseDoc, op, options) {
-	const compiled = compileIntents(materialize(baseDoc.root), [op], "sequential");
+function resolveValueAtPointer(baseJson, pointer, opIndex) {
+	let path;
+	try {
+		path = parseJsonPointer(pointer);
+	} catch (error) {
+		return toPointerParseApplyError(error, pointer, opIndex);
+	}
+	try {
+		return {
+			ok: true,
+			value: getAtJson(baseJson, path)
+		};
+	} catch (error) {
+		return toPointerLookupApplyError(error, pointer, opIndex);
+	}
+}
+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));
 }
@@ -1323,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,
@@ -1362,16 +1840,51 @@ function toApplyError(error) {
 		message: error instanceof Error ? error.message : "failed to compile patch"
 	};
 }
+function toPointerParseApplyError(error, pointer, opIndex) {
+	return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_POINTER",
+		message: error instanceof Error ? error.message : "invalid pointer",
+		path: pointer,
+		opIndex
+	};
+}
+function toPointerLookupApplyError(error, pointer, opIndex) {
+	const mapped = mapLookupErrorToPatchReason(error);
+	return {
+		ok: false,
+		code: 409,
+		reason: mapped.reason,
+		message: mapped.message,
+		path: 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) {
@@ -1385,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
@@ -1436,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;
@@ -1493,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;
 	}
 };
@@ -1517,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.
@@ -1564,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;
@@ -1594,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) {
@@ -1640,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 {
@@ -1658,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()]);
@@ -1675,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);
@@ -1696,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,
@@ -1711,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",
@@ -1738,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();
@@ -1751,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
@@ -1761,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 };