json-patch-to-crdt 0.2.0 → 0.4.0

package/dist/{compact-BE9UsxEo.mjs → compact-BcwxBNx_.mjs}

@@ -1,18 +1,37 @@
-//#region src/clock.ts
-var ClockValidationError = class extends TypeError {
-	reason;
-	constructor(reason, message) {
-		super(message);
-		this.name = "ClockValidationError";
-		this.reason = reason;
+//#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 readVvCounter$1(vv, actor) {
-	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return 0;
+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/version-vector.ts
+function readVersionVectorCounter(vv, actor) {
+	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return;
 	const counter = vv[actor];
-	return typeof counter === "number" ? counter : 0;
+	return typeof counter === "number" ? counter : void 0;
 }
-function writeVvCounter$1(vv, actor, counter) {
+function writeVersionVectorCounter(vv, actor, counter) {
 	Object.defineProperty(vv, actor, {
 		configurable: true,
 		enumerable: true,
@@ -20,6 +39,104 @@ function writeVvCounter$1(vv, actor, counter) {
 		writable: true
 	});
 }
+function observeVersionVectorDot(vv, dot) {
+	if ((readVersionVectorCounter(vv, dot.actor) ?? 0) < dot.ctr) writeVersionVectorCounter(vv, dot.actor, dot.ctr);
+}
+/**
+* Inspect a document or state and return the highest observed counter per actor.
+*
+* When a `CrdtState` is provided, the returned vector is also seeded from the
+* state's local clock so callers do not lose counters that have advanced ahead
+* of the currently materialized document tree.
+*/
+function observedVersionVector(target) {
+	const doc = "doc" in target ? target.doc : target;
+	const vv = Object.create(null);
+	if ("clock" in target) observeVersionVectorDot(vv, {
+		actor: target.clock.actor,
+		ctr: target.clock.ctr
+	});
+	const stack = [{
+		node: doc.root,
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (frame.node.kind === "lww") {
+			observeVersionVectorDot(vv, frame.node.dot);
+			continue;
+		}
+		if (frame.node.kind === "obj") {
+			for (const entry of frame.node.entries.values()) {
+				observeVersionVectorDot(vv, entry.dot);
+				stack.push({
+					node: entry.node,
+					depth: frame.depth + 1
+				});
+			}
+			for (const tombstone of frame.node.tombstone.values()) observeVersionVectorDot(vv, tombstone);
+			continue;
+		}
+		for (const elem of frame.node.elems.values()) {
+			observeVersionVectorDot(vv, elem.insDot);
+			if (elem.delDot) observeVersionVectorDot(vv, elem.delDot);
+			stack.push({
+				node: elem.value,
+				depth: frame.depth + 1
+			});
+		}
+	}
+	return vv;
+}
+/** Combine version vectors using per-actor maxima. */
+function mergeVersionVectors(...vectors) {
+	const merged = Object.create(null);
+	for (const vv of vectors) for (const actor of Object.keys(vv)) {
+		const counter = readVersionVectorCounter(vv, actor);
+		if (counter === void 0) continue;
+		writeVersionVectorCounter(merged, actor, Math.max(readVersionVectorCounter(merged, actor) ?? 0, counter));
+	}
+	return merged;
+}
+/**
+* Derive a causally-stable checkpoint by taking the per-actor minimum.
+*
+* When called with a single vector the result equals that vector. In practice,
+* a meaningful shared-stability checkpoint usually needs acknowledgements from
+* at least two peers or from an explicit quorum.
+*/
+function intersectVersionVectors(...vectors) {
+	if (vectors.length === 0) return Object.create(null);
+	const actors = /* @__PURE__ */ new Set();
+	for (const vv of vectors) for (const actor of Object.keys(vv)) actors.add(actor);
+	const intersection = Object.create(null);
+	for (const actor of actors) {
+		const counters = vectors.map((vv) => readVersionVectorCounter(vv, actor) ?? 0);
+		const counter = Math.min(...counters);
+		if (counter > 0) writeVersionVectorCounter(intersection, actor, counter);
+	}
+	return intersection;
+}
+/** Check whether one version vector has observed every counter in another. */
+function versionVectorCovers(observed, required) {
+	for (const actor of Object.keys(required)) {
+		const requiredCounter = readVersionVectorCounter(required, actor) ?? 0;
+		if ((readVersionVectorCounter(observed, actor) ?? 0) < requiredCounter) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/clock.ts
+var ClockValidationError = class extends TypeError {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.name = "ClockValidationError";
+		this.reason = reason;
+	}
+};
 /**
 * Create a new clock for the given actor. Each call to `clock.next()` yields a fresh `Dot`.
 * @param actor - Unique identifier for this peer.
@@ -56,8 +173,8 @@ function cloneClock(clock) {
 * Useful when a server needs to mint dots for many actors.
 */
 function nextDotForActor(vv, actor) {
-	const ctr = readVvCounter$1(vv, actor) + 1;
-	writeVvCounter$1(vv, actor, ctr);
+	const ctr = (readVersionVectorCounter(vv, actor) ?? 0) + 1;
+	writeVersionVectorCounter(vv, actor, ctr);
 	return {
 		actor,
 		ctr
@@ -65,63 +182,20 @@ function nextDotForActor(vv, actor) {
 }
 /** Record an observed dot in a version vector. */
 function observeDot(vv, dot) {
-	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
-	};
+	observeVersionVectorDot(vv, dot);
 }
 
 //#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 (readVvCounter(vv, d.actor) ?? 0) >= d.ctr;
+	return (readVersionVectorCounter(vv, d.actor) ?? 0) >= d.ctr;
 }
 function vvMerge(a, b) {
-	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;
+	return mergeVersionVectors(a, b);
 }
 function dotToElemId(d) {
 	return `${d.actor}:${d.ctr}`;
@@ -132,12 +206,31 @@ function dotToElemId(d) {
 const HEAD = "HEAD";
 const linearCache = /* @__PURE__ */ new WeakMap();
 const seqVersion = /* @__PURE__ */ new WeakMap();
+const maxSiblingInsDotByPrevCache = /* @__PURE__ */ new WeakMap();
 function getVersion(seq) {
 	return seqVersion.get(seq) ?? 0;
 }
 function bumpVersion(seq) {
 	seqVersion.set(seq, getVersion(seq) + 1);
 }
+function buildMaxSiblingInsDotByPrevIndex(seq) {
+	const index = /* @__PURE__ */ new Map();
+	for (const elem of seq.elems.values()) {
+		const current = index.get(elem.prev);
+		if (!current || compareDot(elem.insDot, current) > 0) index.set(elem.prev, elem.insDot);
+	}
+	maxSiblingInsDotByPrevCache.set(seq, index);
+	return index;
+}
+function getMaxSiblingInsDotByPrevIndex(seq) {
+	return maxSiblingInsDotByPrevCache.get(seq) ?? buildMaxSiblingInsDotByPrevIndex(seq);
+}
+function trackInsertedSiblingDot(seq, prev, insDot) {
+	const index = maxSiblingInsDotByPrevCache.get(seq);
+	if (!index) return;
+	const current = index.get(prev);
+	if (!current || compareDot(insDot, current) > 0) index.set(prev, insDot);
+}
 function rgaChildrenIndex(seq) {
 	const idx = /* @__PURE__ */ new Map();
 	for (const e of seq.elems.values()) {
@@ -186,6 +279,36 @@ function rgaLinearizeIds(seq) {
 	});
 	return [...out];
 }
+function rgaLength(seq) {
+	const ver = getVersion(seq);
+	const cached = linearCache.get(seq);
+	if (cached && cached.version === ver) return cached.ids.length;
+	return rgaLinearizeIds(seq).length;
+}
+function rgaCreateIndexedIdSnapshot(seq) {
+	const ids = rgaLinearizeIds(seq);
+	return {
+		length() {
+			return ids.length;
+		},
+		idAt(index) {
+			return ids[index];
+		},
+		prevForInsertAt(index) {
+			if (index <= 0) return HEAD;
+			return ids[index - 1] ?? (ids.length > 0 ? ids[ids.length - 1] : HEAD);
+		},
+		insertAt(index, id) {
+			const at = Math.max(0, Math.min(index, ids.length));
+			ids.splice(at, 0, id);
+		},
+		deleteAt(index) {
+			if (index < 0 || index >= ids.length) return;
+			const [removed] = ids.splice(index, 1);
+			return removed;
+		}
+	};
+}
 function rgaInsertAfter(seq, prev, id, insDot, value) {
 	if (seq.elems.has(id)) return;
 	seq.elems.set(id, {
@@ -195,15 +318,110 @@ function rgaInsertAfter(seq, prev, id, insDot, value) {
 		value,
 		insDot
 	});
+	trackInsertedSiblingDot(seq, prev, insDot);
 	bumpVersion(seq);
 }
-function rgaDelete(seq, id) {
+function rgaInsertAfterChecked(seq, prev, id, insDot, value) {
+	if (seq.elems.has(id)) return;
+	if (prev !== HEAD && !seq.elems.has(prev)) throw new Error(`RGA predecessor '${prev}' does not exist`);
+	rgaInsertAfter(seq, prev, id, insDot, value);
+}
+function rgaDelete(seq, id, delDot) {
 	const e = seq.elems.get(id);
 	if (!e) return;
-	if (e.tombstone) return;
+	if (e.tombstone) {
+		if (delDot && (!e.delDot || compareDot(delDot, e.delDot) > 0)) {
+			e.delDot = {
+				actor: delDot.actor,
+				ctr: delDot.ctr
+			};
+			bumpVersion(seq);
+		}
+		return;
+	}
 	e.tombstone = true;
+	if (delDot) e.delDot = {
+		actor: delDot.actor,
+		ctr: delDot.ctr
+	};
 	bumpVersion(seq);
 }
+function validateRgaSeq(seq) {
+	const issues = [];
+	for (const elem of seq.elems.values()) if (elem.prev !== HEAD && !seq.elems.has(elem.prev)) issues.push({
+		code: "MISSING_PREDECESSOR",
+		id: elem.id,
+		prev: elem.prev,
+		message: `RGA element '${elem.id}' references missing predecessor '${elem.prev}'`
+	});
+	const cycleIds = /* @__PURE__ */ new Set();
+	const visitState = /* @__PURE__ */ new Map();
+	const sortedIds = [...seq.elems.keys()].sort();
+	for (const startId of sortedIds) {
+		if (visitState.get(startId) === 2) continue;
+		const trail = [];
+		const trailIndex = /* @__PURE__ */ new Map();
+		let currentId = startId;
+		while (currentId !== void 0) {
+			const seenAt = trailIndex.get(currentId);
+			if (seenAt !== void 0) {
+				for (let i = seenAt; i < trail.length; i++) cycleIds.add(trail[i]);
+				break;
+			}
+			if (visitState.get(currentId) === 2) break;
+			const elem = seq.elems.get(currentId);
+			if (!elem) break;
+			trailIndex.set(currentId, trail.length);
+			trail.push(currentId);
+			if (elem.prev === HEAD) break;
+			currentId = elem.prev;
+		}
+		for (const id of trail) visitState.set(id, 2);
+	}
+	for (const id of [...cycleIds].sort()) {
+		const elem = seq.elems.get(id);
+		issues.push({
+			code: "PREDECESSOR_CYCLE",
+			id,
+			prev: elem.prev,
+			message: `RGA predecessor cycle detected at '${id}'`
+		});
+	}
+	const children = rgaChildrenIndex(seq);
+	const reachable = /* @__PURE__ */ new Set();
+	const stack = [...children.get(HEAD) ?? []];
+	while (stack.length > 0) {
+		const elem = stack.pop();
+		if (reachable.has(elem.id)) continue;
+		reachable.add(elem.id);
+		const descendants = children.get(elem.id);
+		if (descendants) stack.push(...descendants);
+	}
+	for (const id of sortedIds) {
+		if (reachable.has(id)) continue;
+		const elem = seq.elems.get(id);
+		issues.push({
+			code: "ORPHANED_ELEMENT",
+			id,
+			prev: elem.prev,
+			message: `RGA element '${id}' is unreachable from HEAD`
+		});
+	}
+	if (issues.length === 0) return {
+		ok: true,
+		issues: []
+	};
+	const issueOrder = {
+		MISSING_PREDECESSOR: 0,
+		PREDECESSOR_CYCLE: 1,
+		ORPHANED_ELEMENT: 2
+	};
+	issues.sort((a, b) => a.id.localeCompare(b.id) || issueOrder[a.code] - issueOrder[b.code] || a.prev.localeCompare(b.prev));
+	return {
+		ok: false,
+		issues
+	};
+}
 /**
 * Prune tombstoned elements that are causally stable and have no live descendants
 * depending on them for sequence traversal.
@@ -250,15 +468,19 @@ function rgaCompactTombstones(seq, isStable) {
 			continue;
 		}
 		const elem = seq.elems.get(frame.id);
-		if (!elem || !elem.tombstone || !isStable(elem.insDot)) continue;
+		if (!elem || !elem.tombstone || !elem.delDot || !isStable(elem.delDot)) 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);
+	maxSiblingInsDotByPrevCache.delete(seq);
 	bumpVersion(seq);
 	return removable.size;
 }
+function rgaMaxInsertDotForPrev(seq, prev) {
+	return getMaxSiblingInsDotByPrevIndex(seq).get(prev) ?? null;
+}
 function rgaIdAtIndex(seq, index) {
 	return rgaLinearizeIds(seq)[index];
 }
@@ -270,6 +492,7 @@ function rgaPrevForInsertAtIndex(seq, index) {
 
 //#endregion
 //#region src/materialize.ts
+let materializeObserver = null;
 function createMaterializedObject() {
 	return Object.create(null);
 }
@@ -283,6 +506,8 @@ function setMaterializedProperty(out, key, value) {
 }
 /** Convert a CRDT node graph into a plain JSON value using an explicit stack. */
 function materialize(node) {
+	const observer = materializeObserver;
+	observer?.([], node);
 	if (node.kind === "lww") return node.value;
 	const root = node.kind === "obj" ? createMaterializedObject() : [];
 	const stack = [];
@@ -290,13 +515,16 @@ function materialize(node) {
 		kind: "obj",
 		depth: 0,
 		entries: node.entries.entries(),
-		out: root
+		out: root,
+		path: []
 	});
 	else stack.push({
 		kind: "seq",
 		depth: 0,
 		cursor: rgaCreateLinearCursor(node),
-		out: root
+		out: root,
+		path: [],
+		nextIndex: 0
 	});
 	while (stack.length > 0) {
 		const frame = stack[stack.length - 1];
@@ -310,6 +538,8 @@ function materialize(node) {
 			const child = entry.node;
 			const childDepth = frame.depth + 1;
 			assertTraversalDepth(childDepth);
+			const childPath = [...frame.path, key];
+			observer?.(childPath, child);
 			if (child.kind === "lww") {
 				setMaterializedProperty(frame.out, key, child.value);
 				continue;
@@ -321,7 +551,8 @@ function materialize(node) {
 					kind: "obj",
 					depth: childDepth,
 					entries: child.entries.entries(),
-					out: outObj
+					out: outObj,
+					path: childPath
 				});
 				continue;
 			}
@@ -331,7 +562,9 @@ function materialize(node) {
 				kind: "seq",
 				depth: childDepth,
 				cursor: rgaCreateLinearCursor(child),
-				out: outArr
+				out: outArr,
+				path: childPath,
+				nextIndex: 0
 			});
 			continue;
 		}
@@ -343,6 +576,9 @@ function materialize(node) {
 		const child = elem.value;
 		const childDepth = frame.depth + 1;
 		assertTraversalDepth(childDepth);
+		const childPath = [...frame.path, String(frame.nextIndex)];
+		frame.nextIndex += 1;
+		observer?.(childPath, child);
 		if (child.kind === "lww") {
 			frame.out.push(child.value);
 			continue;
@@ -354,7 +590,8 @@ function materialize(node) {
 				kind: "obj",
 				depth: childDepth,
 				entries: child.entries.entries(),
-				out: outObj
+				out: outObj,
+				path: childPath
 			});
 			continue;
 		}
@@ -364,7 +601,9 @@ function materialize(node) {
 			kind: "seq",
 			depth: childDepth,
 			cursor: rgaCreateLinearCursor(child),
-			out: outArr
+			out: outArr,
+			path: childPath,
+			nextIndex: 0
 		});
 	}
 	return root;
@@ -475,6 +714,7 @@ function assertRuntimeJsonValue(value) {
 /**
 * Normalize a runtime value to JSON-compatible data.
 * - non-finite numbers -> null
+* - non-plain objects -> null at the root / in arrays, omitted from object properties
 * - invalid object-property values -> key omitted
 * - invalid root / array values -> null
 */
@@ -561,7 +801,10 @@ function isJsonPrimitive$1(value) {
 	return typeof value === "number" && Number.isFinite(value);
 }
 function isJsonObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || Object.getPrototypeOf(prototype) === null;
 }
 function isNonFiniteNumber(value) {
 	return typeof value === "number" && !Number.isFinite(value);
@@ -572,8 +815,16 @@ function describeInvalidValue(value) {
 	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";
+	if (typeof value === "object" && value !== null) return `non-plain object (${describeObjectKind(value)}) is not valid JSON`;
 	return `unsupported value type (${typeof value})`;
 }
+function describeObjectKind(value) {
+	const tag = Object.prototype.toString.call(value).slice(8, -1);
+	if (tag !== "Object") return tag;
+	const constructor = value.constructor;
+	if (typeof constructor === "function" && constructor.name !== "" && constructor.name !== "Object") return constructor.name;
+	return "Object";
+}
 
 //#endregion
 //#region src/types.ts
@@ -586,6 +837,7 @@ const ROOT_KEY = "@@crdt/root";
 //#endregion
 //#region src/patch.ts
 const DEFAULT_LCS_MAX_CELLS = 25e4;
+const LINEAR_LCS_MATRIX_BASE_CASE_MAX_CELLS = 4096;
 /** Structured compile error used to map patch validation failures to typed reasons. */
 var PatchCompileError = class extends Error {
 	reason;
@@ -676,22 +928,37 @@ function getAtJson(base, path) {
 * @returns An array of `IntentOp` ready for `applyIntentsToCrdt`.
 */
 function compileJsonPatchToIntent(baseJson, patch, options = {}) {
+	const internalOptions = options;
 	const semantics = options.semantics ?? "sequential";
+	const opIndexOffset = internalOptions.opIndexOffset ?? 0;
 	let workingBase = baseJson;
-	const pointerCache = /* @__PURE__ */ new Map();
+	const pointerCache = internalOptions.pointerCache ?? /* @__PURE__ */ new Map();
 	const intents = [];
 	for (let opIndex = 0; opIndex < patch.length; opIndex++) {
 		const op = patch[opIndex];
+		const absoluteOpIndex = opIndex + opIndexOffset;
 		const compileBase = semantics === "sequential" ? workingBase : baseJson;
-		intents.push(...compileSingleOp(compileBase, op, opIndex, semantics, pointerCache));
-		if (semantics === "sequential") workingBase = applyPatchOpToJsonWithStructuralSharing(workingBase, op, opIndex, pointerCache);
+		intents.push(...compileSingleOp(compileBase, op, absoluteOpIndex, semantics, pointerCache));
+		if (semantics === "sequential") workingBase = applyPatchOpToJsonWithStructuralSharing(workingBase, op, absoluteOpIndex, pointerCache);
 	}
 	return intents;
 }
+/** Compile a single JSON Patch operation into CRDT intents. */
+function compileJsonPatchOpToIntent(baseJson, op, options = {}) {
+	const internalOptions = options;
+	const semantics = options.semantics ?? "sequential";
+	const pointerCache = internalOptions.pointerCache ?? /* @__PURE__ */ new Map();
+	return compileSingleOp(baseJson, op, internalOptions.opIndexOffset ?? 0, semantics, pointerCache);
+}
 /**
 * Compute a JSON Patch delta between two JSON values.
 * By default arrays use a deterministic LCS strategy.
 * Pass `{ arrayStrategy: "atomic" }` for single-op array replacement.
+* Pass `{ arrayStrategy: "lcs-linear" }` for a lower-memory LCS variant.
+* Use `lcsLinearMaxCells` to optionally cap worst-case `lcs-linear` work and
+* fall back to an atomic array replacement for very large unmatched windows.
+* Pass `{ emitMoves: true }` or `{ emitCopies: true }` to opt into RFC 6902
+* move/copy emission when a deterministic rewrite is available.
 * @param base - The original JSON value.
 * @param next - The target JSON value.
 * @param options - Diff options.
@@ -706,175 +973,457 @@ function diffJsonPatch(base, next, 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)) {
-			if (!diffArray(path, base, next, ops, options.lcsMaxCells)) ops.push({
+	const stack = [{
+		kind: "value",
+		base,
+		next
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		if (frame.kind === "path-pop") {
+			path.pop();
+			continue;
+		}
+		if (frame.kind === "object") {
+			if (frame.index >= frame.sharedKeys.length) continue;
+			const key = frame.sharedKeys[frame.index];
+			stack.push({
+				kind: "object",
+				base: frame.base,
+				next: frame.next,
+				sharedKeys: frame.sharedKeys,
+				index: frame.index + 1
+			});
+			path.push(key);
+			stack.push({ kind: "path-pop" });
+			stack.push({
+				kind: "value",
+				base: frame.base[key],
+				next: frame.next[key]
+			});
+			continue;
+		}
+		assertTraversalDepth(path.length);
+		if (frame.base === frame.next) continue;
+		const baseIsArray = Array.isArray(frame.base);
+		const nextIsArray = Array.isArray(frame.next);
+		if (baseIsArray || nextIsArray) {
+			if (!baseIsArray || !nextIsArray) {
+				ops.push({
+					op: "replace",
+					path: stringifyJsonPointer(path),
+					value: frame.next
+				});
+				continue;
+			}
+			if (jsonEquals(frame.base, frame.next)) continue;
+			const arrayStrategy = options.arrayStrategy ?? "lcs";
+			if (arrayStrategy === "lcs") {
+				if (!diffArrayWithLcsMatrix(path, frame.base, frame.next, ops, options)) ops.push({
+					op: "replace",
+					path: stringifyJsonPointer(path),
+					value: frame.next
+				});
+				continue;
+			}
+			if (arrayStrategy === "lcs-linear") {
+				if (!diffArrayWithLinearLcs(path, frame.base, frame.next, ops, options)) ops.push({
+					op: "replace",
+					path: stringifyJsonPointer(path),
+					value: frame.next
+				});
+				continue;
+			}
+			ops.push({
 				op: "replace",
 				path: stringifyJsonPointer(path),
-				value: next
+				value: frame.next
 			});
-			return;
+			continue;
 		}
-		ops.push({
-			op: "replace",
-			path: stringifyJsonPointer(path),
-			value: next
-		});
-		return;
-	}
-	if (!isPlainObject(base) || !isPlainObject(next)) {
-		ops.push({
-			op: "replace",
-			path: stringifyJsonPointer(path),
-			value: next
+		const baseIsObject = isPlainObject(frame.base);
+		const nextIsObject = isPlainObject(frame.next);
+		if (!baseIsObject || !nextIsObject) {
+			ops.push({
+				op: "replace",
+				path: stringifyJsonPointer(path),
+				value: frame.next
+			});
+			continue;
+		}
+		const { sharedKeys, baseOnlyKeys, nextOnlyKeys } = collectObjectKeys(frame.base, frame.next);
+		if (!(baseOnlyKeys.length > 0 || nextOnlyKeys.length > 0) && (path.length === 0 || sharedKeys.length > 1) && jsonEquals(frame.base, frame.next)) continue;
+		emitObjectStructuralOps(path, frame.base, frame.next, sharedKeys, baseOnlyKeys, nextOnlyKeys, ops, options);
+		if (sharedKeys.length > 0) stack.push({
+			kind: "object",
+			base: frame.base,
+			next: frame.next,
+			sharedKeys,
+			index: 0
 		});
-		return;
 	}
+}
+function collectObjectKeys(base, next) {
 	const baseKeys = Object.keys(base).sort();
 	const nextKeys = Object.keys(next).sort();
+	const baseOnlyKeys = [];
+	const nextOnlyKeys = [];
+	const sharedKeys = [];
 	let baseIndex = 0;
 	let nextIndex = 0;
 	while (baseIndex < baseKeys.length && nextIndex < nextKeys.length) {
 		const baseKey = baseKeys[baseIndex];
 		const nextKey = nextKeys[nextIndex];
 		if (baseKey === nextKey) {
+			sharedKeys.push(baseKey);
 			baseIndex += 1;
 			nextIndex += 1;
 			continue;
 		}
 		if (baseKey < nextKey) {
+			baseOnlyKeys.push(baseKey);
+			baseIndex += 1;
+			continue;
+		}
+		nextOnlyKeys.push(nextKey);
+		nextIndex += 1;
+	}
+	while (baseIndex < baseKeys.length) {
+		baseOnlyKeys.push(baseKeys[baseIndex]);
+		baseIndex += 1;
+	}
+	while (nextIndex < nextKeys.length) {
+		nextOnlyKeys.push(nextKeys[nextIndex]);
+		nextIndex += 1;
+	}
+	return {
+		sharedKeys,
+		baseOnlyKeys,
+		nextOnlyKeys
+	};
+}
+function emitObjectStructuralOps(path, base, next, sharedKeys, baseOnlyKeys, nextOnlyKeys, ops, options) {
+	if (!options.emitMoves && !options.emitCopies) {
+		for (const baseKey of baseOnlyKeys) {
 			path.push(baseKey);
 			ops.push({
 				op: "remove",
 				path: stringifyJsonPointer(path)
 			});
 			path.pop();
-			baseIndex += 1;
+		}
+		for (const nextKey of nextOnlyKeys) {
+			path.push(nextKey);
+			ops.push({
+				op: "add",
+				path: stringifyJsonPointer(path),
+				value: next[nextKey]
+			});
+			path.pop();
+		}
+		return;
+	}
+	const structuralKeyCache = /* @__PURE__ */ new WeakMap();
+	const matchedMoveSources = /* @__PURE__ */ new Set();
+	const moveTargets = /* @__PURE__ */ new Map();
+	if (options.emitMoves) {
+		const moveSourceBuckets = /* @__PURE__ */ new Map();
+		for (const baseKey of baseOnlyKeys) insertObjectSourceBucket(moveSourceBuckets, baseKey, base[baseKey], structuralKeyCache);
+		for (const nextKey of nextOnlyKeys) {
+			const bucket = moveSourceBuckets.get(stableJsonValueKey(next[nextKey], structuralKeyCache));
+			if (!bucket) continue;
+			if (bucket.length > 0) {
+				const candidate = bucket.shift();
+				matchedMoveSources.add(candidate);
+				moveTargets.set(nextKey, candidate);
+			}
+		}
+	}
+	const copySourceBuckets = /* @__PURE__ */ new Map();
+	for (const key of sharedKeys) {
+		if (!jsonEquals(base[key], next[key])) continue;
+		insertObjectSourceBucket(copySourceBuckets, key, base[key], structuralKeyCache);
+	}
+	for (const nextKey of nextOnlyKeys) {
+		path.push(nextKey);
+		const targetPath = stringifyJsonPointer(path);
+		path.pop();
+		const moveSource = moveTargets.get(nextKey);
+		if (moveSource !== void 0) {
+			path.push(moveSource);
+			const fromPath = stringifyJsonPointer(path);
+			path.pop();
+			ops.push({
+				op: "move",
+				from: fromPath,
+				path: targetPath
+			});
+			insertObjectSourceBucket(copySourceBuckets, nextKey, next[nextKey], structuralKeyCache);
 			continue;
 		}
-		nextIndex += 1;
+		if (options.emitCopies) {
+			const copySource = findObjectCopySource(copySourceBuckets, next[nextKey], structuralKeyCache);
+			if (copySource !== void 0) {
+				path.push(copySource);
+				const fromPath = stringifyJsonPointer(path);
+				path.pop();
+				ops.push({
+					op: "copy",
+					from: fromPath,
+					path: targetPath
+				});
+				insertObjectSourceBucket(copySourceBuckets, nextKey, next[nextKey], structuralKeyCache);
+				continue;
+			}
+		}
+		ops.push({
+			op: "add",
+			path: targetPath,
+			value: next[nextKey]
+		});
+		insertObjectSourceBucket(copySourceBuckets, nextKey, next[nextKey], structuralKeyCache);
 	}
-	while (baseIndex < baseKeys.length) {
-		const baseKey = baseKeys[baseIndex];
+	for (const baseKey of baseOnlyKeys) {
+		if (matchedMoveSources.has(baseKey)) continue;
 		path.push(baseKey);
 		ops.push({
 			op: "remove",
 			path: stringifyJsonPointer(path)
 		});
 		path.pop();
-		baseIndex += 1;
 	}
-	baseIndex = 0;
-	nextIndex = 0;
-	while (baseIndex < baseKeys.length && nextIndex < nextKeys.length) {
-		const baseKey = baseKeys[baseIndex];
-		const nextKey = nextKeys[nextIndex];
-		if (baseKey === nextKey) {
-			baseIndex += 1;
-			nextIndex += 1;
-			continue;
-		}
-		if (baseKey < nextKey) {
-			baseIndex += 1;
-			continue;
-		}
-		path.push(nextKey);
-		ops.push({
-			op: "add",
-			path: stringifyJsonPointer(path),
-			value: next[nextKey]
+}
+function insertObjectSourceBucket(buckets, key, value, structuralKeyCache) {
+	const bucketKey = stableJsonValueKey(value, structuralKeyCache);
+	let bucket = buckets.get(bucketKey);
+	if (!bucket) {
+		bucket = [];
+		buckets.set(bucketKey, bucket);
+	}
+	insertSortedKey(bucket, key);
+}
+function findObjectCopySource(copySourceBuckets, target, structuralKeyCache) {
+	return copySourceBuckets.get(stableJsonValueKey(target, structuralKeyCache))?.[0];
+}
+function insertSortedKey(keys, key) {
+	let low = 0;
+	let high = keys.length;
+	while (low < high) {
+		const mid = Math.floor((low + high) / 2);
+		if (keys[mid] < key) low = mid + 1;
+		else high = mid;
+	}
+	keys.splice(low, 0, key);
+}
+function diffArrayWithLcsMatrix(path, base, next, ops, options) {
+	const window = trimEqualArrayEdges(base, next);
+	const baseStart = window.baseStart;
+	const nextStart = window.nextStart;
+	const n = window.unmatchedBaseLength;
+	const m = window.unmatchedNextLength;
+	if (!shouldUseLcsDiff(n, m, options.lcsMaxCells)) return false;
+	if (n === 0 && m === 0) return true;
+	const steps = [];
+	buildArrayEditScriptWithMatrix(base, baseStart, baseStart + n, next, nextStart, nextStart + m, steps);
+	pushArrayPatchOps(path, window.prefixLength, steps, ops, base, options);
+	return true;
+}
+function diffArrayWithLinearLcs(path, base, next, ops, options) {
+	const window = trimEqualArrayEdges(base, next);
+	if (!shouldUseLinearLcsDiff(window.unmatchedBaseLength, window.unmatchedNextLength, options)) return false;
+	const steps = [];
+	buildArrayEditScriptLinearSpace(base, window.baseStart, window.baseStart + window.unmatchedBaseLength, next, window.nextStart, window.nextStart + window.unmatchedNextLength, steps);
+	pushArrayPatchOps(path, window.prefixLength, steps, ops, base, options);
+	return true;
+}
+function trimEqualArrayEdges(base, next) {
+	const baseLength = base.length;
+	const nextLength = next.length;
+	let prefixLength = 0;
+	while (prefixLength < baseLength && prefixLength < nextLength && jsonEquals(base[prefixLength], next[prefixLength])) prefixLength += 1;
+	let suffixLength = 0;
+	while (suffixLength < baseLength - prefixLength && suffixLength < nextLength - prefixLength && jsonEquals(base[baseLength - 1 - suffixLength], next[nextLength - 1 - suffixLength])) suffixLength += 1;
+	return {
+		baseStart: prefixLength,
+		nextStart: prefixLength,
+		prefixLength,
+		unmatchedBaseLength: baseLength - prefixLength - suffixLength,
+		unmatchedNextLength: nextLength - prefixLength - suffixLength
+	};
+}
+function buildArrayEditScriptLinearSpace(base, baseStart, baseEnd, next, nextStart, nextEnd, steps) {
+	const unmatchedBaseLength = baseEnd - baseStart;
+	const unmatchedNextLength = nextEnd - nextStart;
+	if (unmatchedBaseLength === 0) {
+		for (let nextIndex = nextStart; nextIndex < nextEnd; nextIndex++) steps.push({
+			kind: "add",
+			value: next[nextIndex]
+		});
+		return;
+	}
+	if (unmatchedNextLength === 0) {
+		for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) steps.push({ kind: "remove" });
+		return;
+	}
+	if (unmatchedBaseLength === 1) {
+		pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps);
+		return;
+	}
+	if (unmatchedNextLength === 1) {
+		pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps);
+		return;
+	}
+	if (shouldUseMatrixBaseCase(unmatchedBaseLength, unmatchedNextLength)) {
+		buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps);
+		return;
+	}
+	const baseMid = baseStart + Math.floor(unmatchedBaseLength / 2);
+	const forwardScores = computeLcsPrefixLengths(base, baseStart, baseMid, next, nextStart, nextEnd);
+	const reverseScores = computeLcsSuffixLengths(base, baseMid, baseEnd, next, nextStart, nextEnd);
+	let bestOffset = 0;
+	let bestScore = Number.NEGATIVE_INFINITY;
+	for (let offset = 0; offset <= unmatchedNextLength; offset++) {
+		const score = forwardScores[offset] + reverseScores[offset];
+		if (score > bestScore) {
+			bestScore = score;
+			bestOffset = offset;
+		}
+	}
+	const nextMid = nextStart + bestOffset;
+	buildArrayEditScriptLinearSpace(base, baseStart, baseMid, next, nextStart, nextMid, steps);
+	buildArrayEditScriptLinearSpace(base, baseMid, baseEnd, next, nextMid, nextEnd, steps);
+}
+function pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps) {
+	const matchIndex = findFirstMatchingIndexInNext(base[baseStart], next, nextStart, nextEnd);
+	if (matchIndex === -1) {
+		steps.push({ kind: "remove" });
+		for (let nextIndex = nextStart; nextIndex < nextEnd; nextIndex++) steps.push({
+			kind: "add",
+			value: next[nextIndex]
 		});
-		path.pop();
-		nextIndex += 1;
+		return;
 	}
-	while (nextIndex < nextKeys.length) {
-		const nextKey = nextKeys[nextIndex];
-		path.push(nextKey);
-		ops.push({
-			op: "add",
-			path: stringifyJsonPointer(path),
-			value: next[nextKey]
+	for (let nextIndex = nextStart; nextIndex < matchIndex; nextIndex++) steps.push({
+		kind: "add",
+		value: next[nextIndex]
+	});
+	steps.push({ kind: "equal" });
+	for (let nextIndex = matchIndex + 1; nextIndex < nextEnd; nextIndex++) steps.push({
+		kind: "add",
+		value: next[nextIndex]
+	});
+}
+function pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps) {
+	const matchIndex = findFirstMatchingIndexInBase(next[nextStart], base, baseStart, baseEnd);
+	if (matchIndex === -1) {
+		for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) steps.push({ kind: "remove" });
+		steps.push({
+			kind: "add",
+			value: next[nextStart]
 		});
-		path.pop();
-		nextIndex += 1;
+		return;
 	}
-	baseIndex = 0;
-	nextIndex = 0;
-	while (baseIndex < baseKeys.length && nextIndex < nextKeys.length) {
-		const baseKey = baseKeys[baseIndex];
-		const nextKey = nextKeys[nextIndex];
-		if (baseKey === nextKey) {
-			path.push(baseKey);
-			diffValue(path, base[baseKey], next[nextKey], ops, options);
-			path.pop();
-			baseIndex += 1;
-			nextIndex += 1;
+	for (let baseIndex = baseStart; baseIndex < matchIndex; baseIndex++) steps.push({ kind: "remove" });
+	steps.push({ kind: "equal" });
+	for (let baseIndex = matchIndex + 1; baseIndex < baseEnd; baseIndex++) steps.push({ kind: "remove" });
+}
+function findFirstMatchingIndexInNext(target, next, nextStart, nextEnd) {
+	for (let nextIndex = nextStart; nextIndex < nextEnd; nextIndex++) if (jsonEquals(target, next[nextIndex])) return nextIndex;
+	return -1;
+}
+function findFirstMatchingIndexInBase(target, base, baseStart, baseEnd) {
+	for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) if (jsonEquals(target, base[baseIndex])) return baseIndex;
+	return -1;
+}
+function shouldUseMatrixBaseCase(baseLength, nextLength) {
+	return (baseLength + 1) * (nextLength + 1) <= LINEAR_LCS_MATRIX_BASE_CASE_MAX_CELLS;
+}
+function buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps) {
+	const unmatchedBaseLength = baseEnd - baseStart;
+	const unmatchedNextLength = nextEnd - nextStart;
+	const lcs = Array.from({ length: unmatchedBaseLength + 1 }, () => Array(unmatchedNextLength + 1).fill(0));
+	for (let baseOffset = unmatchedBaseLength - 1; baseOffset >= 0; baseOffset--) for (let nextOffset = unmatchedNextLength - 1; nextOffset >= 0; nextOffset--) if (jsonEquals(base[baseStart + baseOffset], next[nextStart + nextOffset])) lcs[baseOffset][nextOffset] = 1 + lcs[baseOffset + 1][nextOffset + 1];
+	else lcs[baseOffset][nextOffset] = Math.max(lcs[baseOffset + 1][nextOffset], lcs[baseOffset][nextOffset + 1]);
+	let baseOffset = 0;
+	let nextOffset = 0;
+	while (baseOffset < unmatchedBaseLength || nextOffset < unmatchedNextLength) {
+		if (baseOffset < unmatchedBaseLength && nextOffset < unmatchedNextLength && jsonEquals(base[baseStart + baseOffset], next[nextStart + nextOffset])) {
+			steps.push({ kind: "equal" });
+			baseOffset += 1;
+			nextOffset += 1;
 			continue;
 		}
-		if (baseKey < nextKey) {
-			baseIndex += 1;
+		const lcsDown = baseOffset < unmatchedBaseLength ? lcs[baseOffset + 1][nextOffset] : -1;
+		const lcsRight = nextOffset < unmatchedNextLength ? lcs[baseOffset][nextOffset + 1] : -1;
+		if (nextOffset < unmatchedNextLength && (baseOffset === unmatchedBaseLength || lcsRight > lcsDown)) {
+			steps.push({
+				kind: "add",
+				value: next[nextStart + nextOffset]
+			});
+			nextOffset += 1;
 			continue;
 		}
-		nextIndex += 1;
+		if (baseOffset < unmatchedBaseLength) {
+			steps.push({ kind: "remove" });
+			baseOffset += 1;
+		}
 	}
 }
-function diffArray(path, base, next, ops, lcsMaxCells) {
-	const baseLength = base.length;
-	const nextLength = next.length;
-	let prefix = 0;
-	while (prefix < baseLength && prefix < nextLength && jsonEquals(base[prefix], next[prefix])) prefix += 1;
-	let suffix = 0;
-	while (suffix < baseLength - prefix && suffix < nextLength - prefix && jsonEquals(base[baseLength - 1 - suffix], next[nextLength - 1 - suffix])) suffix += 1;
-	const baseStart = prefix;
-	const nextStart = prefix;
-	const n = baseLength - prefix - suffix;
-	const m = nextLength - prefix - suffix;
-	if (!shouldUseLcsDiff(n, m, lcsMaxCells)) return false;
-	if (n === 0 && m === 0) return true;
-	const lcs = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
-	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) if (jsonEquals(base[baseStart + i], next[nextStart + j])) lcs[i][j] = 1 + lcs[i + 1][j + 1];
-	else lcs[i][j] = Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+function computeLcsPrefixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd) {
+	const unmatchedNextLength = nextEnd - nextStart;
+	let previousRow = new Int32Array(unmatchedNextLength + 1);
+	let currentRow = new Int32Array(unmatchedNextLength + 1);
+	for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) {
+		for (let nextOffset = 0; nextOffset < unmatchedNextLength; nextOffset++) if (jsonEquals(base[baseIndex], next[nextStart + nextOffset])) currentRow[nextOffset + 1] = previousRow[nextOffset] + 1;
+		else currentRow[nextOffset + 1] = Math.max(previousRow[nextOffset + 1], currentRow[nextOffset]);
+		const nextPreviousRow = currentRow;
+		currentRow = previousRow;
+		previousRow = nextPreviousRow;
+		currentRow.fill(0);
+	}
+	return previousRow;
+}
+function computeLcsSuffixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd) {
+	const unmatchedNextLength = nextEnd - nextStart;
+	let previousRow = new Int32Array(unmatchedNextLength + 1);
+	let currentRow = new Int32Array(unmatchedNextLength + 1);
+	for (let baseIndex = baseEnd - 1; baseIndex >= baseStart; baseIndex--) {
+		for (let nextOffset = unmatchedNextLength - 1; nextOffset >= 0; nextOffset--) if (jsonEquals(base[baseIndex], next[nextStart + nextOffset])) currentRow[nextOffset] = previousRow[nextOffset + 1] + 1;
+		else currentRow[nextOffset] = Math.max(previousRow[nextOffset], currentRow[nextOffset + 1]);
+		const nextPreviousRow = currentRow;
+		currentRow = previousRow;
+		previousRow = nextPreviousRow;
+		currentRow.fill(0);
+	}
+	return previousRow;
+}
+function pushArrayPatchOps(path, startIndex, steps, ops, base, options) {
 	const localOps = [];
-	let i = 0;
-	let j = 0;
-	let index = prefix;
-	while (i < n || j < m) {
-		if (i < n && j < m && jsonEquals(base[baseStart + i], next[nextStart + j])) {
-			i += 1;
-			j += 1;
+	let index = startIndex;
+	for (const step of steps) {
+		if (step.kind === "equal") {
 			index += 1;
 			continue;
 		}
-		const lcsDown = i < n ? lcs[i + 1][j] : -1;
-		const lcsRight = j < m ? lcs[i][j + 1] : -1;
-		if (j < m && (i === n || lcsRight > lcsDown)) {
-			const indexSegment = String(index);
-			path.push(indexSegment);
+		const indexSegment = String(index);
+		path.push(indexSegment);
+		if (step.kind === "add") {
 			localOps.push({
 				op: "add",
 				path: stringifyJsonPointer(path),
-				value: next[nextStart + j]
+				value: step.value
 			});
-			path.pop();
-			j += 1;
 			index += 1;
-			continue;
-		}
-		if (i < n) {
-			const indexSegment = String(index);
-			path.push(indexSegment);
-			localOps.push({
-				op: "remove",
-				path: stringifyJsonPointer(path)
-			});
 			path.pop();
-			i += 1;
 			continue;
 		}
+		localOps.push({
+			op: "remove",
+			path: stringifyJsonPointer(path)
+		});
+		path.pop();
 	}
-	ops.push(...compactArrayOps(localOps));
-	return true;
+	ops.push(...finalizeArrayOps(path, base, localOps, options));
 }
 function shouldUseLcsDiff(baseLength, nextLength, lcsMaxCells) {
 	if (lcsMaxCells === Number.POSITIVE_INFINITY) return true;
@@ -882,6 +1431,169 @@ function shouldUseLcsDiff(baseLength, nextLength, lcsMaxCells) {
 	if (!Number.isFinite(cap) || cap < 1) return false;
 	return (baseLength + 1) * (nextLength + 1) <= cap;
 }
+function shouldUseLinearLcsDiff(baseLength, nextLength, options) {
+	const cap = options.lcsLinearMaxCells;
+	if (cap === void 0 || cap === Number.POSITIVE_INFINITY) return true;
+	if (!Number.isFinite(cap) || cap < 1) return false;
+	return (baseLength + 1) * (nextLength + 1) <= cap;
+}
+function finalizeArrayOps(arrayPath, base, ops, options) {
+	if (ops.length === 0) return [];
+	if (!options.emitMoves && !options.emitCopies) return compactArrayOps(ops);
+	const out = [];
+	const working = createArrayRewriteState(base);
+	for (let i = 0; i < ops.length; i++) {
+		const op = ops[i];
+		const next = ops[i + 1];
+		if (op.op === "remove" && next && next.op === "add") {
+			const valuesMatch = working.entries[getArrayOpIndex(op.path, arrayPath)].key === getArrayRewriteValueKey(working, next.value);
+			if (op.path === next.path) {
+				const replaceOp = {
+					op: "replace",
+					path: op.path,
+					value: next.value
+				};
+				out.push(replaceOp);
+				applyArrayOptimizationOp(working, replaceOp, arrayPath);
+				i += 1;
+				continue;
+			}
+			if (options.emitMoves && valuesMatch) {
+				const moveOp = {
+					op: "move",
+					from: op.path,
+					path: next.path
+				};
+				out.push(moveOp);
+				applyArrayOptimizationOp(working, moveOp, arrayPath);
+				i += 1;
+				continue;
+			}
+			if (valuesMatch) {
+				out.push(op);
+				applyArrayOptimizationOp(working, op, arrayPath);
+				out.push(next);
+				applyArrayOptimizationOp(working, next, arrayPath);
+				i += 1;
+				continue;
+			}
+			out.push(op);
+			applyArrayOptimizationOp(working, op, arrayPath);
+			continue;
+		}
+		if (op.op === "add" && next && next.op === "remove") {
+			const targetIndex = getArrayOpIndex(op.path, arrayPath);
+			const removeIndex = getArrayOpIndex(next.path, arrayPath);
+			const sourceIndex = removeIndex - (targetIndex <= removeIndex ? 1 : 0);
+			const matchesPendingRemove = sourceIndex >= 0 && sourceIndex < working.entries.length && working.entries[sourceIndex].key === getArrayRewriteValueKey(working, op.value);
+			if (options.emitMoves && matchesPendingRemove) {
+				const moveOp = {
+					op: "move",
+					from: stringifyJsonPointer([...arrayPath, String(sourceIndex)]),
+					path: op.path
+				};
+				out.push(moveOp);
+				applyArrayOptimizationOp(working, moveOp, arrayPath);
+				i += 1;
+				continue;
+			}
+			if (matchesPendingRemove) {
+				out.push(op);
+				applyArrayOptimizationOp(working, op, arrayPath);
+				out.push(next);
+				applyArrayOptimizationOp(working, next, arrayPath);
+				i += 1;
+				continue;
+			}
+		}
+		if (op.op === "add" && options.emitCopies) {
+			const copySourceIndex = findArrayCopySourceIndex(working, op.value);
+			if (copySourceIndex !== -1) {
+				const copyOp = {
+					op: "copy",
+					from: stringifyJsonPointer([...arrayPath, String(copySourceIndex)]),
+					path: op.path
+				};
+				out.push(copyOp);
+				applyArrayOptimizationOp(working, copyOp, arrayPath);
+				continue;
+			}
+		}
+		out.push(op);
+		applyArrayOptimizationOp(working, op, arrayPath);
+	}
+	return out;
+}
+/** @internal Stable structural fingerprint used for deterministic diff rewrites. */
+function stableJsonValueKey(value, structuralKeyCache) {
+	if (value !== null && typeof value === "object") {
+		const cachedValue = structuralKeyCache?.get(value);
+		if (cachedValue !== void 0) return cachedValue;
+	}
+	const stack = [{
+		kind: "value",
+		value,
+		depth: 0
+	}];
+	const results = [];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		if (frame.kind === "array") {
+			const stableKey = `[${results.splice(frame.startIndex).join(",")}]`;
+			structuralKeyCache?.set(frame.value, stableKey);
+			results.push(stableKey);
+			continue;
+		}
+		if (frame.kind === "object") {
+			const childParts = results.splice(frame.startIndex);
+			const stableKey = `{${frame.keys.map((key, index) => `${JSON.stringify(key)}:${childParts[index]}`).join(",")}}`;
+			structuralKeyCache?.set(frame.value, stableKey);
+			results.push(stableKey);
+			continue;
+		}
+		assertTraversalDepth(frame.depth);
+		if (frame.value === null || typeof frame.value !== "object") {
+			results.push(JSON.stringify(frame.value));
+			continue;
+		}
+		const cachedValue = structuralKeyCache?.get(frame.value);
+		if (cachedValue !== void 0) {
+			results.push(cachedValue);
+			continue;
+		}
+		if (Array.isArray(frame.value)) {
+			const startIndex = results.length;
+			stack.push({
+				kind: "array",
+				value: frame.value,
+				startIndex
+			});
+			for (let index = frame.value.length - 1; index >= 0; index--) stack.push({
+				kind: "value",
+				value: frame.value[index],
+				depth: frame.depth + 1
+			});
+			continue;
+		}
+		const keys = Object.keys(frame.value).sort();
+		const startIndex = results.length;
+		stack.push({
+			kind: "object",
+			value: frame.value,
+			keys,
+			startIndex
+		});
+		for (let index = keys.length - 1; index >= 0; index--) {
+			const key = keys[index];
+			stack.push({
+				kind: "value",
+				value: frame.value[key],
+				depth: frame.depth + 1
+			});
+		}
+	}
+	return results[0];
+}
 function compactArrayOps(ops) {
 	const out = [];
 	for (let i = 0; i < ops.length; i++) {
@@ -900,26 +1612,172 @@ function compactArrayOps(ops) {
 	}
 	return out;
 }
+function createArrayRewriteState(base) {
+	const structuralKeyCache = /* @__PURE__ */ new WeakMap();
+	const buckets = /* @__PURE__ */ new Map();
+	return {
+		entries: base.map((value, currentIndex) => {
+			const entry = {
+				value,
+				key: stableJsonValueKey(value, structuralKeyCache),
+				currentIndex,
+				bucketIndex: -1
+			};
+			insertArrayRewriteBucketEntry(buckets, entry);
+			return entry;
+		}),
+		buckets,
+		structuralKeyCache
+	};
+}
+function getArrayRewriteValueKey(state, value) {
+	return stableJsonValueKey(value, state.structuralKeyCache);
+}
+function findArrayCopySourceIndex(state, value) {
+	return state.buckets.get(getArrayRewriteValueKey(state, value))?.[0]?.currentIndex ?? -1;
+}
+function insertArrayRewriteBucketEntry(buckets, entry) {
+	let bucket = buckets.get(entry.key);
+	if (!bucket) {
+		bucket = [];
+		buckets.set(entry.key, bucket);
+	}
+	let low = 0;
+	let high = bucket.length;
+	while (low < high) {
+		const mid = Math.floor((low + high) / 2);
+		if (bucket[mid].currentIndex < entry.currentIndex) low = mid + 1;
+		else high = mid;
+	}
+	bucket.splice(low, 0, entry);
+	reindexArrayRewriteBucketPositions(bucket, low);
+}
+function removeArrayRewriteBucketEntry(buckets, entry) {
+	const bucket = buckets.get(entry.key);
+	if (!bucket) return;
+	const bucketIndex = entry.bucketIndex;
+	if (bucketIndex < 0 || bucketIndex >= bucket.length || bucket[bucketIndex] !== entry) return;
+	bucket.splice(bucketIndex, 1);
+	if (bucket.length === 0) {
+		buckets.delete(entry.key);
+		entry.bucketIndex = -1;
+		return;
+	}
+	entry.bucketIndex = -1;
+	reindexArrayRewriteBucketPositions(bucket, bucketIndex);
+}
+function reindexArrayRewriteBucketPositions(bucket, startIndex) {
+	for (let index = startIndex; index < bucket.length; index++) bucket[index].bucketIndex = index;
+}
+function reindexArrayRewriteEntries(entries, startIndex) {
+	for (let index = startIndex; index < entries.length; index++) entries[index].currentIndex = index;
+}
+function getArrayOpIndex(ptr, arrayPath) {
+	const parsed = parseJsonPointer(ptr);
+	if (parsed.length !== arrayPath.length + 1) throw new Error(`Expected array operation under ${stringifyJsonPointer(arrayPath)}: ${ptr}`);
+	for (let index = 0; index < arrayPath.length; index++) if (parsed[index] !== arrayPath[index]) throw new Error(`Expected array operation under ${stringifyJsonPointer(arrayPath)}: ${ptr}`);
+	const token = parsed[arrayPath.length];
+	if (!ARRAY_INDEX_TOKEN_PATTERN.test(token)) throw new Error(`Expected numeric array index at ${ptr}`);
+	return Number(token);
+}
+function applyArrayOptimizationOp(working, op, arrayPath) {
+	if (op.op === "add") {
+		const index = getArrayOpIndex(op.path, arrayPath);
+		const entry = {
+			value: structuredClone(op.value),
+			key: getArrayRewriteValueKey(working, op.value),
+			currentIndex: index,
+			bucketIndex: -1
+		};
+		working.entries.splice(index, 0, entry);
+		reindexArrayRewriteEntries(working.entries, index + 1);
+		insertArrayRewriteBucketEntry(working.buckets, entry);
+		return;
+	}
+	if (op.op === "remove") {
+		const index = getArrayOpIndex(op.path, arrayPath);
+		const [removedEntry] = working.entries.splice(index, 1);
+		if (removedEntry) removeArrayRewriteBucketEntry(working.buckets, removedEntry);
+		reindexArrayRewriteEntries(working.entries, index);
+		return;
+	}
+	if (op.op === "replace") {
+		const index = getArrayOpIndex(op.path, arrayPath);
+		const entry = working.entries[index];
+		removeArrayRewriteBucketEntry(working.buckets, entry);
+		entry.value = structuredClone(op.value);
+		entry.key = getArrayRewriteValueKey(working, op.value);
+		insertArrayRewriteBucketEntry(working.buckets, entry);
+		return;
+	}
+	if (op.op === "copy") {
+		const fromIndex = getArrayOpIndex(op.from, arrayPath);
+		if (fromIndex < 0 || fromIndex >= working.entries.length) throw new Error(`applyArrayOptimizationOp: copy from index ${fromIndex} is out of bounds (length ${working.entries.length})`);
+		const index = getArrayOpIndex(op.path, arrayPath);
+		const source = working.entries[fromIndex];
+		const entry = {
+			value: structuredClone(source.value),
+			key: source.key,
+			currentIndex: index,
+			bucketIndex: -1
+		};
+		working.entries.splice(index, 0, entry);
+		reindexArrayRewriteEntries(working.entries, index + 1);
+		insertArrayRewriteBucketEntry(working.buckets, entry);
+		return;
+	}
+	if (op.op === "move") {
+		const fromIndex = getArrayOpIndex(op.from, arrayPath);
+		if (fromIndex < 0 || fromIndex >= working.entries.length) throw new Error(`applyArrayOptimizationOp: move from index ${fromIndex} is out of bounds (length ${working.entries.length})`);
+		const [entry] = working.entries.splice(fromIndex, 1);
+		if (!entry) throw new Error(`applyArrayOptimizationOp: move from index ${fromIndex} did not resolve`);
+		removeArrayRewriteBucketEntry(working.buckets, entry);
+		const index = getArrayOpIndex(op.path, arrayPath);
+		working.entries.splice(index, 0, entry);
+		reindexArrayRewriteEntries(working.entries, Math.min(fromIndex, index));
+		insertArrayRewriteBucketEntry(working.buckets, entry);
+		return;
+	}
+	throw new Error(`applyArrayOptimizationOp: unexpected op type "${op.op}"`);
+}
 function escapeJsonPointer(token) {
 	return token.replace(/~/g, "~0").replace(/\//g, "~1");
 }
 /** Deep equality check for JSON values (null-safe, handles arrays and objects). */
 function jsonEquals(a, b) {
-	if (a === b) return true;
-	if (a === null || b === null) return false;
-	if (Array.isArray(a) || Array.isArray(b)) {
-		if (!Array.isArray(a) || !Array.isArray(b)) return false;
-		if (a.length !== b.length) return false;
-		for (let i = 0; i < a.length; i++) if (!jsonEquals(a[i], b[i])) return false;
-		return true;
-	}
-	if (!isPlainObject(a) || !isPlainObject(b)) return false;
-	const aKeys = Object.keys(a);
-	const bKeys = Object.keys(b);
-	if (aKeys.length !== bKeys.length) return false;
-	for (const key of aKeys) {
-		if (!hasOwn(b, key)) return false;
-		if (!jsonEquals(a[key], b[key])) return false;
+	const stack = [{
+		left: a,
+		right: b,
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (frame.left === frame.right) continue;
+		if (frame.left === null || frame.right === null) return false;
+		if (Array.isArray(frame.left) || Array.isArray(frame.right)) {
+			if (!Array.isArray(frame.left) || !Array.isArray(frame.right)) return false;
+			if (frame.left.length !== frame.right.length) return false;
+			for (let index = frame.left.length - 1; index >= 0; index--) stack.push({
+				left: frame.left[index],
+				right: frame.right[index],
+				depth: frame.depth + 1
+			});
+			continue;
+		}
+		if (!isPlainObject(frame.left) || !isPlainObject(frame.right)) return false;
+		const leftKeys = Object.keys(frame.left);
+		const rightKeys = Object.keys(frame.right);
+		if (leftKeys.length !== rightKeys.length) return false;
+		for (let index = leftKeys.length - 1; index >= 0; index--) {
+			const key = leftKeys[index];
+			if (!hasOwn(frame.right, key)) return false;
+			stack.push({
+				left: frame.left[key],
+				right: frame.right[key],
+				depth: frame.depth + 1
+			});
+		}
 	}
 	return true;
 }
@@ -1496,6 +2354,10 @@ function cloneNodeAtDepth(node, depth) {
 		id: e.id,
 		prev: e.prev,
 		tombstone: e.tombstone,
+		delDot: e.delDot ? {
+			actor: e.delDot.actor,
+			ctr: e.delDot.ctr
+		} : void 0,
 		value: cloneNodeAtDepth(e.value, depth + 1),
 		insDot: {
 			actor: e.insDot.actor,
@@ -1600,7 +2462,17 @@ function applyObjRemove(head, it, newDot) {
 	objRemove(parentObj, it.key, d);
 	return null;
 }
-function applyArrInsert(base, head, it, newDot, bumpCounterAbove, strictParents = false) {
+function createArrayIndexLookupSession() {
+	const bySeq = /* @__PURE__ */ new WeakMap();
+	return { get(seq) {
+		const cached = bySeq.get(seq);
+		if (cached) return cached;
+		const created = rgaCreateIndexedIdSnapshot(seq);
+		bySeq.set(seq, created);
+		return created;
+	} };
+}
+function applyArrInsert(base, head, it, newDot, indexSession, bumpCounterAbove, strictParents = false) {
 	const pointer = `/${it.path.join("/")}`;
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) {
@@ -1632,8 +2504,9 @@ function applyArrInsert(base, head, it, newDot, bumpCounterAbove, strictParents
 	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;
+	const baseIndex = indexSession.get(baseSeq);
+	const baseLen = baseIndex.length();
+	const idx = it.index === Number.POSITIVE_INFINITY ? baseLen : it.index;
 	if (idx < 0 || idx > baseLen) return {
 		ok: false,
 		code: 409,
@@ -1641,20 +2514,18 @@ function applyArrInsert(base, head, it, newDot, bumpCounterAbove, strictParents
 		message: `index out of bounds at /${it.path.join("/")}/${it.index}`,
 		path: `/${it.path.join("/")}/${it.index}`
 	};
-	const prev = idx === 0 ? HEAD : rgaIdAtIndex(baseSeq, idx - 1) ?? HEAD;
+	const prev = baseIndex.prevForInsertAt(idx);
 	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));
+	const id = dotToElemId(d);
+	rgaInsertAfter(headSeq, prev, id, d, nodeFromJson(it.value, newDot));
+	if (baseSeq === headSeq) baseIndex.insertAt(idx, id);
 	return null;
 }
 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;
-	}
+	const maxSiblingDot = rgaMaxInsertDotForPrev(seq, prev);
 	if (maxSiblingDot) bumpCounterAbove?.(maxSiblingDot.ctr);
 	if (!maxSiblingDot) return {
 		ok: true,
@@ -1675,8 +2546,8 @@ function nextInsertDotForPrev(seq, prev, newDot, path, bumpCounterAbove) {
 		path
 	};
 }
-function applyArrDelete(base, head, it, newDot) {
-	newDot();
+function applyArrDelete(base, head, it, newDot, indexSession) {
+	const _d = newDot();
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) return {
 		ok: false,
@@ -1688,7 +2559,8 @@ function applyArrDelete(base, head, it, newDot) {
 	const headSeqRes = getHeadSeqForBaseArrayIntent(head, it.path);
 	if (!headSeqRes.ok) return headSeqRes;
 	const headSeq = headSeqRes.seq;
-	const baseId = rgaIdAtIndex(baseSeq, it.index);
+	const baseIndex = indexSession.get(baseSeq);
+	const baseId = baseIndex.idAt(it.index);
 	if (!baseId) return {
 		ok: false,
 		code: 409,
@@ -1703,10 +2575,11 @@ function applyArrDelete(base, head, it, newDot) {
 		message: `element missing in head lineage at index ${it.index}`,
 		path: `/${it.path.join("/")}/${it.index}`
 	};
-	rgaDelete(headSeq, baseId);
+	rgaDelete(headSeq, baseId, _d);
+	if (baseSeq === headSeq) baseIndex.deleteAt(it.index);
 	return null;
 }
-function applyArrReplace(base, head, it, newDot) {
+function applyArrReplace(base, head, it, newDot, indexSession) {
 	newDot();
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) return {
@@ -1719,7 +2592,7 @@ function applyArrReplace(base, head, it, newDot) {
 	const headSeqRes = getHeadSeqForBaseArrayIntent(head, it.path);
 	if (!headSeqRes.ok) return headSeqRes;
 	const headSeq = headSeqRes.seq;
-	const baseId = rgaIdAtIndex(baseSeq, it.index);
+	const baseId = indexSession.get(baseSeq).idAt(it.index);
 	if (!baseId) return {
 		ok: false,
 		code: 409,
@@ -1752,6 +2625,7 @@ function applyArrReplace(base, head, it, newDot) {
 * @returns `{ ok: true }` on success, or `{ ok: false, code: 409, message }` on conflict.
 */
 function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head", bumpCounterAbove, options = {}) {
+	const arrayIndexSession = createArrayIndexLookupSession();
 	for (const it of intents) {
 		let fail = null;
 		switch (it.t) {
@@ -1765,13 +2639,13 @@ function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head
 				fail = applyObjRemove(head, it, newDot);
 				break;
 			case "ArrInsert":
-				fail = applyArrInsert(base, head, it, newDot, bumpCounterAbove, options.strictParents ?? false);
+				fail = applyArrInsert(base, head, it, newDot, arrayIndexSession, bumpCounterAbove, options.strictParents ?? false);
 				break;
 			case "ArrDelete":
-				fail = applyArrDelete(base, head, it, newDot);
+				fail = applyArrDelete(base, head, it, newDot, arrayIndexSession);
 				break;
 			case "ArrReplace":
-				fail = applyArrReplace(base, head, it, newDot);
+				fail = applyArrReplace(base, head, it, newDot, arrayIndexSession);
 				break;
 			default: assertNever(it, "Unhandled intent type");
 		}
@@ -1811,17 +2685,201 @@ function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst
 		return toApplyError$1(error);
 	}
 }
-/** Alias for codebases that prefer `try*` naming for non-throwing APIs. */
-const tryJsonPatchToCrdt = jsonPatchToCrdtSafe;
+/** Alias for codebases that prefer `try*` naming for non-throwing APIs. */
+const tryJsonPatchToCrdt = jsonPatchToCrdtSafe;
+function nodeToJsonForPatch(node) {
+	return node.kind === "lww" ? node.value : materialize(node);
+}
+function rebaseDiffOps(path, nestedOps, out) {
+	const prefix = stringifyJsonPointer(path);
+	for (const op of nestedOps) {
+		const rebasedPath = prefix === "" ? op.path : op.path === "" ? prefix : `${prefix}${op.path}`;
+		if (op.op === "remove") {
+			out.push({
+				op: "remove",
+				path: rebasedPath
+			});
+			continue;
+		}
+		if (op.op === "add" || op.op === "replace") {
+			out.push({
+				op: op.op,
+				path: rebasedPath,
+				value: op.value
+			});
+			continue;
+		}
+		throw new Error(`Unexpected op '${op.op}' from diffJsonPatch`);
+	}
+}
+function nodesJsonEqual(baseNode, headNode, depth) {
+	assertTraversalDepth(depth);
+	if (baseNode === headNode) return true;
+	if (baseNode.kind !== headNode.kind) return false;
+	if (baseNode.kind === "lww") {
+		const headLww = headNode;
+		return jsonEquals(baseNode.value, headLww.value);
+	}
+	if (baseNode.kind === "obj") {
+		const headObj = headNode;
+		if (baseNode.entries.size !== headObj.entries.size) return false;
+		for (const [key, baseEntry] of baseNode.entries.entries()) {
+			const headEntry = headObj.entries.get(key);
+			if (!headEntry) return false;
+			if (!nodesJsonEqual(baseEntry.node, headEntry.node, depth + 1)) return false;
+		}
+		return true;
+	}
+	const headSeq = headNode;
+	const baseCursor = rgaCreateLinearCursor(baseNode);
+	const headCursor = rgaCreateLinearCursor(headSeq);
+	while (true) {
+		const baseElem = baseCursor.next();
+		const headElem = headCursor.next();
+		if (baseElem === void 0 || headElem === void 0) return baseElem === void 0 && headElem === void 0;
+		if (!nodesJsonEqual(baseElem.value, headElem.value, depth + 1)) return false;
+	}
+}
+function diffObjectNodes(path, baseNode, headNode, options, ops, depth) {
+	assertTraversalDepth(depth);
+	const baseKeys = [...baseNode.entries.keys()].sort();
+	const headKeys = [...headNode.entries.keys()].sort();
+	let baseIndex = 0;
+	let headIndex = 0;
+	while (baseIndex < baseKeys.length && headIndex < headKeys.length) {
+		const baseKey = baseKeys[baseIndex];
+		const headKey = headKeys[headIndex];
+		if (baseKey === headKey) {
+			baseIndex += 1;
+			headIndex += 1;
+			continue;
+		}
+		if (baseKey < headKey) {
+			path.push(baseKey);
+			ops.push({
+				op: "remove",
+				path: stringifyJsonPointer(path)
+			});
+			path.pop();
+			baseIndex += 1;
+			continue;
+		}
+		headIndex += 1;
+	}
+	while (baseIndex < baseKeys.length) {
+		const baseKey = baseKeys[baseIndex];
+		path.push(baseKey);
+		ops.push({
+			op: "remove",
+			path: stringifyJsonPointer(path)
+		});
+		path.pop();
+		baseIndex += 1;
+	}
+	baseIndex = 0;
+	headIndex = 0;
+	while (baseIndex < baseKeys.length && headIndex < headKeys.length) {
+		const baseKey = baseKeys[baseIndex];
+		const headKey = headKeys[headIndex];
+		if (baseKey === headKey) {
+			baseIndex += 1;
+			headIndex += 1;
+			continue;
+		}
+		if (baseKey < headKey) {
+			baseIndex += 1;
+			continue;
+		}
+		const headEntry = headNode.entries.get(headKey);
+		path.push(headKey);
+		ops.push({
+			op: "add",
+			path: stringifyJsonPointer(path),
+			value: nodeToJsonForPatch(headEntry.node)
+		});
+		path.pop();
+		headIndex += 1;
+	}
+	while (headIndex < headKeys.length) {
+		const headKey = headKeys[headIndex];
+		const headEntry = headNode.entries.get(headKey);
+		path.push(headKey);
+		ops.push({
+			op: "add",
+			path: stringifyJsonPointer(path),
+			value: nodeToJsonForPatch(headEntry.node)
+		});
+		path.pop();
+		headIndex += 1;
+	}
+	baseIndex = 0;
+	headIndex = 0;
+	while (baseIndex < baseKeys.length && headIndex < headKeys.length) {
+		const baseKey = baseKeys[baseIndex];
+		const headKey = headKeys[headIndex];
+		if (baseKey === headKey) {
+			const baseEntry = baseNode.entries.get(baseKey);
+			const headEntry = headNode.entries.get(headKey);
+			if (!nodesJsonEqual(baseEntry.node, headEntry.node, depth + 1)) {
+				path.push(baseKey);
+				diffNodeToPatch(path, baseEntry.node, headEntry.node, options, ops, depth + 1);
+				path.pop();
+			}
+			baseIndex += 1;
+			headIndex += 1;
+			continue;
+		}
+		if (baseKey < headKey) {
+			baseIndex += 1;
+			continue;
+		}
+		headIndex += 1;
+	}
+}
+function diffNodeToPatch(path, baseNode, headNode, options, ops, depth) {
+	assertTraversalDepth(depth);
+	if (baseNode === headNode) return;
+	if (baseNode.kind !== headNode.kind) {
+		ops.push({
+			op: "replace",
+			path: stringifyJsonPointer(path),
+			value: nodeToJsonForPatch(headNode)
+		});
+		return;
+	}
+	if (baseNode.kind === "lww") {
+		const headLww = headNode;
+		if (jsonEquals(baseNode.value, headLww.value)) return;
+		ops.push({
+			op: "replace",
+			path: stringifyJsonPointer(path),
+			value: headLww.value
+		});
+		return;
+	}
+	if (baseNode.kind === "obj") {
+		diffObjectNodes(path, baseNode, headNode, options, ops, depth);
+		return;
+	}
+	const headSeq = headNode;
+	rebaseDiffOps(path, diffJsonPatch(materialize(baseNode), materialize(headSeq), options), ops);
+}
 /**
 * Generate a JSON Patch delta between two CRDT documents.
 * @param base - The base document snapshot.
 * @param head - The current document state.
-* @param options - Diff options (e.g. `{ arrayStrategy: "lcs" }`).
+* @param options - Diff options (e.g. `{ arrayStrategy: "lcs" }` or `{ arrayStrategy: "lcs-linear" }`).
 * @returns An array of JSON Patch operations that transform base into head.
 */
 function crdtToJsonPatch(base, head, options) {
-	return diffJsonPatch(materialize(base.root), materialize(head.root), options);
+	if ((options?.jsonValidation ?? "none") !== "none") return diffJsonPatch(materialize(base.root), materialize(head.root), options);
+	return crdtNodesToJsonPatch(base.root, head.root, options);
+}
+/** Internals-only helper for diffing CRDT nodes from an existing traversal depth. */
+function crdtNodesToJsonPatch(baseNode, headNode, options, depth = 0) {
+	const ops = [];
+	diffNodeToPatch([], baseNode, headNode, options ?? {}, ops, depth);
+	return ops;
 }
 /**
 * Emit a single root `replace` patch representing the full document state.
@@ -2095,7 +3153,7 @@ function applyPatchAsActor(doc, vv, actor, patch, options = {}) {
 }
 /** Non-throwing `applyPatchAsActor` variant for internals sync flows. */
 function tryApplyPatchAsActor(doc, vv, actor, patch, options = {}) {
-	const observedCtr = maxCtrInNodeForActor$1(doc.root, actor);
+	const observedCtr = observedVersionVector(doc)[actor] ?? 0;
 	const applied = tryApplyPatch({
 		doc,
 		clock: createClock(actor, Math.max(vv[actor] ?? 0, observedCtr))
@@ -2124,9 +3182,12 @@ function toApplyPatchOptionsForActor(options) {
 	};
 }
 function applyPatchInternal(state, patch, options, execution) {
+	const preparedPatch = preparePatchPayloadsSafe(patch, options.jsonValidation ?? "none");
+	if (!preparedPatch.ok) return preparedPatch;
+	const runtimePatch = preparedPatch.patch;
 	if ((options.semantics ?? "sequential") === "sequential") {
 		if (!options.base && execution === "batch") {
-			const compiled = compileIntents(materialize(state.doc.root), patch, "sequential", options.jsonValidation ?? "none");
+			const compiled = compilePreparedIntents(materialize(state.doc.root), runtimePatch, "sequential");
 			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 });
 		}
@@ -2134,60 +3195,53 @@ function applyPatchInternal(state, patch, options, execution) {
 			doc: cloneDoc(options.base.doc),
 			clock: createClock("__base__", 0)
 		} : null;
-		let sequentialHeadJson = materialize(state.doc.root);
-		let sequentialBaseJson = explicitBaseState ? materialize(explicitBaseState.doc.root) : sequentialHeadJson;
-		for (const [opIndex, op] of patch.entries()) {
-			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : state.doc, sequentialBaseJson, sequentialHeadJson, explicitBaseState, opIndex);
+		const session = { pointerCache: /* @__PURE__ */ new Map() };
+		for (const [opIndex, op] of runtimePatch.entries()) {
+			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : state.doc, explicitBaseState, opIndex, session);
 			if (!step.ok) return step;
-			sequentialBaseJson = step.baseJson;
-			sequentialHeadJson = step.headJson;
 		}
 		return { ok: true };
 	}
 	const baseDoc = options.base ? options.base.doc : cloneDoc(state.doc);
-	const compiled = compileIntents(materialize(baseDoc.root), patch, "base", options.jsonValidation ?? "none");
+	const compiled = compilePreparedIntents(materialize(baseDoc.root), runtimePatch, "base");
 	if (!compiled.ok) return compiled;
 	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, baseJson, headJson, explicitBaseState, opIndex) {
+function applyPatchOpSequential(state, op, options, baseDoc, explicitBaseState, opIndex, session) {
 	if (op.op === "move") {
-		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
+		const fromResolved = resolveValueAtPointerInDoc(baseDoc, op.from, opIndex, session.pointerCache);
 		if (!fromResolved.ok) return fromResolved;
 		const fromValue = structuredClone(fromResolved.value);
-		const removeRes = applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, {
+		const removeRes = applySinglePatchOpSequentialStep(state, baseDoc, {
 			op: "remove",
 			path: op.from
-		}, options, explicitBaseState);
+		}, options, explicitBaseState, opIndex, session);
 		if (!removeRes.ok) return removeRes;
 		const addOp = {
 			op: "add",
 			path: op.path,
 			value: fromValue
 		};
-		if (!explicitBaseState) return applySinglePatchOpSequentialStep(state, state.doc, removeRes.baseJson, removeRes.headJson, addOp, options, null);
-		const headAddRes = applySinglePatchOpSequentialStep(state, state.doc, removeRes.headJson, removeRes.headJson, addOp, options, null);
+		if (!explicitBaseState) return applySinglePatchOpSequentialStep(state, state.doc, addOp, options, null, opIndex, session);
+		const headAddRes = applySinglePatchOpSequentialStep(state, state.doc, addOp, options, null, opIndex, session);
 		if (!headAddRes.ok) return headAddRes;
-		const shadowAddRes = applySinglePatchOpExplicitShadowStep(explicitBaseState, removeRes.baseJson, addOp, options);
+		const shadowAddRes = applySinglePatchOpExplicitShadowStep(explicitBaseState, addOp, options, opIndex, session);
 		if (!shadowAddRes.ok) return shadowAddRes;
-		return {
-			ok: true,
-			baseJson: shadowAddRes.baseJson,
-			headJson: headAddRes.headJson
-		};
+		return { ok: true };
 	}
 	if (op.op === "copy") {
-		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
+		const fromResolved = resolveValueAtPointerInDoc(baseDoc, op.from, opIndex, session.pointerCache);
 		if (!fromResolved.ok) return fromResolved;
-		return applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, {
+		return applySinglePatchOpSequentialStep(state, baseDoc, {
 			op: "add",
 			path: op.path,
 			value: structuredClone(fromResolved.value)
-		}, options, explicitBaseState);
+		}, options, explicitBaseState, opIndex, session);
 	}
-	return applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, op, options, explicitBaseState);
+	return applySinglePatchOpSequentialStep(state, baseDoc, op, options, explicitBaseState, opIndex, session);
 }
-function applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, op, options, explicitBaseState) {
-	const compiled = compileIntents(baseJson, [op], "sequential", options.jsonValidation ?? "none");
+function applySinglePatchOpSequentialStep(state, baseDoc, op, options, explicitBaseState, opIndex, session) {
+	const compiled = compilePreparedSingleIntentFromDoc(baseDoc, op, session.pointerCache, opIndex);
 	if (!compiled.ok) return compiled;
 	const headStep = applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr), { strictParents: options.strictParents });
 	if (!headStep.ok) return headStep;
@@ -2195,94 +3249,319 @@ function applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, op
 		const shadowStep = applyIntentsToCrdt(explicitBaseState.doc, explicitBaseState.doc, compiled.intents, () => explicitBaseState.clock.next(), "base", (ctr) => bumpClockCounter(explicitBaseState, ctr), { strictParents: options.strictParents });
 		if (!shadowStep.ok) return shadowStep;
 	}
-	if (op.op === "test") return {
-		ok: true,
-		baseJson,
-		headJson
-	};
-	const nextBaseJson = applyJsonPatchOpToShadow(baseJson, op);
-	return {
-		ok: true,
-		baseJson: nextBaseJson,
-		headJson: explicitBaseState ? applyJsonPatchOpToShadow(headJson, op) : nextBaseJson
-	};
+	return { ok: true };
 }
-function applySinglePatchOpExplicitShadowStep(explicitBaseState, baseJson, op, options) {
-	const compiled = compileIntents(baseJson, [op], "sequential", options.jsonValidation ?? "none");
+function applySinglePatchOpExplicitShadowStep(explicitBaseState, op, options, opIndex, session) {
+	const compiled = compilePreparedSingleIntentFromDoc(explicitBaseState.doc, op, session.pointerCache, opIndex);
 	if (!compiled.ok) return compiled;
 	const shadowStep = applyIntentsToCrdt(explicitBaseState.doc, explicitBaseState.doc, compiled.intents, () => explicitBaseState.clock.next(), "base", (ctr) => bumpClockCounter(explicitBaseState, ctr), { strictParents: options.strictParents });
 	if (!shadowStep.ok) return shadowStep;
-	if (op.op === "test") return {
-		ok: true,
-		baseJson
+	return { ok: true };
+}
+function resolveValueAtPointerInDoc(doc, pointer, opIndex, pointerCache) {
+	let path;
+	try {
+		path = parsePointerWithCache(pointer, pointerCache);
+	} catch (error) {
+		return toPointerParseApplyError(error, pointer, opIndex);
+	}
+	const resolved = resolveNodeAtPath(doc.root, path);
+	if (!resolved.ok) return {
+		ok: false,
+		...resolved.error,
+		path: pointer,
+		opIndex
 	};
 	return {
 		ok: true,
-		baseJson: applyJsonPatchOpToShadow(baseJson, op)
+		value: materialize(resolved.node)
 	};
 }
-function applyJsonPatchOpToShadow(baseJson, op) {
-	const path = parseJsonPointer(op.path);
+function compilePreparedSingleIntentFromDoc(baseDoc, op, pointerCache, opIndex) {
+	let path;
+	try {
+		path = parsePointerWithCache(op.path, pointerCache);
+	} catch (error) {
+		return toPointerParseApplyError(error, op.path, opIndex);
+	}
+	if (op.op === "test") return {
+		ok: true,
+		intents: [{
+			t: "Test",
+			path,
+			value: op.value
+		}]
+	};
 	if (path.length === 0) {
-		if (op.op === "test") return baseJson;
-		if (op.op === "remove") return null;
-		return structuredClone(op.value);
+		if (op.op === "remove") return {
+			ok: false,
+			code: 409,
+			reason: "INVALID_TARGET",
+			message: "remove at root path is not supported in RFC-compliant mode",
+			path: op.path,
+			opIndex
+		};
+		return {
+			ok: true,
+			intents: [{
+				t: "ObjSet",
+				path: [],
+				key: ROOT_KEY,
+				value: op.value
+			}]
+		};
 	}
 	const parentPath = path.slice(0, -1);
+	const parentPointer = stringifyJsonPointer(parentPath);
 	const key = path[path.length - 1];
-	const parent = getAtJson(baseJson, parentPath);
-	if (Array.isArray(parent)) {
-		const idx = key === "-" ? parent.length : Number(key);
-		if (!Number.isInteger(idx)) throw new Error(`Invalid array index ${key}`);
-		if (op.op === "add") {
-			parent.splice(idx, 0, structuredClone(op.value));
-			return baseJson;
-		}
-		if (op.op === "remove") {
-			parent.splice(idx, 1);
-			return baseJson;
+	const resolvedParent = parentPath.length === 0 ? {
+		ok: true,
+		node: baseDoc.root
+	} : resolveNodeAtPath(baseDoc.root, parentPath);
+	if (!resolvedParent.ok) return {
+		ok: false,
+		...resolvedParent.error,
+		path: parentPointer,
+		opIndex
+	};
+	const parentNode = resolvedParent.node;
+	if (parentNode.kind === "seq") {
+		const parsedIndex = parseArrayIndexTokenForDoc(key, op.op, op.path, opIndex);
+		if (!parsedIndex.ok) return parsedIndex;
+		const boundedIndex = validateArrayIndexBounds(parsedIndex.index, op.op, rgaLength(parentNode), op.path, opIndex);
+		if (!boundedIndex.ok) return boundedIndex;
+		if (op.op === "add") return {
+			ok: true,
+			intents: [{
+				t: "ArrInsert",
+				path: parentPath,
+				index: boundedIndex.index,
+				value: op.value
+			}]
+		};
+		if (op.op === "remove") return {
+			ok: true,
+			intents: [{
+				t: "ArrDelete",
+				path: parentPath,
+				index: boundedIndex.index
+			}]
+		};
+		return {
+			ok: true,
+			intents: [{
+				t: "ArrReplace",
+				path: parentPath,
+				index: boundedIndex.index,
+				value: op.value
+			}]
+		};
+	}
+	if (parentNode.kind !== "obj") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_TARGET",
+		message: `expected object or array parent at ${parentPointer}`,
+		path: parentPointer,
+		opIndex
+	};
+	if (key === "__proto__") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_POINTER",
+		message: `unsafe object key at ${op.path}`,
+		path: op.path,
+		opIndex
+	};
+	const entry = parentNode.entries.get(key);
+	if ((op.op === "replace" || op.op === "remove") && !entry) return {
+		ok: false,
+		code: 409,
+		reason: "MISSING_TARGET",
+		message: `missing key ${key} at ${parentPointer}`,
+		path: op.path,
+		opIndex
+	};
+	if (op.op === "remove") return {
+		ok: true,
+		intents: [{
+			t: "ObjRemove",
+			path: parentPath,
+			key
+		}]
+	};
+	return {
+		ok: true,
+		intents: [{
+			t: "ObjSet",
+			path: parentPath,
+			key,
+			value: op.value,
+			mode: op.op
+		}]
+	};
+}
+function parsePointerWithCache(pointer, pointerCache) {
+	const cachedPath = pointerCache.get(pointer);
+	if (cachedPath !== void 0) return cachedPath.slice();
+	const parsedPath = parseJsonPointer(pointer);
+	pointerCache.set(pointer, parsedPath);
+	return parsedPath.slice();
+}
+function resolveNodeAtPath(root, path) {
+	let current = root;
+	for (const segment of path) {
+		if (current.kind === "obj") {
+			const entry = current.entries.get(segment);
+			if (!entry) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "MISSING_PARENT",
+					message: `Missing key '${segment}'`
+				}
+			};
+			current = entry.node;
+			continue;
 		}
-		if (op.op === "replace") {
-			parent[idx] = structuredClone(op.value);
-			return baseJson;
+		if (current.kind === "seq") {
+			if (!ARRAY_INDEX_TOKEN_PATTERN.test(segment)) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "INVALID_POINTER",
+					message: `Expected array index, got '${segment}'`
+				}
+			};
+			const index = Number(segment);
+			if (!Number.isSafeInteger(index)) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "OUT_OF_BOUNDS",
+					message: `Index out of bounds at '${segment}'`
+				}
+			};
+			const elemId = rgaIdAtIndex(current, index);
+			if (elemId === void 0) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "OUT_OF_BOUNDS",
+					message: `Index out of bounds at '${segment}'`
+				}
+			};
+			current = current.elems.get(elemId).value;
+			continue;
 		}
-		return baseJson;
-	}
-	const obj = parent;
-	if (op.op === "add" || op.op === "replace") {
-		obj[key] = structuredClone(op.value);
-		return baseJson;
-	}
-	if (op.op === "remove") {
-		delete obj[key];
-		return baseJson;
+		return {
+			ok: false,
+			error: {
+				code: 409,
+				reason: "INVALID_TARGET",
+				message: `Cannot traverse into non-container at '${segment}'`
+			}
+		};
 	}
-	return baseJson;
+	return {
+		ok: true,
+		node: current
+	};
 }
-function resolveValueAtPointer(baseJson, pointer, opIndex) {
-	let path;
-	try {
-		path = parseJsonPointer(pointer);
-	} catch (error) {
-		return toPointerParseApplyError(error, pointer, opIndex);
+function parseArrayIndexTokenForDoc(token, op, path, opIndex) {
+	if (token === "-") {
+		if (op !== "add") return {
+			ok: false,
+			code: 409,
+			reason: "INVALID_POINTER",
+			message: `'-' index is only valid for add at ${path}`,
+			path,
+			opIndex
+		};
+		return {
+			ok: true,
+			index: Number.POSITIVE_INFINITY
+		};
 	}
+	if (!ARRAY_INDEX_TOKEN_PATTERN.test(token)) return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_POINTER",
+		message: `expected array index at ${path}`,
+		path,
+		opIndex
+	};
+	const index = Number(token);
+	if (!Number.isSafeInteger(index)) return {
+		ok: false,
+		code: 409,
+		reason: "OUT_OF_BOUNDS",
+		message: `array index is too large at ${path}`,
+		path,
+		opIndex
+	};
+	return {
+		ok: true,
+		index
+	};
+}
+function validateArrayIndexBounds(index, op, arrLength, path, opIndex) {
+	if (op === "add") {
+		if (index === Number.POSITIVE_INFINITY) return {
+			ok: true,
+			index
+		};
+		if (index > arrLength) return {
+			ok: false,
+			code: 409,
+			reason: "OUT_OF_BOUNDS",
+			message: `index out of bounds at ${path}; expected 0..${arrLength}`,
+			path,
+			opIndex
+		};
+	} else if (index >= arrLength) return {
+		ok: false,
+		code: 409,
+		reason: "OUT_OF_BOUNDS",
+		message: `index out of bounds at ${path}; expected 0..${Math.max(arrLength - 1, 0)}`,
+		path,
+		opIndex
+	};
+	return {
+		ok: true,
+		index
+	};
+}
+function bumpClockCounter(state, ctr) {
+	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
+}
+function compilePreparedIntents(baseJson, patch, semantics = "sequential", pointerCache, opIndexOffset = 0) {
 	try {
+		const compileOptions = toCompilePatchOptions(semantics, pointerCache, opIndexOffset);
+		if (patch.length === 1) return {
+			ok: true,
+			intents: compileJsonPatchOpToIntent(baseJson, patch[0], compileOptions)
+		};
 		return {
 			ok: true,
-			value: getAtJson(baseJson, path)
+			intents: compileJsonPatchToIntent(baseJson, patch, compileOptions)
 		};
 	} catch (error) {
-		return toPointerLookupApplyError(error, pointer, opIndex);
+		return toApplyError(error);
 	}
 }
-function bumpClockCounter(state, ctr) {
-	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
+function toCompilePatchOptions(semantics, pointerCache, opIndexOffset = 0) {
+	return {
+		semantics,
+		pointerCache,
+		opIndexOffset
+	};
 }
-function compileIntents(baseJson, patch, semantics = "sequential", jsonValidation = "none") {
+function preparePatchPayloadsSafe(patch, mode) {
 	try {
 		return {
 			ok: true,
-			intents: compileJsonPatchToIntent(baseJson, preparePatchPayloads(patch, jsonValidation), { semantics })
+			patch: preparePatchPayloads(patch, mode)
 		};
 	} catch (error) {
 		return toApplyError(error);
@@ -2322,40 +3601,6 @@ function mergePointerPaths(basePointer, nestedPointer) {
 	if (basePointer === "") return nestedPointer;
 	return `${basePointer}${nestedPointer}`;
 }
-function maxCtrInNodeForActor$1(node, actor) {
-	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;
-				stack.push({
-					node: entry.node,
-					depth: frame.depth + 1
-				});
-			}
-			for (const tomb of frame.node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
-			continue;
-		}
-		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 {
@@ -2383,21 +3628,12 @@ function toPointerParseApplyError(error, pointer, opIndex) {
 		opIndex
 	};
 }
-function toPointerLookupApplyError(error, pointer, opIndex) {
-	const mapped = mapLookupErrorToPatchReason(error);
-	return {
-		ok: false,
-		code: 409,
-		reason: mapped.reason,
-		message: mapped.message,
-		path: pointer,
-		opIndex
-	};
-}
 
 //#endregion
 //#region src/serialize.ts
 const HEAD_ELEM_ID = "HEAD";
+const SERIALIZED_DOC_VERSION = 1;
+const SERIALIZED_STATE_VERSION = 1;
 function createSerializedRecord() {
 	return Object.create(null);
 }
@@ -2422,13 +3658,16 @@ var DeserializeError = class extends Error {
 };
 /** Serialize a CRDT document to a JSON-safe representation (Maps become plain objects). */
 function serializeDoc(doc) {
-	return { root: serializeNode(doc.root) };
+	return {
+		version: SERIALIZED_DOC_VERSION,
+		root: serializeNode(doc.root)
+	};
 }
 /** Reconstruct a CRDT document from its serialized form. */
 function deserializeDoc(data) {
-	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) };
+	const raw = readSerializedDocEnvelope(data);
+	if (!("root" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/root", "serialized doc is missing root");
+	return { root: deserializeNode(raw.root, "/root", 0) };
 }
 /** Non-throwing `deserializeDoc` variant with typed validation details. */
 function tryDeserializeDoc(data) {
@@ -2449,6 +3688,7 @@ function tryDeserializeDoc(data) {
 /** Serialize a full CRDT state (document + clock) to a JSON-safe representation. */
 function serializeState(state) {
 	return {
+		version: SERIALIZED_STATE_VERSION,
 		doc: serializeDoc(state.doc),
 		clock: {
 			actor: state.clock.actor,
@@ -2456,16 +3696,24 @@ function serializeState(state) {
 		}
 	};
 }
-/** Reconstruct a full CRDT state from its serialized form, restoring the clock. */
+/**
+* Reconstruct a full CRDT state from its serialized form, restoring the clock.
+*
+* May throw `TraversalDepthError` when the payload exceeds the maximum
+* supported nesting depth.
+*/
 function deserializeState(data) {
-	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"));
+	const raw = readSerializedStateEnvelope(data);
+	if (!("doc" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/doc", "serialized state is missing doc");
+	if (!("clock" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/clock", "serialized state is missing clock");
+	const clockRaw = asRecord(raw.clock, "/clock");
+	const actor = readActor(clockRaw.actor, "/clock/actor");
+	const ctr = readCounter(clockRaw.ctr, "/clock/ctr");
+	const doc = deserializeDoc(raw.doc);
+	const observedCtr = observedVersionVector(doc)[actor] ?? 0;
 	return {
-		doc: deserializeDoc(data.doc),
-		clock
+		doc,
+		clock: createClock(actor, Math.max(ctr, observedCtr))
 	};
 }
 /** Non-throwing `deserializeState` variant with typed validation details. */
@@ -2514,21 +3762,38 @@ function serializeNode(node) {
 		};
 	}
 	const elems = createSerializedRecord();
-	for (const [id, e] of node.elems.entries()) setSerializedRecordValue(elems, id, {
-		id: e.id,
-		prev: e.prev,
-		tombstone: e.tombstone,
-		value: serializeNode(e.value),
-		insDot: {
-			actor: e.insDot.actor,
-			ctr: e.insDot.ctr
-		}
-	});
+	for (const [id, e] of node.elems.entries()) {
+		const serializedElem = {
+			id: e.id,
+			prev: e.prev,
+			tombstone: e.tombstone,
+			value: serializeNode(e.value),
+			insDot: {
+				actor: e.insDot.actor,
+				ctr: e.insDot.ctr
+			}
+		};
+		if (e.delDot) serializedElem.delDot = {
+			actor: e.delDot.actor,
+			ctr: e.delDot.ctr
+		};
+		setSerializedRecordValue(elems, id, serializedElem);
+	}
 	return {
 		kind: "seq",
 		elems
 	};
 }
+function readSerializedDocEnvelope(data) {
+	const raw = asRecord(data, "/");
+	assertSerializedEnvelopeVersion(raw, "/version", SERIALIZED_DOC_VERSION, "doc");
+	return raw;
+}
+function readSerializedStateEnvelope(data) {
+	const raw = asRecord(data, "/");
+	assertSerializedEnvelopeVersion(raw, "/version", SERIALIZED_STATE_VERSION, "state");
+	return raw;
+}
 function deserializeNode(node, path, depth) {
 	assertTraversalDepth(depth);
 	const raw = asRecord(node, path);
@@ -2574,11 +3839,14 @@ function deserializeNode(node, path, depth) {
 		const tombstone = readBoolean(elem.tombstone, `${elemPath}/tombstone`);
 		const value = deserializeNode(elem.value, `${elemPath}/value`, depth + 1);
 		const insDot = readDot(elem.insDot, `${elemPath}/insDot`);
+		const delDot = "delDot" in elem && elem.delDot !== void 0 ? readDot(elem.delDot, `${elemPath}/delDot`) : void 0;
 		if (dotToElemId(insDot) !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/insDot`, "sequence element id must match its insertion dot");
+		if (!tombstone && delDot) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/delDot`, "live sequence elements must not include delete metadata");
 		elems.set(id, {
 			id,
 			prev,
 			tombstone,
+			delDot,
 			value,
 			insDot
 		});
@@ -2617,6 +3885,15 @@ function asRecord(value, path) {
 	if (!isRecord(value)) fail("INVALID_SERIALIZED_SHAPE", path, "expected object");
 	return value;
 }
+function assertSerializedEnvelopeVersion(raw, path, expectedVersion, label) {
+	if (!("version" in raw)) return;
+	const version = readVersion(raw.version, path);
+	if (version !== expectedVersion) fail("INVALID_SERIALIZED_SHAPE", path, `unsupported serialized ${label} version '${version}'`);
+}
+function readVersion(value, path) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) fail("INVALID_SERIALIZED_SHAPE", path, "envelope version must be a non-negative safe integer");
+	return value;
+}
 function readDot(value, path) {
 	const raw = asRecord(value, path);
 	return {
@@ -2715,7 +3992,7 @@ function mergeDoc(a, b, options = {}) {
 function tryMergeDoc(a, b, options = {}) {
 	try {
 		const mismatchPath = options.requireSharedOrigin ?? true ? findSeqLineageMismatch(a.root, b.root, []) : null;
-		if (mismatchPath) return {
+		if (mismatchPath !== null) return {
 			ok: false,
 			error: {
 				ok: false,
@@ -2796,7 +4073,7 @@ function findSeqLineageMismatch(a, b, path) {
 					shared = true;
 					break;
 				}
-				if (!shared) return `/${frame.path.join("/")}`;
+				if (!shared) return stringifyJsonPointer(frame.path);
 			}
 		}
 		if (frame.a.kind === "obj" && frame.b.kind === "obj") {
@@ -2819,45 +4096,11 @@ function findSeqLineageMismatch(a, b, path) {
 	return null;
 }
 function maxObservedCtrForActor(doc, actor, a, b) {
-	let best = maxCtrInNodeForActor(doc.root, actor);
+	let best = observedVersionVector(doc)[actor] ?? 0;
 	if (a.clock.actor === actor && a.clock.ctr > best) best = a.clock.ctr;
 	if (b.clock.actor === actor && b.clock.ctr > best) best = b.clock.ctr;
 	return best;
 }
-function maxCtrInNodeForActor(node, actor) {
-	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;
-				stack.push({
-					node: entry.node,
-					depth: frame.depth + 1
-				});
-			}
-			for (const tomb of frame.node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
-			continue;
-		}
-		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) {
 		case "lww": return node.dot;
@@ -2950,13 +4193,14 @@ function mergeSeq(a, b, depth, path) {
 		const ea = a.elems.get(id);
 		const eb = b.elems.get(id);
 		if (ea && eb) {
-			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");
+			if (ea.prev !== eb.prev) throw new SharedElementMetadataMismatchError(stringifyJsonPointer(path), id, "prev");
+			if (!sameDot(ea.insDot, eb.insDot)) throw new SharedElementMetadataMismatchError(stringifyJsonPointer(path), id, "insDot");
 			const mergedValue = mergeNodeAtDepth(ea.value, eb.value, depth + 1, [...path, id]);
 			elems.set(id, {
 				id,
 				prev: ea.prev,
 				tombstone: ea.tombstone || eb.tombstone,
+				delDot: mergeDeleteDot(ea.delDot, eb.delDot),
 				value: mergedValue,
 				insDot: { ...ea.insDot }
 			});
@@ -2971,20 +4215,22 @@ function mergeSeq(a, b, depth, path) {
 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,
+		delDot: e.delDot ? { ...e.delDot } : void 0,
 		value: cloneNodeShallow(e.value, depth + 1),
 		insDot: { ...e.insDot }
 	};
 }
+function mergeDeleteDot(a, b) {
+	if (a && b) return compareDot(a, b) >= 0 ? { ...a } : { ...b };
+	if (a) return { ...a };
+	if (b) return { ...b };
+}
 function cloneNodeShallow(node, depth) {
 	assertTraversalDepth(depth);
 	switch (node.kind) {
@@ -3098,4 +4344,4 @@ function compactStateTombstones(state, options) {
 }
 
 //#endregion
-export { rgaCompactTombstones as $, docFromJson as A, parseJsonPointer as B, tryApplyPatchAsActor as C, cloneDoc as D, applyIntentsToCrdt as E, PatchCompileError as F, newObj as G, ROOT_KEY as H, compileJsonPatchToIntent as I, objCompactTombstones as J, newReg as K, diffJsonPatch as L, jsonPatchToCrdt as M, jsonPatchToCrdtSafe as N, crdtToFullReplace as O, tryJsonPatchToCrdt as P, HEAD as Q, getAtJson as R, tryApplyPatch as S, validateJsonPatch as T, JsonValueValidationError as U, stringifyJsonPointer as V, lwwSet as W, objSet as X, objRemove as Y, materialize as Z, applyPatchAsActor as _, mergeState as a, compareDot as at, forkState as b, DeserializeError as c, vvMerge as ct, serializeDoc as d, ClockValidationError as dt, rgaDelete as et, serializeState as f, cloneClock as ft, applyPatch as g, PatchError as h, observeDot as ht, mergeDoc as i, rgaPrevForInsertAtIndex as it, docFromJsonWithDot as j, crdtToJsonPatch as k, deserializeDoc as l, MAX_TRAVERSAL_DEPTH as lt, tryDeserializeState as m, nextDotForActor as mt, compactStateTombstones as n, rgaInsertAfter as nt, tryMergeDoc as o, dotToElemId as ot, tryDeserializeDoc as p, createClock as pt, newSeq as q, MergeError as r, rgaLinearizeIds as rt, tryMergeState as s, vvHasDot as st, compactDocTombstones as t, rgaIdAtIndex as tt, deserializeState as u, TraversalDepthError as ut, applyPatchInPlace as v, tryApplyPatchInPlace as w, toJson as x, createState as y, jsonEquals as z };
+export { materialize as $, crdtToJsonPatch as A, jsonEquals as B, tryApplyPatchAsActor as C, TraversalDepthError as Ct, cloneDoc as D, applyIntentsToCrdt as E, tryJsonPatchToCrdt as F, JsonValueValidationError as G, stableJsonValueKey as H, PatchCompileError as I, newReg as J, lwwSet as K, compileJsonPatchToIntent as L, docFromJsonWithDot as M, jsonPatchToCrdt as N, crdtNodesToJsonPatch as O, jsonPatchToCrdtSafe as P, objSet as Q, diffJsonPatch as R, tryApplyPatch as S, MAX_TRAVERSAL_DEPTH as St, validateJsonPatch as T, stringifyJsonPointer as U, parseJsonPointer as V, ROOT_KEY as W, objCompactTombstones as X, newSeq as Y, objRemove as Z, applyPatchAsActor as _, observeDot as _t, mergeState as a, rgaInsertAfterChecked as at, forkState as b, observedVersionVector as bt, DeserializeError as c, validateRgaSeq as ct, serializeDoc as d, vvHasDot as dt, HEAD as et, serializeState as f, vvMerge as ft, applyPatch as g, nextDotForActor as gt, PatchError as h, createClock as ht, mergeDoc as i, rgaInsertAfter as it, docFromJson as j, crdtToFullReplace as k, deserializeDoc as l, compareDot as lt, tryDeserializeState as m, cloneClock as mt, compactStateTombstones as n, rgaDelete as nt, tryMergeDoc as o, rgaLinearizeIds as ot, tryDeserializeDoc as p, ClockValidationError as pt, newObj as q, MergeError as r, rgaIdAtIndex as rt, tryMergeState as s, rgaPrevForInsertAtIndex as st, compactDocTombstones as t, rgaCompactTombstones as tt, deserializeState as u, dotToElemId as ut, applyPatchInPlace as v, intersectVersionVectors as vt, tryApplyPatchInPlace as w, toJson as x, versionVectorCovers as xt, createState as y, mergeVersionVectors as yt, getAtJson as z };