json-patch-to-crdt 0.1.1 → 0.1.3

package/dist/{merge-BAfuC6bf.js → compact-DoM9CJNR.js}

@@ -1,11 +1,34 @@
 
 //#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,
@@ -19,6 +42,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);
@@ -28,8 +57,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
@@ -37,21 +66,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) {
@@ -85,15 +155,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
@@ -118,6 +199,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];
 }
@@ -129,17 +265,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
@@ -184,6 +414,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
@@ -195,6 +587,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;
@@ -208,6 +601,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 `""`).
@@ -254,14 +658,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;
 }
 /**
@@ -275,12 +680,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;
 }
@@ -294,15 +700,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({
@@ -338,7 +755,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));
@@ -378,6 +795,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++) {
@@ -414,7 +837,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;
@@ -426,6 +849,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);
@@ -433,17 +859,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 = {
@@ -455,21 +881,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",
@@ -505,6 +931,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",
@@ -527,32 +954,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") {
@@ -568,6 +994,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;
@@ -575,9 +1002,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);
 	}
@@ -615,26 +1046,31 @@ function compileErrorFromLookup(error, path, opIndex) {
 	return compileError(mapped.reason, mapped.message, path, opIndex);
 }
 function mapLookupErrorToPatchReason(error) {
-	const message = error instanceof Error ? error.message : "invalid path";
-	if (message.includes("Expected array index")) return {
-		reason: "INVALID_POINTER",
-		message
-	};
-	if (message.includes("Index out of bounds")) return {
-		reason: "OUT_OF_BOUNDS",
-		message
-	};
-	if (message.includes("Missing key")) return {
-		reason: "MISSING_PARENT",
-		message
-	};
-	if (message.includes("Cannot traverse into non-container")) return {
-		reason: "INVALID_TARGET",
-		message
-	};
+	if (error instanceof JsonLookupError) switch (error.code) {
+		case "EXPECTED_ARRAY_INDEX": return {
+			reason: "INVALID_POINTER",
+			message: error.message
+		};
+		case "INDEX_OUT_OF_BOUNDS": return {
+			reason: "OUT_OF_BOUNDS",
+			message: error.message
+		};
+		case "MISSING_KEY": return {
+			reason: "MISSING_PARENT",
+			message: error.message
+		};
+		case "NON_CONTAINER": return {
+			reason: "INVALID_TARGET",
+			message: error.message
+		};
+		default: return {
+			reason: "INVALID_PATCH",
+			message: error.message
+		};
+	}
 	return {
 		reason: "INVALID_PATCH",
-		message
+		message: error instanceof Error ? error.message : "invalid path"
 	};
 }
 function compileError(reason, message, path, opIndex) {
@@ -751,7 +1187,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();
@@ -763,40 +1235,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),
@@ -808,7 +1363,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
@@ -830,7 +1385,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
@@ -841,6 +1396,9 @@ function cloneNode(node) {
 		elems
 	};
 }
+function isJsonPrimitive(value) {
+	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
 function applyTest(base, head, it, evalTestAgainst) {
 	const snapshot = evalTestAgainst === "head" ? materialize(head.root) : materialize(base.root);
 	let got;
@@ -910,13 +1468,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;
 		}
@@ -925,10 +1493,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 {
@@ -939,23 +1510,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,
@@ -964,7 +1553,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,
@@ -973,11 +1564,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,
@@ -986,7 +1584,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,
@@ -1015,9 +1615,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) {
@@ -1031,7 +1633,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);
@@ -1045,7 +1647,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,
@@ -1059,10 +1661,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 {
@@ -1071,7 +1674,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);
 	}
@@ -1109,7 +1712,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;
@@ -1128,10 +1731,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 };
@@ -1184,6 +1787,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,
@@ -1234,7 +1838,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
 	};
 }
@@ -1289,11 +1893,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
@@ -1309,11 +1920,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 };
 }
 /**
@@ -1321,7 +1939,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
@@ -1350,35 +1971,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);
@@ -1386,12 +2015,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
@@ -1401,13 +2031,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;
@@ -1425,49 +2055,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,
@@ -1507,13 +2182,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) {
@@ -1527,7 +2227,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
@@ -1543,27 +2247,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,
@@ -1572,60 +2276,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;
@@ -1635,7 +2417,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;
 	}
 };
@@ -1659,21 +2441,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.
@@ -1706,25 +2506,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;
@@ -1736,28 +2553,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) {
@@ -1782,11 +2609,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 {
@@ -1800,7 +2631,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()]);
@@ -1817,15 +2649,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);
@@ -1838,14 +2670,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,
@@ -1853,24 +2688,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",
@@ -1880,7 +2724,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();
@@ -1893,7 +2737,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
@@ -1903,12 +2747,115 @@ function cloneNodeShallow(node) {
 }
 
 //#endregion
+//#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
+Object.defineProperty(exports, 'ClockValidationError', {
+  enumerable: true,
+  get: function () {
+    return ClockValidationError;
+  }
+});
+Object.defineProperty(exports, 'DeserializeError', {
+  enumerable: true,
+  get: function () {
+    return DeserializeError;
+  }
+});
 Object.defineProperty(exports, 'HEAD', {
   enumerable: true,
   get: function () {
     return HEAD;
   }
 });
+Object.defineProperty(exports, 'JsonValueValidationError', {
+  enumerable: true,
+  get: function () {
+    return JsonValueValidationError;
+  }
+});
+Object.defineProperty(exports, 'MAX_TRAVERSAL_DEPTH', {
+  enumerable: true,
+  get: function () {
+    return MAX_TRAVERSAL_DEPTH;
+  }
+});
 Object.defineProperty(exports, 'MergeError', {
   enumerable: true,
   get: function () {
@@ -1933,6 +2880,12 @@ Object.defineProperty(exports, 'ROOT_KEY', {
     return ROOT_KEY;
   }
 });
+Object.defineProperty(exports, 'TraversalDepthError', {
+  enumerable: true,
+  get: function () {
+    return TraversalDepthError;
+  }
+});
 Object.defineProperty(exports, 'applyIntentsToCrdt', {
   enumerable: true,
   get: function () {
@@ -1969,6 +2922,18 @@ Object.defineProperty(exports, 'cloneDoc', {
     return cloneDoc;
   }
 });
+Object.defineProperty(exports, 'compactDocTombstones', {
+  enumerable: true,
+  get: function () {
+    return compactDocTombstones;
+  }
+});
+Object.defineProperty(exports, 'compactStateTombstones', {
+  enumerable: true,
+  get: function () {
+    return compactStateTombstones;
+  }
+});
 Object.defineProperty(exports, 'compareDot', {
   enumerable: true,
   get: function () {
@@ -2119,6 +3084,12 @@ Object.defineProperty(exports, 'nextDotForActor', {
     return nextDotForActor;
   }
 });
+Object.defineProperty(exports, 'objCompactTombstones', {
+  enumerable: true,
+  get: function () {
+    return objCompactTombstones;
+  }
+});
 Object.defineProperty(exports, 'objRemove', {
   enumerable: true,
   get: function () {
@@ -2143,6 +3114,12 @@ Object.defineProperty(exports, 'parseJsonPointer', {
     return parseJsonPointer;
   }
 });
+Object.defineProperty(exports, 'rgaCompactTombstones', {
+  enumerable: true,
+  get: function () {
+    return rgaCompactTombstones;
+  }
+});
 Object.defineProperty(exports, 'rgaDelete', {
   enumerable: true,
   get: function () {