json-patch-to-crdt 0.2.0 → 0.3.0

package/dist/{compact-DrmgKiVW.js → compact-BToZE6Q6.js}

@@ -133,12 +133,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()) {
@@ -187,6 +206,30 @@ function rgaLinearizeIds(seq) {
 	});
 	return [...out];
 }
+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, {
@@ -196,15 +239,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.
@@ -251,15 +389,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];
 }
@@ -587,6 +729,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;
@@ -677,22 +820,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.
+* Note that `lcs-linear` still runs in `O(n * m)` time and does not have an
+* automatic fallback 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.
@@ -709,14 +867,19 @@ function diffJsonPatch(base, next, options = {}) {
 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 arrayStrategy = options.arrayStrategy ?? "lcs";
+		if (arrayStrategy === "lcs" && Array.isArray(base) && Array.isArray(next)) {
+			if (!diffArrayWithLcsMatrix(path, base, next, ops, options)) ops.push({
 				op: "replace",
 				path: stringifyJsonPointer(path),
 				value: next
 			});
 			return;
 		}
+		if (arrayStrategy === "lcs-linear" && Array.isArray(base) && Array.isArray(next)) {
+			diffArrayWithLinearLcs(path, base, next, ops, options);
+			return;
+		}
 		ops.push({
 			op: "replace",
 			path: stringifyJsonPointer(path),
@@ -732,150 +895,368 @@ function diffValue(path, base, next, ops, options) {
 		});
 		return;
 	}
+	diffObject(path, base, next, ops, options);
+}
+function diffObject(path, base, next, ops, options) {
 	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;
+	}
+	emitObjectStructuralOps(path, base, next, sharedKeys, baseOnlyKeys, nextOnlyKeys, ops, options);
+	for (const key of sharedKeys) {
+		path.push(key);
+		diffValue(path, base[key], next[key], ops, options);
+		path.pop();
+	}
+}
+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;
-			continue;
 		}
-		nextIndex += 1;
+		for (const nextKey of nextOnlyKeys) {
+			path.push(nextKey);
+			ops.push({
+				op: "add",
+				path: stringifyJsonPointer(path),
+				value: next[nextKey]
+			});
+			path.pop();
+		}
+		return;
 	}
-	while (baseIndex < baseKeys.length) {
-		const baseKey = baseKeys[baseIndex];
-		path.push(baseKey);
-		ops.push({
-			op: "remove",
-			path: stringifyJsonPointer(path)
-		});
-		path.pop();
-		baseIndex += 1;
+	const matchedMoveSources = /* @__PURE__ */ new Set();
+	const moveTargets = /* @__PURE__ */ new Map();
+	if (options.emitMoves) {
+		const moveSourceBuckets = /* @__PURE__ */ new Map();
+		for (const baseKey of baseOnlyKeys) {
+			const bucketKey = stableJsonValueKey(base[baseKey]);
+			const bucket = moveSourceBuckets.get(bucketKey);
+			if (bucket) bucket.push(baseKey);
+			else moveSourceBuckets.set(bucketKey, [baseKey]);
+		}
+		for (const nextKey of nextOnlyKeys) {
+			const bucket = moveSourceBuckets.get(stableJsonValueKey(next[nextKey]));
+			if (!bucket) continue;
+			if (bucket.length > 0) {
+				const candidate = bucket.shift();
+				matchedMoveSources.add(candidate);
+				moveTargets.set(nextKey, candidate);
+			}
+		}
 	}
-	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;
+	const availableSources = /* @__PURE__ */ new Map();
+	const availableSourceKeys = [];
+	for (const key of sharedKeys) {
+		if (!jsonEquals(base[key], next[key])) continue;
+		availableSources.set(key, base[key]);
+		availableSourceKeys.push(key);
+	}
+	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
+			});
+			availableSources.set(nextKey, next[nextKey]);
+			insertSortedKey(availableSourceKeys, nextKey);
 			continue;
 		}
-		if (baseKey < nextKey) {
-			baseIndex += 1;
-			continue;
+		if (options.emitCopies) {
+			const copySource = findObjectCopySource(availableSourceKeys, availableSources, next[nextKey]);
+			if (copySource !== void 0) {
+				path.push(copySource);
+				const fromPath = stringifyJsonPointer(path);
+				path.pop();
+				ops.push({
+					op: "copy",
+					from: fromPath,
+					path: targetPath
+				});
+				availableSources.set(nextKey, next[nextKey]);
+				insertSortedKey(availableSourceKeys, nextKey);
+				continue;
+			}
 		}
-		path.push(nextKey);
 		ops.push({
 			op: "add",
-			path: stringifyJsonPointer(path),
+			path: targetPath,
 			value: next[nextKey]
 		});
-		path.pop();
-		nextIndex += 1;
+		availableSources.set(nextKey, next[nextKey]);
+		insertSortedKey(availableSourceKeys, nextKey);
 	}
-	while (nextIndex < nextKeys.length) {
-		const nextKey = nextKeys[nextIndex];
-		path.push(nextKey);
+	for (const baseKey of baseOnlyKeys) {
+		if (matchedMoveSources.has(baseKey)) continue;
+		path.push(baseKey);
 		ops.push({
-			op: "add",
-			path: stringifyJsonPointer(path),
-			value: next[nextKey]
+			op: "remove",
+			path: stringifyJsonPointer(path)
 		});
 		path.pop();
-		nextIndex += 1;
 	}
-	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;
+}
+function findObjectCopySource(sortedKeys, availableSources, target) {
+	for (const key of sortedKeys) if (jsonEquals(availableSources.get(key), target)) return key;
+}
+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);
+	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);
+}
+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]
+		});
+		return;
+	}
+	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]
+		});
+		return;
+	}
+	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;
@@ -883,6 +1264,99 @@ function shouldUseLcsDiff(baseLength, nextLength, lcsMaxCells) {
 	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 = base.slice();
+	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 removedValue = working[getArrayOpIndex(op.path, arrayPath)];
+			const valuesMatch = jsonEquals(removedValue, 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.length && jsonEquals(working[sourceIndex], 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;
+}
+function stableJsonValueKey(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map(stableJsonValueKey).join(",")}]`;
+	return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJsonValueKey(value[key])}`).join(",")}}`;
+}
 function compactArrayOps(ops) {
 	const out = [];
 	for (let i = 0; i < ops.length; i++) {
@@ -901,6 +1375,47 @@ function compactArrayOps(ops) {
 	}
 	return out;
 }
+function findArrayCopySourceIndex(working, value) {
+	for (let index = 0; index < working.length; index++) if (jsonEquals(working[index], value)) return index;
+	return -1;
+}
+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") {
+		working.splice(getArrayOpIndex(op.path, arrayPath), 0, structuredClone(op.value));
+		return;
+	}
+	if (op.op === "remove") {
+		working.splice(getArrayOpIndex(op.path, arrayPath), 1);
+		return;
+	}
+	if (op.op === "replace") {
+		working[getArrayOpIndex(op.path, arrayPath)] = structuredClone(op.value);
+		return;
+	}
+	if (op.op === "copy") {
+		const fromIndex = getArrayOpIndex(op.from, arrayPath);
+		if (fromIndex < 0 || fromIndex >= working.length) throw new Error(`applyArrayOptimizationOp: copy from index ${fromIndex} is out of bounds (length ${working.length})`);
+		const value = structuredClone(working[fromIndex]);
+		working.splice(getArrayOpIndex(op.path, arrayPath), 0, value);
+		return;
+	}
+	if (op.op === "move") {
+		const fromIndex = getArrayOpIndex(op.from, arrayPath);
+		if (fromIndex < 0 || fromIndex >= working.length) throw new Error(`applyArrayOptimizationOp: move from index ${fromIndex} is out of bounds (length ${working.length})`);
+		const [value] = working.splice(fromIndex, 1);
+		working.splice(getArrayOpIndex(op.path, arrayPath), 0, value);
+		return;
+	}
+	throw new Error(`applyArrayOptimizationOp: unexpected op type "${op.op}"`);
+}
 function escapeJsonPointer(token) {
 	return token.replace(/~/g, "~0").replace(/\//g, "~1");
 }
@@ -1497,6 +2012,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,
@@ -1601,7 +2120,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) {
@@ -1633,8 +2162,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,
@@ -1642,20 +2172,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,
@@ -1676,8 +2204,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,
@@ -1689,7 +2217,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,
@@ -1704,10 +2233,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 {
@@ -1720,7 +2250,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,
@@ -1753,6 +2283,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) {
@@ -1766,13 +2297,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");
 		}
@@ -1814,15 +2345,199 @@ function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst
 }
 /** 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.
@@ -2125,9 +2840,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 });
 		}
@@ -2135,10 +2853,15 @@ function applyPatchInternal(state, patch, options, execution) {
 			doc: cloneDoc(options.base.doc),
 			clock: createClock("__base__", 0)
 		} : null;
+		const session = {
+			pointerCache: /* @__PURE__ */ new Map(),
+			baseShadowParentCache: /* @__PURE__ */ new Map(),
+			headShadowParentCache: /* @__PURE__ */ new Map()
+		};
 		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);
+		for (const [opIndex, op] of runtimePatch.entries()) {
+			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : state.doc, sequentialBaseJson, sequentialHeadJson, explicitBaseState, opIndex, session);
 			if (!step.ok) return step;
 			sequentialBaseJson = step.baseJson;
 			sequentialHeadJson = step.headJson;
@@ -2146,29 +2869,29 @@ function applyPatchInternal(state, patch, options, execution) {
 		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, baseJson, headJson, explicitBaseState, opIndex, session) {
 	if (op.op === "move") {
-		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
+		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex, session.pointerCache);
 		if (!fromResolved.ok) return fromResolved;
 		const fromValue = structuredClone(fromResolved.value);
 		const removeRes = applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, {
 			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, removeRes.baseJson, removeRes.headJson, addOp, options, null, opIndex, session);
+		const headAddRes = applySinglePatchOpSequentialStep(state, state.doc, removeRes.headJson, removeRes.headJson, addOp, options, null, opIndex, session);
 		if (!headAddRes.ok) return headAddRes;
-		const shadowAddRes = applySinglePatchOpExplicitShadowStep(explicitBaseState, removeRes.baseJson, addOp, options);
+		const shadowAddRes = applySinglePatchOpExplicitShadowStep(explicitBaseState, removeRes.baseJson, addOp, options, opIndex, session);
 		if (!shadowAddRes.ok) return shadowAddRes;
 		return {
 			ok: true,
@@ -2177,18 +2900,18 @@ function applyPatchOpSequential(state, op, options, baseDoc, baseJson, headJson,
 		};
 	}
 	if (op.op === "copy") {
-		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
+		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex, session.pointerCache);
 		if (!fromResolved.ok) return fromResolved;
 		return applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, {
 			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, baseJson, headJson, 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, baseJson, headJson, op, options, explicitBaseState, opIndex, session) {
+	const compiled = compilePreparedIntents(baseJson, [op], "base", 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;
@@ -2201,15 +2924,21 @@ function applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, op
 		baseJson,
 		headJson
 	};
-	const nextBaseJson = applyJsonPatchOpToShadow(baseJson, op);
+	const nextBaseJson = applyJsonPatchOpToShadow(baseJson, op, explicitBaseState ? session.baseShadowParentCache : session.headShadowParentCache, {
+		pointerCache: session.pointerCache,
+		opIndex
+	});
 	return {
 		ok: true,
 		baseJson: nextBaseJson,
-		headJson: explicitBaseState ? applyJsonPatchOpToShadow(headJson, op) : nextBaseJson
+		headJson: explicitBaseState ? applyJsonPatchOpToShadow(headJson, op, session.headShadowParentCache, {
+			pointerCache: session.pointerCache,
+			opIndex
+		}) : nextBaseJson
 	};
 }
-function applySinglePatchOpExplicitShadowStep(explicitBaseState, baseJson, op, options) {
-	const compiled = compileIntents(baseJson, [op], "sequential", options.jsonValidation ?? "none");
+function applySinglePatchOpExplicitShadowStep(explicitBaseState, baseJson, op, options, opIndex, session) {
+	const compiled = compilePreparedIntents(baseJson, [op], "base", 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;
@@ -2219,32 +2948,46 @@ function applySinglePatchOpExplicitShadowStep(explicitBaseState, baseJson, op, o
 	};
 	return {
 		ok: true,
-		baseJson: applyJsonPatchOpToShadow(baseJson, op)
+		baseJson: applyJsonPatchOpToShadow(baseJson, op, session.baseShadowParentCache, {
+			pointerCache: session.pointerCache,
+			opIndex
+		})
 	};
 }
-function applyJsonPatchOpToShadow(baseJson, op) {
-	const path = parseJsonPointer(op.path);
+function applyJsonPatchOpToShadow(baseJson, op, parentCache, pointerContext) {
+	let path;
+	try {
+		path = parsePointerWithCache(op.path, pointerContext.pointerCache);
+	} catch (error) {
+		throw toPointerParseCompileError(error, op.path, pointerContext.opIndex);
+	}
 	if (path.length === 0) {
+		parentCache.clear();
 		if (op.op === "test") return baseJson;
 		if (op.op === "remove") return null;
 		return structuredClone(op.value);
 	}
+	const pathPointer = op.path;
 	const parentPath = path.slice(0, -1);
+	const parentPointer = pointerParent(pathPointer);
 	const key = path[path.length - 1];
-	const parent = getAtJson(baseJson, parentPath);
+	const parent = resolveShadowParent(baseJson, parentPath, parentPointer, parentCache);
 	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));
+			invalidateArrayShadowParentCache(parentCache, parentPointer);
 			return baseJson;
 		}
 		if (op.op === "remove") {
 			parent.splice(idx, 1);
+			invalidateArrayShadowParentCache(parentCache, parentPointer);
 			return baseJson;
 		}
 		if (op.op === "replace") {
 			parent[idx] = structuredClone(op.value);
+			invalidateShadowPointerCache(parentCache, pathPointer);
 			return baseJson;
 		}
 		return baseJson;
@@ -2252,18 +2995,57 @@ function applyJsonPatchOpToShadow(baseJson, op) {
 	const obj = parent;
 	if (op.op === "add" || op.op === "replace") {
 		obj[key] = structuredClone(op.value);
+		invalidateShadowPointerCache(parentCache, pathPointer);
 		return baseJson;
 	}
 	if (op.op === "remove") {
 		delete obj[key];
+		invalidateShadowPointerCache(parentCache, pathPointer);
 		return baseJson;
 	}
 	return baseJson;
 }
-function resolveValueAtPointer(baseJson, pointer, opIndex) {
+function resolveShadowParent(baseJson, parentPath, parentPointer, parentCache) {
+	const cachedParent = parentCache.get(parentPointer);
+	if (cachedParent !== void 0) return cachedParent;
+	const parentValue = parentPath.length === 0 ? baseJson : getAtJson(baseJson, parentPath);
+	if (!Array.isArray(parentValue) && !(parentValue && typeof parentValue === "object")) throw new Error(`Cannot mutate JSON shadow at non-container parent ${parentPointer || "<root>"}`);
+	parentCache.set(parentPointer, parentValue);
+	return parentValue;
+}
+function invalidateShadowPointerCache(parentCache, pointer) {
+	if (pointer === "") {
+		parentCache.clear();
+		return;
+	}
+	const pointerPrefix = `${pointer}/`;
+	for (const cachedPointer of parentCache.keys()) if (cachedPointer === pointer || cachedPointer.startsWith(pointerPrefix)) parentCache.delete(cachedPointer);
+}
+function invalidateArrayShadowParentCache(parentCache, parentPointer) {
+	if (parentPointer === "") {
+		for (const cachedPointer of parentCache.keys()) if (cachedPointer !== "") parentCache.delete(cachedPointer);
+		return;
+	}
+	const pointerPrefix = `${parentPointer}/`;
+	for (const cachedPointer of parentCache.keys()) if (cachedPointer.startsWith(pointerPrefix)) parentCache.delete(cachedPointer);
+}
+function pointerParent(pointer) {
+	if (pointer === "") return "";
+	const lastSlash = pointer.lastIndexOf("/");
+	if (lastSlash <= 0) return "";
+	return pointer.slice(0, lastSlash);
+}
+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 resolveValueAtPointer(baseJson, pointer, opIndex, pointerCache) {
 	let path;
 	try {
-		path = parseJsonPointer(pointer);
+		path = parsePointerWithCache(pointer, pointerCache);
 	} catch (error) {
 		return toPointerParseApplyError(error, pointer, opIndex);
 	}
@@ -2279,11 +3061,33 @@ function resolveValueAtPointer(baseJson, pointer, opIndex) {
 function bumpClockCounter(state, ctr) {
 	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
 }
-function compileIntents(baseJson, patch, semantics = "sequential", jsonValidation = "none") {
+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,
+			intents: compileJsonPatchToIntent(baseJson, patch, compileOptions)
+		};
+	} catch (error) {
+		return toApplyError(error);
+	}
+}
+function toCompilePatchOptions(semantics, pointerCache, opIndexOffset = 0) {
+	return {
+		semantics,
+		pointerCache,
+		opIndexOffset
+	};
+}
+function preparePatchPayloadsSafe(patch, mode) {
 	try {
 		return {
 			ok: true,
-			intents: compileJsonPatchToIntent(baseJson, preparePatchPayloads(patch, jsonValidation), { semantics })
+			patch: preparePatchPayloads(patch, mode)
 		};
 	} catch (error) {
 		return toApplyError(error);
@@ -2384,6 +3188,9 @@ function toPointerParseApplyError(error, pointer, opIndex) {
 		opIndex
 	};
 }
+function toPointerParseCompileError(error, pointer, opIndex) {
+	return new PatchCompileError("INVALID_POINTER", error instanceof Error ? error.message : "invalid pointer", pointer, opIndex);
+}
 function toPointerLookupApplyError(error, pointer, opIndex) {
 	const mapped = mapLookupErrorToPatchReason(error);
 	return {
@@ -2463,10 +3270,13 @@ function deserializeState(data) {
 	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 actor = readActor(clockRaw.actor, "/clock/actor");
+	const ctr = readCounter(clockRaw.ctr, "/clock/ctr");
+	const doc = deserializeDoc(data.doc);
+	const observedCtr = maxObservedCounterForActorInNode(doc.root, actor);
 	return {
-		doc: deserializeDoc(data.doc),
-		clock
+		doc,
+		clock: createClock(actor, Math.max(ctr, observedCtr))
 	};
 }
 /** Non-throwing `deserializeState` variant with typed validation details. */
@@ -2515,16 +3325,23 @@ 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
@@ -2575,11 +3392,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
 		});
@@ -2614,6 +3434,24 @@ function assertAcyclicRgaPredecessors(elems, path) {
 		for (const id of trail) visitState.set(id, 2);
 	}
 }
+function maxObservedCounterForActorInNode(node, actor) {
+	if (node.kind === "lww") return node.dot.actor === actor ? node.dot.ctr : 0;
+	if (node.kind === "obj") {
+		let maxCtr = 0;
+		for (const entry of node.entries.values()) {
+			if (entry.dot.actor === actor) maxCtr = Math.max(maxCtr, entry.dot.ctr);
+			maxCtr = Math.max(maxCtr, maxObservedCounterForActorInNode(entry.node, actor));
+		}
+		for (const tombstoneDot of node.tombstone.values()) if (tombstoneDot.actor === actor) maxCtr = Math.max(maxCtr, tombstoneDot.ctr);
+		return maxCtr;
+	}
+	let maxCtr = 0;
+	for (const elem of node.elems.values()) {
+		if (elem.insDot.actor === actor) maxCtr = Math.max(maxCtr, elem.insDot.ctr);
+		maxCtr = Math.max(maxCtr, maxObservedCounterForActorInNode(elem.value, actor));
+	}
+	return maxCtr;
+}
 function asRecord(value, path) {
 	if (!isRecord(value)) fail("INVALID_SERIALIZED_SHAPE", path, "expected object");
 	return value;
@@ -2958,6 +3796,7 @@ function mergeSeq(a, b, depth, path) {
 				id,
 				prev: ea.prev,
 				tombstone: ea.tombstone || eb.tombstone,
+				delDot: mergeDeleteDot(ea.delDot, eb.delDot),
 				value: mergedValue,
 				insDot: { ...ea.insDot }
 			});
@@ -2982,10 +3821,16 @@ function cloneElem(e, depth) {
 		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) {
@@ -3219,6 +4064,12 @@ Object.defineProperty(exports, 'compileJsonPatchToIntent', {
     return compileJsonPatchToIntent;
   }
 });
+Object.defineProperty(exports, 'crdtNodesToJsonPatch', {
+  enumerable: true,
+  get: function () {
+    return crdtNodesToJsonPatch;
+  }
+});
 Object.defineProperty(exports, 'crdtToFullReplace', {
   enumerable: true,
   get: function () {
@@ -3411,6 +4262,12 @@ Object.defineProperty(exports, 'rgaInsertAfter', {
     return rgaInsertAfter;
   }
 });
+Object.defineProperty(exports, 'rgaInsertAfterChecked', {
+  enumerable: true,
+  get: function () {
+    return rgaInsertAfterChecked;
+  }
+});
 Object.defineProperty(exports, 'rgaLinearizeIds', {
   enumerable: true,
   get: function () {
@@ -3501,6 +4358,12 @@ Object.defineProperty(exports, 'validateJsonPatch', {
     return validateJsonPatch;
   }
 });
+Object.defineProperty(exports, 'validateRgaSeq', {
+  enumerable: true,
+  get: function () {
+    return validateRgaSeq;
+  }
+});
 Object.defineProperty(exports, 'vvHasDot', {
   enumerable: true,
   get: function () {