json-patch-to-crdt 0.1.1 → 0.1.3

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

@@ -1,10 +1,33 @@
 //#region src/clock.ts
+var ClockValidationError = class extends TypeError {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.name = "ClockValidationError";
+		this.reason = reason;
+	}
+};
+function readVvCounter$1(vv, actor) {
+	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return 0;
+	const counter = vv[actor];
+	return typeof counter === "number" ? counter : 0;
+}
+function writeVvCounter$1(vv, actor, counter) {
+	Object.defineProperty(vv, actor, {
+		configurable: true,
+		enumerable: true,
+		value: counter,
+		writable: true
+	});
+}
 /**
 * Create a new clock for the given actor. Each call to `clock.next()` yields a fresh `Dot`.
 * @param actor - Unique identifier for this peer.
 * @param start - Initial counter value (defaults to 0).
 */
 function createClock(actor, start = 0) {
+	assertActorId(actor);
+	assertCounter(start);
 	const clock = {
 		actor,
 		ctr: start,
@@ -18,6 +41,12 @@ function createClock(actor, start = 0) {
 	};
 	return clock;
 }
+function assertActorId(actor) {
+	if (actor.length === 0) throw new ClockValidationError("INVALID_ACTOR", "actor must not be empty");
+}
+function assertCounter(counter) {
+	if (!Number.isSafeInteger(counter) || counter < 0) throw new ClockValidationError("INVALID_COUNTER", "counter must be a non-negative safe integer");
+}
 /** Create an independent copy of a clock at the same counter position. */
 function cloneClock(clock) {
 	return createClock(clock.actor, clock.ctr);
@@ -27,8 +56,8 @@ function cloneClock(clock) {
 * Useful when a server needs to mint dots for many actors.
 */
 function nextDotForActor(vv, actor) {
-	const ctr = (vv[actor] ?? 0) + 1;
-	vv[actor] = ctr;
+	const ctr = readVvCounter$1(vv, actor) + 1;
+	writeVvCounter$1(vv, actor, ctr);
 	return {
 		actor,
 		ctr
@@ -36,21 +65,62 @@ function nextDotForActor(vv, actor) {
 }
 /** Record an observed dot in a version vector. */
 function observeDot(vv, dot) {
-	if ((vv[dot.actor] ?? 0) < dot.ctr) vv[dot.actor] = dot.ctr;
+	if (readVvCounter$1(vv, dot.actor) < dot.ctr) writeVvCounter$1(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 readVvCounter(vv, actor) {
+	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return;
+	const counter = vv[actor];
+	return typeof counter === "number" ? counter : void 0;
+}
+function writeVvCounter(vv, actor, counter) {
+	Object.defineProperty(vv, actor, {
+		configurable: true,
+		enumerable: true,
+		value: counter,
+		writable: true
+	});
+}
 function compareDot(a, b) {
 	if (a.ctr !== b.ctr) return a.ctr - b.ctr;
 	return a.actor < b.actor ? -1 : a.actor > b.actor ? 1 : 0;
 }
 function vvHasDot(vv, d) {
-	return (vv[d.actor] ?? 0) >= d.ctr;
+	return (readVvCounter(vv, d.actor) ?? 0) >= d.ctr;
 }
 function vvMerge(a, b) {
-	const out = { ...a };
-	for (const [actor, ctr] of Object.entries(b)) out[actor] = Math.max(out[actor] ?? 0, ctr);
+	const out = Object.create(null);
+	for (const [actor, ctr] of Object.entries(a)) writeVvCounter(out, actor, ctr);
+	for (const [actor, ctr] of Object.entries(b)) writeVvCounter(out, actor, Math.max(readVvCounter(out, actor) ?? 0, ctr));
 	return out;
 }
 function dotToElemId(d) {
@@ -84,15 +154,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 +198,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 +264,111 @@ function rgaPrevForInsertAtIndex(seq, index) {
 
 //#endregion
 //#region src/materialize.ts
-/** Recursively convert a CRDT node graph into a plain JSON value. */
+function createMaterializedObject() {
+	return Object.create(null);
+}
+function setMaterializedProperty(out, key, value) {
+	Object.defineProperty(out, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
+/** 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" ? createMaterializedObject() : [];
+	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") {
+				setMaterializedProperty(frame.out, key, child.value);
+				continue;
+			}
+			if (child.kind === "obj") {
+				const outObj = createMaterializedObject();
+				setMaterializedProperty(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 = [];
+			setMaterializedProperty(frame.out, key, outArr);
+			stack.push({
+				kind: "seq",
+				depth: childDepth,
+				ids: rgaLinearizeIds(child),
+				index: 0,
+				seq: child,
+				out: outArr
+			});
+			continue;
 		}
-		case "seq": return rgaLinearizeIds(node).map((id) => materialize(node.elems.get(id).value));
+		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 = createMaterializedObject();
+			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 +413,168 @@ 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/json-value.ts
+/**
+* Runtime validation error for values that are not JSON-compatible.
+* `path` is an RFC 6901 pointer relative to the validated root.
+*/
+var JsonValueValidationError = class extends TypeError {
+	path;
+	detail;
+	constructor(path, detail) {
+		super(`invalid JSON value at ${path === "" ? "<root>" : path}: ${detail}`);
+		this.name = "JsonValueValidationError";
+		this.path = path;
+		this.detail = detail;
+	}
+};
+/** Assert that a runtime value is JSON-compatible (including finite numbers only). */
+function assertRuntimeJsonValue(value) {
+	const stack = [{
+		value,
+		path: "",
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (isJsonPrimitive$1(frame.value)) continue;
+		if (Array.isArray(frame.value)) {
+			for (const [index, child] of frame.value.entries()) stack.push({
+				value: child,
+				path: appendPointerSegment(frame.path, String(index)),
+				depth: frame.depth + 1
+			});
+			continue;
+		}
+		if (isJsonObject(frame.value)) {
+			for (const [key, child] of Object.entries(frame.value)) stack.push({
+				value: child,
+				path: appendPointerSegment(frame.path, key),
+				depth: frame.depth + 1
+			});
+			continue;
+		}
+		throw new JsonValueValidationError(frame.path, describeInvalidValue(frame.value));
+	}
+}
+/**
+* Normalize a runtime value to JSON-compatible data.
+* - non-finite numbers -> null
+* - invalid object-property values -> key omitted
+* - invalid root / array values -> null
+*/
+function normalizeRuntimeJsonValue(value) {
+	const rootHolder = {};
+	const stack = [{
+		value,
+		path: "",
+		depth: 0,
+		slot: { kind: "root" }
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (isJsonPrimitive$1(frame.value)) {
+			assignSlot(frame.slot, frame.value, rootHolder);
+			continue;
+		}
+		if (Array.isArray(frame.value)) {
+			const out = [];
+			assignSlot(frame.slot, out, rootHolder);
+			for (const [index, child] of frame.value.entries()) stack.push({
+				value: child,
+				path: appendPointerSegment(frame.path, String(index)),
+				depth: frame.depth + 1,
+				slot: {
+					kind: "array",
+					out,
+					index
+				}
+			});
+			continue;
+		}
+		if (isJsonObject(frame.value)) {
+			const out = Object.create(null);
+			assignSlot(frame.slot, out, rootHolder);
+			for (const [key, child] of Object.entries(frame.value)) stack.push({
+				value: child,
+				path: appendPointerSegment(frame.path, key),
+				depth: frame.depth + 1,
+				slot: {
+					kind: "object",
+					out,
+					key
+				}
+			});
+			continue;
+		}
+		if (isNonFiniteNumber(frame.value)) {
+			assignSlot(frame.slot, null, rootHolder);
+			continue;
+		}
+		if (frame.slot.kind !== "object") assignSlot(frame.slot, null, rootHolder);
+	}
+	return rootHolder.value ?? null;
+}
+/** Runtime JSON guardrail helper shared by create/apply/diff paths. */
+function coerceRuntimeJsonValue(value, mode) {
+	if (mode === "none") return value;
+	if (mode === "strict") {
+		assertRuntimeJsonValue(value);
+		return value;
+	}
+	return normalizeRuntimeJsonValue(value);
+}
+function assignSlot(slot, value, rootHolder) {
+	if (slot.kind === "root") {
+		rootHolder.value = value;
+		return;
+	}
+	if (slot.kind === "array") {
+		slot.out[slot.index] = value;
+		return;
+	}
+	slot.out[slot.key] = value;
+}
+function appendPointerSegment(path, segment) {
+	const escaped = segment.replaceAll("~", "~0").replaceAll("/", "~1");
+	if (path === "") return `/${escaped}`;
+	return `${path}/${escaped}`;
+}
+function isJsonPrimitive$1(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonFiniteNumber(value) {
+	return typeof value === "number" && !Number.isFinite(value);
+}
+function describeInvalidValue(value) {
+	if (typeof value === "number") return `non-finite number (${String(value)})`;
+	if (value === void 0) return "undefined is not valid JSON";
+	if (typeof value === "bigint") return "bigint is not valid JSON";
+	if (typeof value === "symbol") return "symbol is not valid JSON";
+	if (typeof value === "function") return "function is not valid JSON";
+	return `unsupported value type (${typeof value})`;
+}
 
 //#endregion
 //#region src/types.ts
@@ -194,6 +586,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 +600,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 +657,15 @@ 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}`);
-		cur = cur[seg];
-	} else throw new Error(`Cannot traverse into non-container at ${seg}`);
+		const obj = cur;
+		if (!hasOwn(obj, seg)) throw new JsonLookupError("MISSING_KEY", seg, `Missing key '${seg}'`);
+		cur = obj[seg];
+	} else throw new JsonLookupError("NON_CONTAINER", seg, `Cannot traverse into non-container at '${seg}'`);
 	return cur;
 }
 /**
@@ -274,12 +679,13 @@ function getAtJson(base, path) {
 function compileJsonPatchToIntent(baseJson, patch, options = {}) {
 	const semantics = options.semantics ?? "sequential";
 	let workingBase = semantics === "sequential" ? structuredClone(baseJson) : baseJson;
+	const pointerCache = /* @__PURE__ */ new Map();
 	const intents = [];
 	for (let opIndex = 0; opIndex < patch.length; opIndex++) {
 		const op = patch[opIndex];
 		const compileBase = semantics === "sequential" ? workingBase : baseJson;
-		intents.push(...compileSingleOp(compileBase, op, opIndex, semantics));
-		if (semantics === "sequential") workingBase = applyPatchOpToJson(workingBase, op, opIndex);
+		intents.push(...compileSingleOp(compileBase, op, opIndex, semantics, pointerCache));
+		if (semantics === "sequential") workingBase = applyPatchOpToJsonInPlace(workingBase, op, opIndex, pointerCache);
 	}
 	return intents;
 }
@@ -293,15 +699,26 @@ function compileJsonPatchToIntent(baseJson, patch, options = {}) {
 * @returns An array of JSON Patch operations that transform `base` into `next`.
 */
 function diffJsonPatch(base, next, options = {}) {
+	const runtimeMode = options.jsonValidation ?? "none";
+	const runtimeBase = coerceRuntimeJsonValue(base, runtimeMode);
+	const runtimeNext = coerceRuntimeJsonValue(next, runtimeMode);
 	const ops = [];
-	diffValue([], base, next, ops, options);
+	diffValue([], runtimeBase, runtimeNext, ops, options);
 	return ops;
 }
 function diffValue(path, base, next, ops, options) {
 	if (jsonEquals(base, next)) return;
 	if (Array.isArray(base) || Array.isArray(next)) {
 		if ((options.arrayStrategy ?? "lcs") === "lcs" && Array.isArray(base) && Array.isArray(next)) {
-			diffArray(path, base, next, ops, options);
+			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 +754,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 +794,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++) {
@@ -413,7 +836,7 @@ function jsonEquals(a, b) {
 	const bKeys = Object.keys(b);
 	if (aKeys.length !== bKeys.length) return false;
 	for (const key of aKeys) {
-		if (!(key in b)) return false;
+		if (!hasOwn(b, key)) return false;
 		if (!jsonEquals(a[key], b[key])) return false;
 	}
 	return true;
@@ -425,6 +848,9 @@ const ARRAY_INDEX_TOKEN_PATTERN = /^(0|[1-9][0-9]*)$/;
 function hasOwn(value, key) {
 	return Object.prototype.hasOwnProperty.call(value, key);
 }
+function isUnsafeObjectKey(key) {
+	return key === "__proto__";
+}
 function pathValueAt(base, path) {
 	if (path.length === 0) return base;
 	return getAtJson(base, path);
@@ -432,17 +858,17 @@ function pathValueAt(base, path) {
 function assertNever$1(_value, message) {
 	throw new Error(message);
 }
-function compileSingleOp(baseJson, op, opIndex, semantics) {
+function compileSingleOp(baseJson, op, opIndex, semantics, pointerCache) {
 	if (op.op === "test") return [{
 		t: "Test",
-		path: parsePointerOrThrow(op.path, op.path, opIndex),
+		path: parsePointerOrThrow(op.path, op.path, opIndex, pointerCache),
 		value: op.value
 	}];
 	if (op.op === "copy" || op.op === "move") {
-		const fromPath = parsePointerOrThrow(op.from, op.from, opIndex);
-		const toPath = parsePointerOrThrow(op.path, op.path, opIndex);
+		const fromPath = parsePointerOrThrow(op.from, op.from, opIndex, pointerCache);
+		const toPath = parsePointerOrThrow(op.path, op.path, opIndex, pointerCache);
 		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);
+		const val = structuredClone(lookupValueOrThrow(baseJson, fromPath, op.from, opIndex));
 		if (op.op === "move" && isSamePath(fromPath, toPath)) return [];
 		if (op.op === "move" && semantics === "sequential") {
 			const removeOp = {
@@ -454,21 +880,21 @@ function compileSingleOp(baseJson, op, opIndex, semantics) {
 				path: op.path,
 				value: val
 			};
-			const baseAfterRemove = applyPatchOpToJson(baseJson, removeOp, opIndex);
-			return [...compileSingleOp(baseJson, removeOp, opIndex, semantics), ...compileSingleOp(baseAfterRemove, addOp, opIndex, semantics)];
+			const baseAfterRemove = applyPatchOpToJson(baseJson, removeOp, opIndex, pointerCache);
+			return [...compileSingleOp(baseJson, removeOp, opIndex, semantics, pointerCache), ...compileSingleOp(baseAfterRemove, addOp, opIndex, semantics, pointerCache)];
 		}
 		const out = compileSingleOp(baseJson, {
 			op: "add",
 			path: op.path,
 			value: val
-		}, opIndex, semantics);
+		}, opIndex, semantics, pointerCache);
 		if (op.op === "move") out.push(...compileSingleOp(baseJson, {
 			op: "remove",
 			path: op.from
-		}, opIndex, semantics));
+		}, opIndex, semantics, pointerCache));
 		return out;
 	}
-	const path = parsePointerOrThrow(op.path, op.path, opIndex);
+	const path = parsePointerOrThrow(op.path, op.path, opIndex, pointerCache);
 	if (path.length === 0) {
 		if (op.op === "replace" || op.op === "add") return [{
 			t: "ObjSet",
@@ -504,6 +930,7 @@ function compileSingleOp(baseJson, op, opIndex, semantics) {
 		return assertNever$1(op, "Unsupported op at array path");
 	}
 	if (!isPlainObject(parentValue)) throw compileError("INVALID_TARGET", `expected object or array parent at ${parentPath}`, parentPath, opIndex);
+	if (isUnsafeObjectKey(token)) throw compileError("INVALID_POINTER", `unsafe object key at ${op.path}`, op.path, opIndex);
 	if ((op.op === "replace" || op.op === "remove") && !hasOwn(parentValue, token)) throw compileError("MISSING_TARGET", `missing key ${token} at ${parentPath}`, op.path, opIndex);
 	if (op.op === "add") return [{
 		t: "ObjSet",
@@ -526,32 +953,31 @@ function compileSingleOp(baseJson, op, opIndex, semantics) {
 	}];
 	return assertNever$1(op, "Unsupported op");
 }
-function applyPatchOpToJson(baseJson, op, opIndex) {
-	let doc = structuredClone(baseJson);
+function applyPatchOpToJson(baseJson, op, opIndex, pointerCache) {
+	return applyPatchOpToJsonInPlace(structuredClone(baseJson), op, opIndex, pointerCache);
+}
+function applyPatchOpToJsonInPlace(doc, op, opIndex, pointerCache) {
 	if (op.op === "test") return doc;
 	if (op.op === "copy" || op.op === "move") {
-		const fromPath = parsePointerOrThrow(op.from, op.from, opIndex);
+		const fromPath = parsePointerOrThrow(op.from, op.from, opIndex, pointerCache);
 		const value = structuredClone(lookupValueOrThrow(doc, fromPath, op.from, opIndex));
-		if (op.op === "move") doc = applyPatchOpToJson(doc, {
+		return applyPatchOpToJsonInPlace(op.op === "move" ? applyPatchOpToJsonInPlace(doc, {
 			op: "remove",
 			path: op.from
-		}, opIndex);
-		return applyPatchOpToJson(doc, {
+		}, opIndex, pointerCache) : doc, {
 			op: "add",
 			path: op.path,
 			value
-		}, opIndex);
+		}, opIndex, pointerCache);
 	}
-	const path = parsePointerOrThrow(op.path, op.path, opIndex);
+	const path = parsePointerOrThrow(op.path, op.path, opIndex, pointerCache);
 	if (path.length === 0) {
 		if (op.op === "add" || op.op === "replace") return structuredClone(op.value);
 		throw compileError("INVALID_TARGET", "remove at root path is not supported in RFC-compliant mode", op.path, opIndex);
 	}
 	const parentPath = path.slice(0, -1);
 	const token = path[path.length - 1];
-	let parent;
-	if (parentPath.length === 0) parent = doc;
-	else parent = lookupValueOrThrow(doc, parentPath, op.path, opIndex);
+	const parent = parentPath.length === 0 ? doc : lookupValueOrThrow(doc, parentPath, op.path, opIndex);
 	if (Array.isArray(parent)) {
 		const index = parseArrayIndexToken(token, op.op, parent.length, op.path, opIndex);
 		if (op.op === "add") {
@@ -567,6 +993,7 @@ function applyPatchOpToJson(baseJson, op, opIndex) {
 		return doc;
 	}
 	if (!isPlainObject(parent)) throw compileError("INVALID_TARGET", `expected object or array parent at ${stringifyJsonPointer(parentPath)}`, op.path, opIndex);
+	if (isUnsafeObjectKey(token)) throw compileError("INVALID_POINTER", `unsafe object key at ${op.path}`, op.path, opIndex);
 	if (op.op === "add" || op.op === "replace") {
 		parent[token] = structuredClone(op.value);
 		return doc;
@@ -574,9 +1001,13 @@ function applyPatchOpToJson(baseJson, op, opIndex) {
 	delete parent[token];
 	return doc;
 }
-function parsePointerOrThrow(ptr, path, opIndex) {
+function parsePointerOrThrow(ptr, path, opIndex, pointerCache) {
+	const cached = pointerCache.get(ptr);
+	if (cached) return cached.slice();
 	try {
-		return parseJsonPointer(ptr);
+		const parsed = parseJsonPointer(ptr);
+		pointerCache.set(ptr, parsed);
+		return parsed.slice();
 	} catch (error) {
 		throw compileError("INVALID_POINTER", error instanceof Error ? error.message : "invalid pointer", path, opIndex);
 	}
@@ -614,26 +1045,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) {
@@ -750,7 +1186,43 @@ function ensureSeqAtPath(head, path, dotForCreate) {
 	if (head.root.kind !== "seq") head.root = newSeq();
 	return head.root;
 }
+function getNodeAtPath(doc, path) {
+	let cur = doc.root;
+	for (const seg of path) {
+		if (cur.kind !== "obj") return;
+		const ent = cur.entries.get(seg);
+		if (!ent) return;
+		cur = ent.node;
+	}
+	return cur;
+}
+function getHeadSeqForBaseArrayIntent(head, path) {
+	const pointer = `/${path.join("/")}`;
+	const headNode = getNodeAtPath(head, path);
+	if (!headNode) return {
+		ok: false,
+		code: 409,
+		reason: "MISSING_PARENT",
+		message: `head array missing at ${pointer}`,
+		path: pointer
+	};
+	if (headNode.kind !== "seq") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_TARGET",
+		message: `expected array at ${pointer}`,
+		path: pointer
+	};
+	return {
+		ok: true,
+		seq: headNode
+	};
+}
 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 +1234,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 +1362,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 +1384,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 +1395,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;
@@ -909,13 +1467,23 @@ function applyObjRemove(head, it, newDot) {
 	objRemove(parentObj, it.key, d);
 	return null;
 }
-function applyArrInsert(base, head, it, newDot, bumpCounterAbove) {
+function applyArrInsert(base, head, it, newDot, bumpCounterAbove, strictParents = false) {
+	const pointer = `/${it.path.join("/")}`;
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) {
+		if (strictParents) return {
+			ok: false,
+			code: 409,
+			reason: "MISSING_PARENT",
+			message: `base array missing at /${it.path.join("/")}`,
+			path: pointer
+		};
 		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,10 +1492,13 @@ 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());
+	newDot();
+	const headSeqRes = getHeadSeqForBaseArrayIntent(head, it.path);
+	if (!headSeqRes.ok) return headSeqRes;
+	const headSeq = headSeqRes.seq;
 	const idx = it.index === Number.POSITIVE_INFINITY ? rgaLinearizeIds(baseSeq).length : it.index;
 	const baseLen = rgaLinearizeIds(baseSeq).length;
 	if (idx < 0 || idx > baseLen) return {
@@ -938,23 +1509,41 @@ 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();
+	newDot();
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) return {
 		ok: false,
@@ -963,7 +1552,9 @@ function applyArrDelete(base, head, it, newDot) {
 		message: `base array missing at /${it.path.join("/")}`,
 		path: `/${it.path.join("/")}`
 	};
-	const headSeq = ensureSeqAtPath(head, it.path, d);
+	const headSeqRes = getHeadSeqForBaseArrayIntent(head, it.path);
+	if (!headSeqRes.ok) return headSeqRes;
+	const headSeq = headSeqRes.seq;
 	const baseId = rgaIdAtIndex(baseSeq, it.index);
 	if (!baseId) return {
 		ok: false,
@@ -972,11 +1563,18 @@ function applyArrDelete(base, head, it, newDot) {
 		message: `no base element at index ${it.index}`,
 		path: `/${it.path.join("/")}/${it.index}`
 	};
+	if (!headSeq.elems.get(baseId)) return {
+		ok: false,
+		code: 409,
+		reason: "MISSING_TARGET",
+		message: `element missing in head lineage at index ${it.index}`,
+		path: `/${it.path.join("/")}/${it.index}`
+	};
 	rgaDelete(headSeq, baseId);
 	return null;
 }
 function applyArrReplace(base, head, it, newDot) {
-	const d = newDot();
+	newDot();
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) return {
 		ok: false,
@@ -985,7 +1583,9 @@ function applyArrReplace(base, head, it, newDot) {
 		message: `base array missing at /${it.path.join("/")}`,
 		path: `/${it.path.join("/")}`
 	};
-	const headSeq = ensureSeqAtPath(head, it.path, d);
+	const headSeqRes = getHeadSeqForBaseArrayIntent(head, it.path);
+	if (!headSeqRes.ok) return headSeqRes;
+	const headSeq = headSeqRes.seq;
 	const baseId = rgaIdAtIndex(baseSeq, it.index);
 	if (!baseId) return {
 		ok: false,
@@ -1014,9 +1614,11 @@ function applyArrReplace(base, head, it, newDot) {
 * @param newDot - A function that generates a unique `Dot` per mutation.
 * @param evalTestAgainst - Whether `test` ops are evaluated against `"head"` or `"base"`.
 * @param bumpCounterAbove - Optional hook that can fast-forward the underlying counter before inserts.
+* @param options - Optional behavior toggles.
+* @param options.strictParents - When `true`, reject array inserts whose base parent path is missing.
 * @returns `{ ok: true }` on success, or `{ ok: false, code: 409, message }` on conflict.
 */
-function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head", bumpCounterAbove) {
+function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head", bumpCounterAbove, options = {}) {
 	for (const it of intents) {
 		let fail = null;
 		switch (it.t) {
@@ -1030,7 +1632,7 @@ function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head
 				fail = applyObjRemove(head, it, newDot);
 				break;
 			case "ArrInsert":
-				fail = applyArrInsert(base, head, it, newDot, bumpCounterAbove);
+				fail = applyArrInsert(base, head, it, newDot, bumpCounterAbove, options.strictParents ?? false);
 				break;
 			case "ArrDelete":
 				fail = applyArrDelete(base, head, it, newDot);
@@ -1044,7 +1646,7 @@ function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head
 	}
 	return { ok: true };
 }
-function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove) {
+function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = false) {
 	if (isJsonPatchToCrdtOptions(baseOrOptions)) return jsonPatchToCrdtInternal(baseOrOptions);
 	if (!head || !patch || !newDot) return {
 		ok: false,
@@ -1058,10 +1660,11 @@ function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "
 		patch,
 		newDot,
 		evalTestAgainst,
-		bumpCounterAbove
+		bumpCounterAbove,
+		strictParents
 	});
 }
-function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove) {
+function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = false) {
 	try {
 		if (isJsonPatchToCrdtOptions(baseOrOptions)) return jsonPatchToCrdt(baseOrOptions);
 		if (!head || !patch || !newDot) return {
@@ -1070,7 +1673,7 @@ function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst
 			reason: "INVALID_PATCH",
 			message: "invalid jsonPatchToCrdtSafe call signature"
 		};
-		return jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst, bumpCounterAbove);
+		return jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst, bumpCounterAbove, strictParents);
 	} catch (error) {
 		return toApplyError$1(error);
 	}
@@ -1108,7 +1711,7 @@ function jsonPatchToCrdtInternal(options) {
 		} catch (error) {
 			return toApplyError$1(error);
 		}
-		return applyIntentsToCrdt(options.base, options.head, intents, options.newDot, evalTestAgainst, options.bumpCounterAbove);
+		return applyIntentsToCrdt(options.base, options.head, intents, options.newDot, evalTestAgainst, options.bumpCounterAbove, { strictParents: options.strictParents });
 	}
 	let shadowBase = cloneDoc(evalTestAgainst === "base" ? options.base : options.head);
 	let shadowCtr = 0;
@@ -1127,10 +1730,10 @@ function jsonPatchToCrdtInternal(options) {
 		} catch (error) {
 			return withOpIndex(toApplyError$1(error), opIndex);
 		}
-		const headStep = applyIntentsToCrdt(shadowBase, options.head, intents, options.newDot, evalTestAgainst, options.bumpCounterAbove);
+		const headStep = applyIntentsToCrdt(shadowBase, options.head, intents, options.newDot, evalTestAgainst, options.bumpCounterAbove, { strictParents: options.strictParents });
 		if (!headStep.ok) return withOpIndex(headStep, opIndex);
 		if (evalTestAgainst === "base") {
-			const shadowStep = applyIntentsToCrdt(shadowBase, shadowBase, intents, shadowDot, "base", shadowBump);
+			const shadowStep = applyIntentsToCrdt(shadowBase, shadowBase, intents, shadowDot, "base", shadowBump, { strictParents: options.strictParents });
 			if (!shadowStep.ok) return withOpIndex(shadowStep, opIndex);
 		} else shadowBase = cloneDoc(options.head);
 		return { ok: true };
@@ -1183,6 +1786,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,
@@ -1233,7 +1837,7 @@ var PatchError = class extends Error {
 function createState(initial, options) {
 	const clock = createClock(options.actor, options.start ?? 0);
 	return {
-		doc: docFromJson(initial, clock.next),
+		doc: docFromJson(coerceRuntimeJsonValue(initial, options.jsonValidation ?? "none"), clock.next),
 		clock
 	};
 }
@@ -1288,11 +1892,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, "batch");
+		if (!result.ok) return {
+			ok: false,
+			error: result
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: toApplyError(error)
+		};
+	}
 	return {
 		ok: true,
 		state: nextState
@@ -1308,11 +1919,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, "step");
+		if (!result.ok) return {
+			ok: false,
+			error: result
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: toApplyError(error)
+		};
+	}
 	return { ok: true };
 }
 /**
@@ -1320,7 +1938,10 @@ function tryApplyPatchInPlace(state, patch, options = {}) {
 * Does not mutate caller-provided values.
 */
 function validateJsonPatch(base, patch, options = {}) {
-	const result = tryApplyPatch(createState(base, { actor: "__validate__" }), patch, options);
+	const result = tryApplyPatch(createState(base, {
+		actor: "__validate__",
+		jsonValidation: options.jsonValidation
+	}), patch, options);
 	if (!result.ok) return {
 		ok: false,
 		error: result.error
@@ -1349,35 +1970,43 @@ function toApplyPatchOptionsForActor(options) {
 	return {
 		semantics: options.semantics,
 		testAgainst: options.testAgainst,
+		strictParents: options.strictParents,
+		jsonValidation: options.jsonValidation,
 		base: options.base ? {
 			doc: options.base,
 			clock: createClock("__base__", 0)
 		} : void 0
 	};
 }
-function applyPatchInternal(state, patch, options) {
+function applyPatchInternal(state, patch, options, execution) {
 	if ((options.semantics ?? "sequential") === "sequential") {
+		if (!options.base && execution === "batch") {
+			const compiled = compileIntents(materialize(state.doc.root), patch, "sequential", options.jsonValidation ?? "none");
+			if (!compiled.ok) return compiled;
+			return applyIntentsToCrdt(state.doc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr), { strictParents: options.strictParents });
+		}
 		const explicitBaseState = options.base ? {
 			doc: cloneDoc(options.base.doc),
 			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], {
 					semantics: "sequential",
-					testAgainst: "base"
-				});
+					testAgainst: "base",
+					strictParents: options.strictParents
+				}, "step");
 				if (!baseStep.ok) return baseStep;
 			}
 		}
 		return { ok: true };
 	}
 	const baseDoc = options.base ? options.base.doc : cloneDoc(state.doc);
-	const compiled = compileIntents(materialize(baseDoc.root), patch, "base");
+	const compiled = compileIntents(materialize(baseDoc.root), patch, "base", options.jsonValidation ?? "none");
 	if (!compiled.ok) return compiled;
-	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr));
+	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr), { strictParents: options.strictParents });
 }
 function applyPatchOpSequential(state, op, options, baseDoc, opIndex) {
 	const baseJson = materialize(baseDoc.root);
@@ -1385,12 +2014,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 +2030,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,49 +2054,94 @@ 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", options.jsonValidation ?? "none");
 	if (!compiled.ok) return compiled;
-	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr));
+	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr), { strictParents: options.strictParents });
 }
 function bumpClockCounter(state, ctr) {
 	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
 }
-function compileIntents(baseJson, patch, semantics = "sequential") {
+function compileIntents(baseJson, patch, semantics = "sequential", jsonValidation = "none") {
 	try {
 		return {
 			ok: true,
-			intents: compileJsonPatchToIntent(baseJson, patch, { semantics })
+			intents: compileJsonPatchToIntent(baseJson, preparePatchPayloads(patch, jsonValidation), { semantics })
 		};
 	} catch (error) {
 		return toApplyError(error);
 	}
 }
+function preparePatchPayloads(patch, mode) {
+	if (mode === "none") return patch;
+	const out = [];
+	for (const [opIndex, op] of patch.entries()) {
+		if (op.op === "move" || op.op === "copy" || op.op === "remove") {
+			out.push(op);
+			continue;
+		}
+		if (mode === "strict") {
+			try {
+				assertRuntimeJsonValue(op.value);
+			} catch (error) {
+				if (error instanceof JsonValueValidationError) throw patchPayloadCompileError(op, opIndex, error);
+				throw error;
+			}
+			out.push(op);
+			continue;
+		}
+		out.push({
+			...op,
+			value: coerceRuntimeJsonValue(op.value, mode)
+		});
+	}
+	return out;
+}
+function patchPayloadCompileError(op, opIndex, error) {
+	const path = mergePointerPaths(op.path, error.path);
+	return new PatchCompileError("INVALID_PATCH", `invalid JSON value for '${op.op}' at ${path === "" ? "<root>" : path}: ${error.detail}`, path, opIndex);
+}
+function mergePointerPaths(basePointer, nestedPointer) {
+	if (nestedPointer === "") return basePointer;
+	if (basePointer === "") return nestedPointer;
+	return `${basePointer}${nestedPointer}`;
+}
 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 +2181,38 @@ function toPointerLookupApplyError(error, pointer, opIndex) {
 
 //#endregion
 //#region src/serialize.ts
+const HEAD_ELEM_ID = "HEAD";
+function createSerializedRecord() {
+	return Object.create(null);
+}
+function setSerializedRecordValue(out, key, value) {
+	Object.defineProperty(out, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
+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 +2226,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
@@ -1542,27 +2246,27 @@ function serializeNode(node) {
 		}
 	};
 	if (node.kind === "obj") {
-		const entries = {};
-		for (const [k, v] of node.entries.entries()) entries[k] = {
+		const entries = createSerializedRecord();
+		for (const [k, v] of node.entries.entries()) setSerializedRecordValue(entries, k, {
 			node: serializeNode(v.node),
 			dot: {
 				actor: v.dot.actor,
 				ctr: v.dot.ctr
 			}
-		};
-		const tombstone = {};
-		for (const [k, d] of node.tombstone.entries()) tombstone[k] = {
+		});
+		const tombstone = createSerializedRecord();
+		for (const [k, d] of node.tombstone.entries()) setSerializedRecordValue(tombstone, k, {
 			actor: d.actor,
 			ctr: d.ctr
-		};
+		});
 		return {
 			kind: "obj",
 			entries,
 			tombstone
 		};
 	}
-	const elems = {};
-	for (const [id, e] of node.elems.entries()) elems[id] = {
+	const elems = createSerializedRecord();
+	for (const [id, e] of node.elems.entries()) setSerializedRecordValue(elems, id, {
 		id: e.id,
 		prev: e.prev,
 		tombstone: e.tombstone,
@@ -1571,60 +2275,138 @@ function serializeNode(node) {
 			actor: e.insDot.actor,
 			ctr: e.insDot.ctr
 		}
-	};
+	});
 	return {
 		kind: "seq",
 		elems
 	};
 }
-function deserializeNode(node) {
-	if (node.kind === "lww") return {
-		kind: "lww",
-		value: structuredClone(node.value),
-		dot: {
-			actor: node.dot.actor,
-			ctr: node.dot.ctr
-		}
-	};
-	if (node.kind === "obj") {
+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 +2416,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 +2440,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 +2505,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 +2552,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 +2608,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 +2630,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 +2648,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 +2669,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 +2687,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 +2723,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 +2736,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 +2746,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 { rgaInsertAfter as $, jsonPatchToCrdtSafe as A, JsonValueValidationError as B, applyIntentsToCrdt as C, docFromJson as D, crdtToJsonPatch as E, getAtJson as F, objCompactTombstones as G, newObj as H, jsonEquals as I, materialize as J, objRemove as K, parseJsonPointer as L, PatchCompileError as M, compileJsonPatchToIntent as N, docFromJsonWithDot as O, diffJsonPatch as P, rgaIdAtIndex as Q, stringifyJsonPointer as R, validateJsonPatch as S, crdtToFullReplace as T, newReg as U, lwwSet as V, newSeq as W, rgaCompactTombstones as X, HEAD as Y, rgaDelete as Z, createState as _, mergeState as a, vvMerge as at, tryApplyPatch as b, DeserializeError as c, ClockValidationError as ct, serializeDoc as d, nextDotForActor as dt, rgaLinearizeIds as et, serializeState as f, observeDot as ft, applyPatchInPlace as g, applyPatchAsActor as h, mergeDoc as i, vvHasDot as it, tryJsonPatchToCrdt as j, jsonPatchToCrdt as k, deserializeDoc as l, cloneClock as lt, applyPatch as m, compactStateTombstones as n, compareDot as nt, tryMergeDoc as o, MAX_TRAVERSAL_DEPTH as ot, PatchError as p, objSet as q, MergeError as r, dotToElemId as rt, tryMergeState as s, TraversalDepthError as st, compactDocTombstones as t, rgaPrevForInsertAtIndex as tt, deserializeState as u, createClock as ut, forkState as v, cloneDoc as w, tryApplyPatchInPlace as x, toJson as y, ROOT_KEY as z };