json-patch-to-crdt 0.3.0 → 0.5.0

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

@@ -1,19 +1,39 @@
 
-//#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
+let observedVersionVectorObserverForTests = null;
+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,
@@ -21,6 +41,105 @@ 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) {
+	observedVersionVectorObserverForTests?.(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.
@@ -57,8 +176,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
@@ -66,63 +185,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}`;
@@ -206,6 +282,12 @@ 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 {
@@ -413,6 +495,8 @@ function rgaPrevForInsertAtIndex(seq, index) {
 
 //#endregion
 //#region src/materialize.ts
+let materializeObserver = null;
+const EMPTY_PATH = [];
 function createMaterializedObject() {
 	return Object.create(null);
 }
@@ -426,6 +510,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?.(EMPTY_PATH, node);
 	if (node.kind === "lww") return node.value;
 	const root = node.kind === "obj" ? createMaterializedObject() : [];
 	const stack = [];
@@ -433,13 +519,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];
@@ -453,6 +542,8 @@ function materialize(node) {
 			const child = entry.node;
 			const childDepth = frame.depth + 1;
 			assertTraversalDepth(childDepth);
+			const childPath = observer ? [...frame.path, key] : EMPTY_PATH;
+			observer?.(childPath, child);
 			if (child.kind === "lww") {
 				setMaterializedProperty(frame.out, key, child.value);
 				continue;
@@ -464,7 +555,8 @@ function materialize(node) {
 					kind: "obj",
 					depth: childDepth,
 					entries: child.entries.entries(),
-					out: outObj
+					out: outObj,
+					path: childPath
 				});
 				continue;
 			}
@@ -474,7 +566,9 @@ function materialize(node) {
 				kind: "seq",
 				depth: childDepth,
 				cursor: rgaCreateLinearCursor(child),
-				out: outArr
+				out: outArr,
+				path: childPath,
+				nextIndex: 0
 			});
 			continue;
 		}
@@ -486,6 +580,9 @@ function materialize(node) {
 		const child = elem.value;
 		const childDepth = frame.depth + 1;
 		assertTraversalDepth(childDepth);
+		const childPath = observer ? [...frame.path, String(frame.nextIndex)] : EMPTY_PATH;
+		frame.nextIndex += 1;
+		observer?.(childPath, child);
 		if (child.kind === "lww") {
 			frame.out.push(child.value);
 			continue;
@@ -497,7 +594,8 @@ function materialize(node) {
 				kind: "obj",
 				depth: childDepth,
 				entries: child.entries.entries(),
-				out: outObj
+				out: outObj,
+				path: childPath
 			});
 			continue;
 		}
@@ -507,7 +605,9 @@ function materialize(node) {
 			kind: "seq",
 			depth: childDepth,
 			cursor: rgaCreateLinearCursor(child),
-			out: outArr
+			out: outArr,
+			path: childPath,
+			nextIndex: 0
 		});
 	}
 	return root;
@@ -618,6 +718,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
 */
@@ -704,7 +805,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);
@@ -715,8 +819,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
@@ -847,8 +959,8 @@ function compileJsonPatchOpToIntent(baseJson, op, options = {}) {
 * 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.
+* 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.
@@ -865,39 +977,97 @@ 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)) {
-		const arrayStrategy = options.arrayStrategy ?? "lcs";
-		if (arrayStrategy === "lcs" && Array.isArray(base) && Array.isArray(next)) {
-			if (!diffArrayWithLcsMatrix(path, base, next, ops, options)) 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;
 		}
-		if (arrayStrategy === "lcs-linear" && Array.isArray(base) && Array.isArray(next)) {
-			diffArrayWithLinearLcs(path, base, next, ops, options);
-			return;
+		const baseIsObject = isPlainObject(frame.base);
+		const nextIsObject = isPlainObject(frame.next);
+		if (!baseIsObject || !nextIsObject) {
+			ops.push({
+				op: "replace",
+				path: stringifyJsonPointer(path),
+				value: frame.next
+			});
+			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 { 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;
 	}
-	diffObject(path, base, next, ops, options);
 }
-function diffObject(path, base, next, ops, options) {
+function collectObjectKeys(base, next) {
 	const baseKeys = Object.keys(base).sort();
 	const nextKeys = Object.keys(next).sort();
 	const baseOnlyKeys = [];
@@ -930,12 +1100,11 @@ function diffObject(path, base, next, ops, options) {
 		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();
-	}
+	return {
+		sharedKeys,
+		baseOnlyKeys,
+		nextOnlyKeys
+	};
 }
 function emitObjectStructuralOps(path, base, next, sharedKeys, baseOnlyKeys, nextOnlyKeys, ops, options) {
 	if (!options.emitMoves && !options.emitCopies) {
@@ -958,18 +1127,14 @@ function emitObjectStructuralOps(path, base, next, sharedKeys, baseOnlyKeys, nex
 		}
 		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) {
-			const bucketKey = stableJsonValueKey(base[baseKey]);
-			const bucket = moveSourceBuckets.get(bucketKey);
-			if (bucket) bucket.push(baseKey);
-			else moveSourceBuckets.set(bucketKey, [baseKey]);
-		}
+		for (const baseKey of baseOnlyKeys) insertObjectSourceBucket(moveSourceBuckets, baseKey, base[baseKey], structuralKeyCache);
 		for (const nextKey of nextOnlyKeys) {
-			const bucket = moveSourceBuckets.get(stableJsonValueKey(next[nextKey]));
+			const bucket = moveSourceBuckets.get(stableJsonValueKey(next[nextKey], structuralKeyCache));
 			if (!bucket) continue;
 			if (bucket.length > 0) {
 				const candidate = bucket.shift();
@@ -978,12 +1143,10 @@ function emitObjectStructuralOps(path, base, next, sharedKeys, baseOnlyKeys, nex
 			}
 		}
 	}
-	const availableSources = /* @__PURE__ */ new Map();
-	const availableSourceKeys = [];
+	const copySourceBuckets = /* @__PURE__ */ new Map();
 	for (const key of sharedKeys) {
 		if (!jsonEquals(base[key], next[key])) continue;
-		availableSources.set(key, base[key]);
-		availableSourceKeys.push(key);
+		insertObjectSourceBucket(copySourceBuckets, key, base[key], structuralKeyCache);
 	}
 	for (const nextKey of nextOnlyKeys) {
 		path.push(nextKey);
@@ -999,12 +1162,11 @@ function emitObjectStructuralOps(path, base, next, sharedKeys, baseOnlyKeys, nex
 				from: fromPath,
 				path: targetPath
 			});
-			availableSources.set(nextKey, next[nextKey]);
-			insertSortedKey(availableSourceKeys, nextKey);
+			insertObjectSourceBucket(copySourceBuckets, nextKey, next[nextKey], structuralKeyCache);
 			continue;
 		}
 		if (options.emitCopies) {
-			const copySource = findObjectCopySource(availableSourceKeys, availableSources, next[nextKey]);
+			const copySource = findObjectCopySource(copySourceBuckets, next[nextKey], structuralKeyCache);
 			if (copySource !== void 0) {
 				path.push(copySource);
 				const fromPath = stringifyJsonPointer(path);
@@ -1014,8 +1176,7 @@ function emitObjectStructuralOps(path, base, next, sharedKeys, baseOnlyKeys, nex
 					from: fromPath,
 					path: targetPath
 				});
-				availableSources.set(nextKey, next[nextKey]);
-				insertSortedKey(availableSourceKeys, nextKey);
+				insertObjectSourceBucket(copySourceBuckets, nextKey, next[nextKey], structuralKeyCache);
 				continue;
 			}
 		}
@@ -1024,8 +1185,7 @@ function emitObjectStructuralOps(path, base, next, sharedKeys, baseOnlyKeys, nex
 			path: targetPath,
 			value: next[nextKey]
 		});
-		availableSources.set(nextKey, next[nextKey]);
-		insertSortedKey(availableSourceKeys, nextKey);
+		insertObjectSourceBucket(copySourceBuckets, nextKey, next[nextKey], structuralKeyCache);
 	}
 	for (const baseKey of baseOnlyKeys) {
 		if (matchedMoveSources.has(baseKey)) continue;
@@ -1037,8 +1197,17 @@ function emitObjectStructuralOps(path, base, next, sharedKeys, baseOnlyKeys, nex
 		path.pop();
 	}
 }
-function findObjectCopySource(sortedKeys, availableSources, target) {
-	for (const key of sortedKeys) if (jsonEquals(availableSources.get(key), target)) return key;
+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;
@@ -1065,9 +1234,11 @@ function diffArrayWithLcsMatrix(path, base, next, ops, options) {
 }
 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;
@@ -1264,17 +1435,22 @@ 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 = base.slice();
+	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 removedValue = working[getArrayOpIndex(op.path, arrayPath)];
-			const valuesMatch = jsonEquals(removedValue, next.value);
+			const valuesMatch = working.entries[getArrayOpIndex(op.path, arrayPath)].key === getArrayRewriteValueKey(working, next.value);
 			if (op.path === next.path) {
 				const replaceOp = {
 					op: "replace",
@@ -1313,7 +1489,7 @@ function finalizeArrayOps(arrayPath, base, ops, options) {
 			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);
+			const matchesPendingRemove = sourceIndex >= 0 && sourceIndex < working.entries.length && working.entries[sourceIndex].key === getArrayRewriteValueKey(working, op.value);
 			if (options.emitMoves && matchesPendingRemove) {
 				const moveOp = {
 					op: "move",
@@ -1352,10 +1528,75 @@ function finalizeArrayOps(arrayPath, base, ops, options) {
 	}
 	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(",")}}`;
+/** @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 = [];
@@ -1375,9 +1616,65 @@ 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 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);
@@ -1389,29 +1686,60 @@ function getArrayOpIndex(ptr, arrayPath) {
 }
 function applyArrayOptimizationOp(working, op, arrayPath) {
 	if (op.op === "add") {
-		working.splice(getArrayOpIndex(op.path, arrayPath), 0, structuredClone(op.value));
+		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") {
-		working.splice(getArrayOpIndex(op.path, arrayPath), 1);
+		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") {
-		working[getArrayOpIndex(op.path, arrayPath)] = structuredClone(op.value);
+		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.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);
+		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.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);
+		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}"`);
@@ -1421,21 +1749,39 @@ function escapeJsonPointer(token) {
 }
 /** 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;
 }
@@ -1726,51 +2072,35 @@ function docFromJson(value, nextDot) {
 	return { root: nodeFromJson(value, nextDot) };
 }
 /**
-* Legacy: create a doc using a single dot with counter offsets for array children.
-* Prefer `docFromJson(value, nextDot)` to ensure unique dots per node.
+* Legacy helper for tests and fixtures that seeds an entire document from one dot.
+*
+* It reuses that dot for object entries and synthesizes array child counters from the
+* same seed, which can produce low-quality causal metadata and unrealistic sequence
+* identities in production CRDT state.
+*
+* Prefer `docFromJson(value, nextDot)` so every node receives a fresh unique dot.
+*
+* @deprecated Use `docFromJson(value, nextDot)` for production documents.
 */
 function docFromJsonWithDot(value, dot) {
 	return { root: deepNodeFromJson(value, dot) };
 }
 function getSeqAtPath(doc, path) {
-	let cur = doc.root;
-	for (const seg of path) {
-		if (cur.kind !== "obj") return;
-		const ent = cur.entries.get(seg);
-		if (!ent) return;
-		cur = ent.node;
-	}
-	return cur.kind === "seq" ? cur : void 0;
+	const node = getNodeAtPath(doc, path);
+	return node?.kind === "seq" ? node : void 0;
 }
 function getObjAtPathStrict(doc, path) {
-	let cur = doc.root;
-	const seen = [];
-	if (path.length === 0) {
-		if (cur.kind !== "obj") return {
-			ok: false,
-			message: "expected object at /"
-		};
+	const node = getNodeAtPath(doc, path);
+	if (!node || node.kind !== "obj") {
+		const pointer = stringifyJsonPointer(path);
 		return {
-			ok: true,
-			obj: cur
-		};
-	}
-	for (const seg of path) {
-		if (cur.kind !== "obj") return {
 			ok: false,
-			message: `expected object at /${seen.join("/")}`
+			message: `expected object at ${pointer === "" ? "/" : pointer}`
 		};
-		const entry = cur.entries.get(seg);
-		seen.push(seg);
-		if (!entry || entry.node.kind !== "obj") return {
-			ok: false,
-			message: `expected object at /${seen.join("/")}`
-		};
-		cur = entry.node;
 	}
 	return {
 		ok: true,
-		obj: cur
+		obj: node
 	};
 }
 function ensureSeqAtPath(head, path, dotForCreate) {
@@ -1817,10 +2147,24 @@ function ensureSeqAtPath(head, path, dotForCreate) {
 function getNodeAtPath(doc, path) {
 	let cur = doc.root;
 	for (const seg of path) {
-		if (cur.kind !== "obj") return;
-		const ent = cur.entries.get(seg);
-		if (!ent) return;
-		cur = ent.node;
+		if (cur.kind === "obj") {
+			const ent = cur.entries.get(seg);
+			if (!ent) return;
+			cur = ent.node;
+			continue;
+		}
+		if (cur.kind === "seq") {
+			if (!ARRAY_INDEX_TOKEN_PATTERN.test(seg)) return;
+			const index = Number(seg);
+			if (!Number.isSafeInteger(index)) return;
+			const elemId = rgaIdAtIndex(cur, index);
+			if (elemId === void 0) return;
+			const elem = cur.elems.get(elemId);
+			if (!elem) return;
+			cur = elem.value;
+			continue;
+		}
+		if (cur.kind === "lww") return;
 	}
 	return cur;
 }
@@ -2034,38 +2378,88 @@ function getJsonAtDocPathForTest(doc, path) {
 	let cur = doc.root;
 	for (let i = 0; i < path.length; i++) {
 		const seg = path[i];
-		assertTraversalDepth(i + 1);
+		try {
+			assertTraversalDepth(i + 1);
+		} catch (error) {
+			return {
+				ok: false,
+				error: error instanceof TraversalDepthError ? toDepthApplyError(error) : {
+					ok: false,
+					code: 409,
+					reason: "INVALID_PATCH",
+					message: error instanceof Error ? error.message : "invalid test path"
+				}
+			};
+		}
 		if (cur.kind === "obj") {
 			const ent = cur.entries.get(seg);
-			if (!ent) throw new Error(`Missing key '${seg}'`);
+			if (!ent) return {
+				ok: false,
+				error: {
+					ok: false,
+					code: 409,
+					reason: "MISSING_TARGET",
+					message: `Missing key '${seg}'`
+				}
+			};
 			cur = ent.node;
 			continue;
 		}
 		if (cur.kind === "seq") {
-			if (!ARRAY_INDEX_TOKEN_PATTERN.test(seg)) throw new Error(`Expected array index, got '${seg}'`);
-			const id = rgaIdAtIndex(cur, Number(seg));
-			if (id === void 0) throw new Error(`Index out of bounds at '${seg}'`);
+			if (!ARRAY_INDEX_TOKEN_PATTERN.test(seg)) return {
+				ok: false,
+				error: {
+					ok: false,
+					code: 409,
+					reason: "INVALID_POINTER",
+					message: `Expected array index, got '${seg}'`
+				}
+			};
+			const idx = Number(seg);
+			if (!Number.isSafeInteger(idx)) return {
+				ok: false,
+				error: {
+					ok: false,
+					code: 409,
+					reason: "OUT_OF_BOUNDS",
+					message: `Index out of bounds at '${seg}'`
+				}
+			};
+			const id = rgaIdAtIndex(cur, idx);
+			if (id === void 0) return {
+				ok: false,
+				error: {
+					ok: false,
+					code: 409,
+					reason: "OUT_OF_BOUNDS",
+					message: `Index out of bounds at '${seg}'`
+				}
+			};
 			cur = cur.elems.get(id).value;
 			continue;
 		}
-		throw new Error(`Cannot traverse into non-container at '${seg}'`);
-	}
-	return cur.kind === "lww" ? cur.value : materialize(cur);
-}
-function applyTest(base, head, it, evalTestAgainst) {
-	let got;
-	try {
-		got = getJsonAtDocPathForTest(evalTestAgainst === "head" ? head : base, it.path);
-	} catch {
 		return {
 			ok: false,
-			code: 409,
-			reason: "MISSING_TARGET",
-			message: `test path missing at /${it.path.join("/")}`,
-			path: `/${it.path.join("/")}`
+			error: {
+				ok: false,
+				code: 409,
+				reason: "INVALID_TARGET",
+				message: `Cannot traverse into non-container at '${seg}'`
+			}
 		};
 	}
-	if (!jsonEquals(got, it.value)) return {
+	return {
+		ok: true,
+		value: cur.kind === "lww" ? cur.value : materialize(cur)
+	};
+}
+function applyTest(base, head, it, evalTestAgainst) {
+	const got = getJsonAtDocPathForTest(evalTestAgainst === "head" ? head : base, it.path);
+	if (!got.ok) return {
+		...got.error,
+		path: `/${it.path.join("/")}`
+	};
+	if (!jsonEquals(got.value, it.value)) return {
 		ok: false,
 		code: 409,
 		reason: "TEST_FAILED",
@@ -2370,6 +2764,46 @@ function rebaseDiffOps(path, nestedOps, out) {
 		throw new Error(`Unexpected op '${op.op}' from diffJsonPatch`);
 	}
 }
+function collectLiveSequenceElements(seq) {
+	const elems = [];
+	const cursor = rgaCreateLinearCursor(seq);
+	for (let elem = cursor.next(); elem; elem = cursor.next()) elems.push(elem);
+	return elems;
+}
+function materializeSequenceWindow(elems, start, end) {
+	const out = [];
+	for (let i = start; i < end; i++) out.push(nodeToJsonForPatch(elems[i].value));
+	return out;
+}
+function rebaseSequenceWindowDiffOps(path, indexOffset, nestedOps, out) {
+	const pending = [];
+	for (const op of nestedOps) {
+		if (op.path === "") return false;
+		const rebasedSegments = parseJsonPointer(op.path);
+		const indexToken = rebasedSegments[0];
+		if (!indexToken || !ARRAY_INDEX_TOKEN_PATTERN.test(indexToken)) return false;
+		rebasedSegments[0] = String(Number(indexToken) + indexOffset);
+		const rebasedPath = stringifyJsonPointer([...path, ...rebasedSegments]);
+		if (op.op === "remove") {
+			pending.push({
+				op: "remove",
+				path: rebasedPath
+			});
+			continue;
+		}
+		if (op.op === "add" || op.op === "replace") {
+			pending.push({
+				op: op.op,
+				path: rebasedPath,
+				value: op.value
+			});
+			continue;
+		}
+		return false;
+	}
+	out.push(...pending);
+	return true;
+}
 function nodesJsonEqual(baseNode, headNode, depth) {
 	assertTraversalDepth(depth);
 	if (baseNode === headNode) return true;
@@ -2494,6 +2928,35 @@ function diffObjectNodes(path, baseNode, headNode, options, ops, depth) {
 		headIndex += 1;
 	}
 }
+function diffSequenceNodes(path, baseNode, headSeq, options, ops, depth) {
+	if ((options.arrayStrategy ?? "lcs") === "atomic") {
+		rebaseDiffOps(path, diffJsonPatch(materialize(baseNode), materialize(headSeq), options), ops);
+		return;
+	}
+	const baseElems = collectLiveSequenceElements(baseNode);
+	const headElems = collectLiveSequenceElements(headSeq);
+	const sharedLength = Math.min(baseElems.length, headElems.length);
+	let prefixLength = 0;
+	while (prefixLength < sharedLength && nodesJsonEqual(baseElems[prefixLength].value, headElems[prefixLength].value, depth + 1)) prefixLength += 1;
+	if (prefixLength === baseElems.length && prefixLength === headElems.length) return;
+	let baseEnd = baseElems.length;
+	let headEnd = headElems.length;
+	while (baseEnd > prefixLength && headEnd > prefixLength && nodesJsonEqual(baseElems[baseEnd - 1].value, headElems[headEnd - 1].value, depth + 1)) {
+		baseEnd -= 1;
+		headEnd -= 1;
+	}
+	const unmatchedBaseLength = baseEnd - prefixLength;
+	const unmatchedHeadLength = headEnd - prefixLength;
+	if (unmatchedBaseLength === 1 && unmatchedHeadLength === 1) {
+		path.push(String(prefixLength));
+		diffNodeToPatch(path, baseElems[prefixLength].value, headElems[prefixLength].value, options, ops, depth + 1);
+		path.pop();
+		return;
+	}
+	const seqOps = diffJsonPatch(materializeSequenceWindow(baseElems, prefixLength, baseEnd), materializeSequenceWindow(headElems, prefixLength, headEnd), options);
+	if (rebaseSequenceWindowDiffOps(path, prefixLength, seqOps, ops)) return;
+	rebaseDiffOps(path, diffJsonPatch(materialize(baseNode), materialize(headSeq), options), ops);
+}
 function diffNodeToPatch(path, baseNode, headNode, options, ops, depth) {
 	assertTraversalDepth(depth);
 	if (baseNode === headNode) return;
@@ -2519,8 +2982,7 @@ function diffNodeToPatch(path, baseNode, headNode, options, ops, depth) {
 		diffObjectNodes(path, baseNode, headNode, options, ops, depth);
 		return;
 	}
-	const headSeq = headNode;
-	rebaseDiffOps(path, diffJsonPatch(materialize(baseNode), materialize(headSeq), options), ops);
+	diffSequenceNodes(path, baseNode, headNode, options, ops, depth);
 }
 /**
 * Generate a JSON Patch delta between two CRDT documents.
@@ -2562,7 +3024,7 @@ function jsonPatchToCrdtInternal(options) {
 		}
 		return applyIntentsToCrdt(options.base, options.head, intents, options.newDot, evalTestAgainst, options.bumpCounterAbove, { strictParents: options.strictParents });
 	}
-	let shadowBase = cloneDoc(evalTestAgainst === "base" ? options.base : options.head);
+	const shadowBase = evalTestAgainst === "base" ? cloneDoc(options.base) : null;
 	let shadowCtr = 0;
 	const shadowDot = () => ({
 		actor: "__shadow__",
@@ -2571,60 +3033,340 @@ function jsonPatchToCrdtInternal(options) {
 	const shadowBump = (ctr) => {
 		if (shadowCtr < ctr) shadowCtr = ctr;
 	};
-	const applySequentialOp = (op, opIndex) => {
-		const baseJson = materialize(shadowBase.root);
-		let intents;
-		try {
-			intents = compileJsonPatchToIntent(baseJson, [op], { semantics: "sequential" });
-		} catch (error) {
-			return withOpIndex(toApplyError$1(error), opIndex);
+	const session = { pointerCache: /* @__PURE__ */ new Map() };
+	for (const [opIndex, op] of options.patch.entries()) {
+		const step = applySequentialPatchOp(options, evalTestAgainst === "base" ? shadowBase : options.head, op, opIndex, evalTestAgainst, shadowDot, shadowBump, session);
+		if (!step.ok) return step;
+	}
+	return { ok: true };
+}
+function applySequentialPatchOp(options, compileBase, op, opIndex, evalTestAgainst, shadowDot, shadowBump, session) {
+	if (op.op === "move") {
+		if (op.from === op.path) {
+			const pathCheck = resolveValueAtPointerInDoc$1(compileBase, op.from, opIndex, session.pointerCache);
+			if (!pathCheck.ok) return pathCheck;
+			return { ok: true };
 		}
-		const headStep = applyIntentsToCrdt(shadowBase, options.head, intents, options.newDot, evalTestAgainst, options.bumpCounterAbove, { strictParents: options.strictParents });
-		if (!headStep.ok) return withOpIndex(headStep, opIndex);
-		if (evalTestAgainst === "base") {
-			const shadowStep = applyIntentsToCrdt(shadowBase, shadowBase, intents, shadowDot, "base", shadowBump, { strictParents: options.strictParents });
-			if (!shadowStep.ok) return withOpIndex(shadowStep, opIndex);
-		} else shadowBase = cloneDoc(options.head);
-		return { ok: true };
+		const fromResolved = resolveValueAtPointerInDoc$1(compileBase, op.from, opIndex, session.pointerCache);
+		if (!fromResolved.ok) return fromResolved;
+		const removeStep = applySingleSequentialPatchStep(options, compileBase, {
+			op: "remove",
+			path: op.from
+		}, opIndex, evalTestAgainst, shadowDot, shadowBump, session);
+		if (!removeStep.ok) return removeStep;
+		return applySingleSequentialPatchStep(options, compileBase, {
+			op: "add",
+			path: op.path,
+			value: structuredClone(fromResolved.value)
+		}, opIndex, evalTestAgainst, shadowDot, shadowBump, session);
+	}
+	if (op.op === "copy") {
+		const fromResolved = resolveValueAtPointerInDoc$1(compileBase, op.from, opIndex, session.pointerCache);
+		if (!fromResolved.ok) return fromResolved;
+		return applySingleSequentialPatchStep(options, compileBase, {
+			op: "add",
+			path: op.path,
+			value: structuredClone(fromResolved.value)
+		}, opIndex, evalTestAgainst, shadowDot, shadowBump, session);
+	}
+	return applySingleSequentialPatchStep(options, compileBase, op, opIndex, evalTestAgainst, shadowDot, shadowBump, session);
+}
+function applySingleSequentialPatchStep(options, compileBase, op, opIndex, evalTestAgainst, shadowDot, shadowBump, session) {
+	const compiled = compilePreparedSingleIntentFromDoc$1(compileBase, op, session.pointerCache, opIndex);
+	if (!compiled.ok) return compiled;
+	const headStep = applyIntentsToCrdt(compileBase, options.head, compiled.intents, options.newDot, evalTestAgainst, options.bumpCounterAbove, { strictParents: options.strictParents });
+	if (!headStep.ok) return withOpIndex$1(headStep, opIndex);
+	if (op.op === "test") return { ok: true };
+	if (evalTestAgainst === "head") return { ok: true };
+	const shadowStep = applyIntentsToCrdt(compileBase, compileBase, compiled.intents, shadowDot, "base", shadowBump, { strictParents: options.strictParents });
+	if (!shadowStep.ok) return withOpIndex$1(shadowStep, opIndex);
+	return { ok: true };
+}
+function resolveValueAtPointerInDoc$1(doc, pointer, opIndex, pointerCache) {
+	const parsedPath = parsePointerWithCache$1(pointer, pointerCache, opIndex);
+	if (!parsedPath.ok) return parsedPath;
+	const resolved = resolveNodeAtPath$1(doc.root, parsedPath.path);
+	if (!resolved.ok) return {
+		ok: false,
+		...resolved.error,
+		path: pointer,
+		opIndex
 	};
-	for (let opIndex = 0; opIndex < options.patch.length; opIndex++) {
-		const op = options.patch[opIndex];
-		if (op.op === "move") {
-			const baseJson = materialize(shadowBase.root);
-			let fromValue;
-			try {
-				fromValue = structuredClone(getAtJson(baseJson, parseJsonPointer(op.from)));
-			} catch {
-				try {
-					compileJsonPatchToIntent(baseJson, [{
-						op: "remove",
-						path: op.from
-					}], { semantics: "sequential" });
-				} catch (error) {
-					return withOpIndex(toApplyError$1(error), opIndex);
+	return {
+		ok: true,
+		value: nodeToJsonForPatch(resolved.node)
+	};
+}
+function compilePreparedSingleIntentFromDoc$1(baseDoc, op, pointerCache, opIndex) {
+	const parsedPath = parsePointerWithCache$1(op.path, pointerCache, opIndex);
+	if (!parsedPath.ok) return parsedPath;
+	const path = parsedPath.path;
+	if (op.op === "test") return {
+		ok: true,
+		intents: [{
+			t: "Test",
+			path,
+			value: op.value
+		}]
+	};
+	if (path.length === 0) {
+		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 resolvedParent = parentPath.length === 0 ? {
+		ok: true,
+		node: baseDoc.root
+	} : resolveNodeAtPath$1(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$1(key, op.op, op.path, opIndex);
+		if (!parsedIndex.ok) return parsedIndex;
+		const boundedIndex = validateArrayIndexBounds$1(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$1(pointer, pointerCache, opIndex) {
+	const cachedPath = pointerCache.get(pointer);
+	if (cachedPath !== void 0) return {
+		ok: true,
+		path: cachedPath.slice()
+	};
+	try {
+		const parsedPath = parseJsonPointer(pointer);
+		pointerCache.set(pointer, parsedPath);
+		return {
+			ok: true,
+			path: parsedPath.slice()
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			code: 409,
+			reason: "INVALID_POINTER",
+			message: error instanceof Error ? error.message : "invalid pointer",
+			path: pointer,
+			opIndex
+		};
+	}
+}
+function resolveNodeAtPath$1(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}'`
 				}
-				return withOpIndex(toApplyError$1(/* @__PURE__ */ new Error(`failed to resolve move source at ${op.from}`)), opIndex);
-			}
-			if (op.from === op.path) continue;
-			const removeStep = applySequentialOp({
-				op: "remove",
-				path: op.from
-			}, opIndex);
-			if (!removeStep.ok) return removeStep;
-			const addStep = applySequentialOp({
-				op: "add",
-				path: op.path,
-				value: fromValue
-			}, opIndex);
-			if (!addStep.ok) return addStep;
+			};
+			current = entry.node;
 			continue;
 		}
-		const step = applySequentialOp(op, opIndex);
-		if (!step.ok) return step;
+		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 {
+			ok: false,
+			error: {
+				code: 409,
+				reason: "INVALID_TARGET",
+				message: `Cannot traverse into non-container at '${segment}'`
+			}
+		};
 	}
-	return { ok: true };
+	return {
+		ok: true,
+		node: current
+	};
 }
-function withOpIndex(error, opIndex) {
+function parseArrayIndexTokenForDoc$1(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$1(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 withOpIndex$1(error, opIndex) {
 	if (error.opIndex !== void 0) return error;
 	return {
 		...error,
@@ -2787,10 +3529,13 @@ function tryApplyPatchInPlace(state, patch, options = {}) {
 * Does not mutate caller-provided values.
 */
 function validateJsonPatch(base, patch, options = {}) {
-	const result = tryApplyPatch(createState(base, {
+	const result = tryApplyPatchInPlace(createState(base, {
 		actor: "__validate__",
 		jsonValidation: options.jsonValidation
-	}), patch, options);
+	}), patch, {
+		...options,
+		atomic: false
+	});
 	if (!result.ok) return {
 		ok: false,
 		error: result.error
@@ -2811,7 +3556,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))
@@ -2839,32 +3584,19 @@ function toApplyPatchOptionsForActor(options) {
 		} : void 0
 	};
 }
-function applyPatchInternal(state, patch, options, execution) {
+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 = 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 });
-		}
 		const explicitBaseState = options.base ? {
 			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;
+		const session = { pointerCache: /* @__PURE__ */ new Map() };
 		for (const [opIndex, op] of runtimePatch.entries()) {
-			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : state.doc, sequentialBaseJson, sequentialHeadJson, explicitBaseState, opIndex, session);
+			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 };
 	}
@@ -2873,12 +3605,12 @@ function applyPatchInternal(state, patch, options, execution) {
 	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, session) {
+function applyPatchOpSequential(state, op, options, baseDoc, explicitBaseState, opIndex, session) {
 	if (op.op === "move") {
-		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex, session.pointerCache);
+		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, opIndex, session);
@@ -2888,152 +3620,184 @@ function applyPatchOpSequential(state, op, options, baseDoc, baseJson, headJson,
 			path: op.path,
 			value: fromValue
 		};
-		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 (!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, opIndex, session);
+		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, session.pointerCache);
+		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, opIndex, session);
 	}
-	return applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, op, options, explicitBaseState, opIndex, session);
+	return applySinglePatchOpSequentialStep(state, baseDoc, op, options, explicitBaseState, opIndex, session);
 }
-function applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, op, options, explicitBaseState, opIndex, session) {
-	const compiled = compilePreparedIntents(baseJson, [op], "base", session.pointerCache, opIndex);
+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;
+	if (!headStep.ok) return withOpIndex(headStep, opIndex);
 	if (explicitBaseState && op.op !== "test") {
 		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 (!shadowStep.ok) return withOpIndex(shadowStep, opIndex);
 	}
-	if (op.op === "test") return {
-		ok: true,
-		baseJson,
-		headJson
-	};
-	const nextBaseJson = applyJsonPatchOpToShadow(baseJson, op, explicitBaseState ? session.baseShadowParentCache : session.headShadowParentCache, {
-		pointerCache: session.pointerCache,
-		opIndex
-	});
-	return {
-		ok: true,
-		baseJson: nextBaseJson,
-		headJson: explicitBaseState ? applyJsonPatchOpToShadow(headJson, op, session.headShadowParentCache, {
-			pointerCache: session.pointerCache,
-			opIndex
-		}) : nextBaseJson
-	};
+	return { ok: true };
 }
-function applySinglePatchOpExplicitShadowStep(explicitBaseState, baseJson, op, options, opIndex, session) {
-	const compiled = compilePreparedIntents(baseJson, [op], "base", session.pointerCache, opIndex);
+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
+	if (!shadowStep.ok) return withOpIndex(shadowStep, opIndex);
+	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, session.baseShadowParentCache, {
-			pointerCache: session.pointerCache,
-			opIndex
-		})
+		value: materialize(resolved.node)
 	};
 }
-function applyJsonPatchOpToShadow(baseJson, op, parentCache, pointerContext) {
+function compilePreparedSingleIntentFromDoc(baseDoc, op, pointerCache, opIndex) {
 	let path;
 	try {
-		path = parsePointerWithCache(op.path, pointerContext.pointerCache);
+		path = parsePointerWithCache(op.path, pointerCache);
 	} catch (error) {
-		throw toPointerParseCompileError(error, op.path, pointerContext.opIndex);
+		return toPointerParseApplyError(error, op.path, opIndex);
 	}
+	if (op.op === "test") return {
+		ok: true,
+		intents: [{
+			t: "Test",
+			path,
+			value: op.value
+		}]
+	};
 	if (path.length === 0) {
-		parentCache.clear();
-		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 pathPointer = op.path;
 	const parentPath = path.slice(0, -1);
-	const parentPointer = pointerParent(pathPointer);
+	const parentPointer = stringifyJsonPointer(parentPath);
 	const key = path[path.length - 1];
-	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;
-	}
-	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 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 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
+			}]
+		};
 	}
-	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);
+	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);
@@ -3042,21 +3806,129 @@ function parsePointerWithCache(pointer, pointerCache) {
 	pointerCache.set(pointer, parsedPath);
 	return parsedPath.slice();
 }
-function resolveValueAtPointer(baseJson, pointer, opIndex, pointerCache) {
-	let path;
-	try {
-		path = parsePointerWithCache(pointer, pointerCache);
-	} catch (error) {
-		return toPointerParseApplyError(error, pointer, opIndex);
+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 (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 {
+			ok: false,
+			error: {
+				code: 409,
+				reason: "INVALID_TARGET",
+				message: `Cannot traverse into non-container at '${segment}'`
+			}
+		};
 	}
-	try {
+	return {
+		ok: true,
+		node: current
+	};
+}
+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,
-			value: getAtJson(baseJson, path)
+			index: Number.POSITIVE_INFINITY
 		};
-	} catch (error) {
-		return toPointerLookupApplyError(error, pointer, opIndex);
 	}
+	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;
@@ -3127,40 +3999,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 {
@@ -3178,26 +4016,19 @@ function toApplyError(error) {
 		message: error instanceof Error ? error.message : "failed to compile patch"
 	};
 }
-function toPointerParseApplyError(error, pointer, opIndex) {
+function withOpIndex(error, opIndex) {
+	if (error.opIndex !== void 0) return error;
 	return {
-		ok: false,
-		code: 409,
-		reason: "INVALID_POINTER",
-		message: error instanceof Error ? error.message : "invalid pointer",
-		path: pointer,
+		...error,
 		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);
+function toPointerParseApplyError(error, pointer, opIndex) {
 	return {
 		ok: false,
 		code: 409,
-		reason: mapped.reason,
-		message: mapped.message,
+		reason: "INVALID_POINTER",
+		message: error instanceof Error ? error.message : "invalid pointer",
 		path: pointer,
 		opIndex
 	};
@@ -3206,6 +4037,8 @@ function toPointerLookupApplyError(error, 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);
 }
@@ -3230,13 +4063,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) {
@@ -3257,6 +4093,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,
@@ -3264,16 +4101,21 @@ 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 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(data.doc);
-	const observedCtr = maxObservedCounterForActorInNode(doc.root, actor);
+	const doc = deserializeDoc(raw.doc);
+	const observedCtr = observedVersionVector(doc)[actor] ?? 0;
 	return {
 		doc,
 		clock: createClock(actor, Math.max(ctr, observedCtr))
@@ -3347,6 +4189,16 @@ function serializeNode(node) {
 		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);
@@ -3434,28 +4286,19 @@ 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;
 }
+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 {
@@ -3553,20 +4396,23 @@ function mergeDoc(a, b, options = {}) {
 /** Non-throwing `mergeDoc` variant with structured conflict details. */
 function tryMergeDoc(a, b, options = {}) {
 	try {
-		const mismatchPath = options.requireSharedOrigin ?? true ? findSeqLineageMismatch(a.root, b.root, []) : null;
-		if (mismatchPath) return {
-			ok: false,
-			error: {
+		const config = { unrelatedArrays: resolveUnrelatedArraysStrategy(options) };
+		if (config.unrelatedArrays === "reject") {
+			const mismatchPath = findSeqLineageMismatch(a.root, b.root, []);
+			if (mismatchPath !== null) return {
 				ok: false,
-				code: 409,
-				reason: "LINEAGE_MISMATCH",
-				message: `merge requires shared array origin at ${mismatchPath}`,
-				path: mismatchPath
-			}
-		};
+				error: {
+					ok: false,
+					code: 409,
+					reason: "LINEAGE_MISMATCH",
+					message: `merge requires shared array origin at ${mismatchPath}`,
+					path: mismatchPath
+				}
+			};
+		}
 		return {
 			ok: true,
-			doc: { root: mergeNode(a.root, b.root) }
+			doc: mergeDocRoot(a.root, b.root, config).doc
 		};
 	} catch (error) {
 		if (error instanceof SharedElementMetadataMismatchError) return {
@@ -3592,7 +4438,7 @@ function tryMergeDoc(a, b, options = {}) {
 * The merged clock keeps a stable actor identity:
 * - defaults to the actor from the first argument (`a`)
 * - can be overridden via `options.actor`
-* - optional `options.requireSharedOrigin` controls merge lineage checks
+* - optional `options.unrelatedArrays` controls the merge strategy for non-overlapping sequences
 *
 * The merged counter is lifted to the highest counter already observed for
 * that actor across both input clocks and the merged document dots.
@@ -3604,17 +4450,51 @@ function mergeState(a, b, options = {}) {
 }
 /** Non-throwing `mergeState` variant with structured conflict details. */
 function tryMergeState(a, b, options = {}) {
-	const mergedDoc = tryMergeDoc(a.doc, b.doc, { requireSharedOrigin: options.requireSharedOrigin });
-	if (!mergedDoc.ok) return mergedDoc;
-	const doc = mergedDoc.doc;
-	const actor = options.actor ?? a.clock.actor;
-	return {
-		ok: true,
-		state: {
-			doc,
-			clock: createClock(actor, maxObservedCtrForActor(doc, actor, a, b))
+	try {
+		const actor = options.actor ?? a.clock.actor;
+		const config = {
+			actor,
+			unrelatedArrays: resolveUnrelatedArraysStrategy(options)
+		};
+		if (config.unrelatedArrays === "reject") {
+			const mismatchPath = findSeqLineageMismatch(a.doc.root, b.doc.root, []);
+			if (mismatchPath !== null) return {
+				ok: false,
+				error: {
+					ok: false,
+					code: 409,
+					reason: "LINEAGE_MISMATCH",
+					message: `merge requires shared array origin at ${mismatchPath}`,
+					path: mismatchPath
+				}
+			};
 		}
-	};
+		const merged = mergeDocRoot(a.doc.root, b.doc.root, config);
+		const ctr = maxObservedCtrForActor(merged.maxObservedCtr, actor, a, b);
+		return {
+			ok: true,
+			state: {
+				doc: merged.doc,
+				clock: createClock(actor, ctr)
+			}
+		};
+	} catch (error) {
+		if (error instanceof SharedElementMetadataMismatchError) return {
+			ok: false,
+			error: {
+				ok: false,
+				code: 409,
+				reason: "LINEAGE_MISMATCH",
+				message: error.message,
+				path: error.path
+			}
+		};
+		if (error instanceof TraversalDepthError) return {
+			ok: false,
+			error: toDepthApplyError(error)
+		};
+		throw error;
+	}
 }
 function findSeqLineageMismatch(a, b, path) {
 	const stack = [{
@@ -3635,7 +4515,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") {
@@ -3657,14 +4537,29 @@ function findSeqLineageMismatch(a, b, path) {
 	}
 	return null;
 }
-function maxObservedCtrForActor(doc, actor, a, b) {
-	let best = maxCtrInNodeForActor(doc.root, actor);
+function mergeDocRoot(a, b, config) {
+	const merged = mergeNodeAtDepth(a, b, 0, [], config);
+	return {
+		doc: { root: merged.node },
+		maxObservedCtr: merged.maxObservedCtr
+	};
+}
+function resolveUnrelatedArraysStrategy(options) {
+	if (options.unrelatedArrays !== void 0) return options.unrelatedArrays;
+	if (options.requireSharedOrigin === false) return "unsafe-union";
+	return "reject";
+}
+function maxObservedCtrForActor(docObservedCtr, actor, a, b) {
+	let best = docObservedCtr;
 	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;
+function repDot(node) {
+	let best = {
+		actor: "",
+		ctr: 0
+	};
 	const stack = [{
 		node,
 		depth: 0
@@ -3672,158 +4567,188 @@ function maxCtrInNodeForActor(node, actor) {
 	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
-			});
+		switch (frame.node.kind) {
+			case "lww":
+				if (compareDot(frame.node.dot, best) > 0) best = frame.node.dot;
+				break;
+			case "obj":
+				for (const entry of frame.node.entries.values()) {
+					if (compareDot(entry.dot, best) > 0) best = entry.dot;
+					stack.push({
+						node: entry.node,
+						depth: frame.depth + 1
+					});
+				}
+				for (const tombstone of frame.node.tombstone.values()) if (compareDot(tombstone, best) > 0) best = tombstone;
+				break;
+			case "seq":
+				for (const elem of frame.node.elems.values()) {
+					if (compareDot(elem.insDot, best) > 0) best = elem.insDot;
+					if (elem.delDot && compareDot(elem.delDot, best) > 0) best = elem.delDot;
+					stack.push({
+						node: elem.value,
+						depth: frame.depth + 1
+					});
+				}
+				break;
 		}
 	}
 	return best;
 }
-function repDot(node) {
-	switch (node.kind) {
-		case "lww": return node.dot;
-		case "obj": {
-			let best = {
-				actor: "",
-				ctr: 0
-			};
-			for (const entry of node.entries.values()) if (compareDot(entry.dot, best) > 0) best = entry.dot;
-			for (const d of node.tombstone.values()) if (compareDot(d, best) > 0) best = d;
-			return best;
-		}
-		case "seq": {
-			let best = {
-				actor: "",
-				ctr: 0
-			};
-			for (const e of node.elems.values()) if (compareDot(e.insDot, best) > 0) best = e.insDot;
-			return best;
-		}
-	}
-}
-function mergeNode(a, b) {
-	return mergeNodeAtDepth(a, b, 0, []);
-}
-function mergeNodeAtDepth(a, b, depth, path) {
+function mergeNodeAtDepth(a, b, depth, path, config) {
 	assertTraversalDepth(depth);
-	if (a.kind === "lww" && b.kind === "lww") return mergeLww(a, b);
-	if (a.kind === "obj" && b.kind === "obj") return mergeObj(a, b, depth + 1, path);
-	if (a.kind === "seq" && b.kind === "seq") return mergeSeq(a, b, depth + 1, path);
-	if (compareDot(repDot(a), repDot(b)) >= 0) return cloneNodeShallow(a, depth + 1);
-	return cloneNodeShallow(b, depth + 1);
+	if (a.kind === "lww" && b.kind === "lww") return mergeLww(a, b, config.actor);
+	if (a.kind === "obj" && b.kind === "obj") return mergeObj(a, b, depth + 1, path, config);
+	if (a.kind === "seq" && b.kind === "seq") return mergeSeq(a, b, depth + 1, path, config);
+	if (compareDot(repDot(a), repDot(b)) >= 0) return cloneNodeShallow(a, depth + 1, config.actor);
+	return cloneNodeShallow(b, depth + 1, config.actor);
 }
-function mergeLww(a, b) {
+function mergeLww(a, b, actor) {
 	if (compareDot(a.dot, b.dot) >= 0) return {
-		kind: "lww",
-		value: structuredClone(a.value),
-		dot: { ...a.dot }
+		node: {
+			kind: "lww",
+			value: structuredClone(a.value),
+			dot: { ...a.dot }
+		},
+		maxObservedCtr: maxObservedCtrForDot(a.dot, actor)
 	};
 	return {
-		kind: "lww",
-		value: structuredClone(b.value),
-		dot: { ...b.dot }
+		node: {
+			kind: "lww",
+			value: structuredClone(b.value),
+			dot: { ...b.dot }
+		},
+		maxObservedCtr: maxObservedCtrForDot(b.dot, actor)
 	};
 }
-function mergeObj(a, b, depth, path) {
+function mergeObj(a, b, depth, path, config) {
 	assertTraversalDepth(depth);
 	const entries = /* @__PURE__ */ new Map();
 	const tombstone = /* @__PURE__ */ new Map();
+	let maxObservedCtr = 0;
 	const allTombKeys = new Set([...a.tombstone.keys(), ...b.tombstone.keys()]);
 	for (const key of allTombKeys) {
 		const da = a.tombstone.get(key);
 		const db = b.tombstone.get(key);
-		if (da && db) tombstone.set(key, compareDot(da, db) >= 0 ? { ...da } : { ...db });
-		else if (da) tombstone.set(key, { ...da });
-		else tombstone.set(key, { ...db });
+		if (da && db) {
+			const mergedDot = compareDot(da, db) >= 0 ? { ...da } : { ...db };
+			tombstone.set(key, mergedDot);
+			maxObservedCtr = Math.max(maxObservedCtr, maxObservedCtrForDot(mergedDot, config.actor));
+		} else if (da) {
+			tombstone.set(key, { ...da });
+			maxObservedCtr = Math.max(maxObservedCtr, maxObservedCtrForDot(da, config.actor));
+		} else {
+			tombstone.set(key, { ...db });
+			maxObservedCtr = Math.max(maxObservedCtr, maxObservedCtrForDot(db, config.actor));
+		}
 	}
 	const allKeys = new Set([...a.entries.keys(), ...b.entries.keys()]);
 	for (const key of allKeys) {
 		const ea = a.entries.get(key);
 		const eb = b.entries.get(key);
 		let merged;
-		if (ea && eb) merged = {
-			node: mergeNodeAtDepth(ea.node, eb.node, depth + 1, [...path, key]),
-			dot: compareDot(ea.dot, eb.dot) >= 0 ? { ...ea.dot } : { ...eb.dot }
-		};
-		else if (ea) merged = {
-			node: cloneNodeShallow(ea.node, depth + 1),
-			dot: { ...ea.dot }
-		};
-		else merged = {
-			node: cloneNodeShallow(eb.node, depth + 1),
-			dot: { ...eb.dot }
-		};
+		let mergedNodeMaxObservedCtr = 0;
+		if (ea && eb) {
+			const mergedNode = mergeNodeAtDepth(ea.node, eb.node, depth + 1, [...path, key], config);
+			const dot = compareDot(ea.dot, eb.dot) >= 0 ? { ...ea.dot } : { ...eb.dot };
+			merged = {
+				node: mergedNode.node,
+				dot
+			};
+			mergedNodeMaxObservedCtr = mergedNode.maxObservedCtr;
+		} else if (ea) {
+			const cloned = cloneNodeShallow(ea.node, depth + 1, config.actor);
+			merged = {
+				node: cloned.node,
+				dot: { ...ea.dot }
+			};
+			mergedNodeMaxObservedCtr = cloned.maxObservedCtr;
+		} else {
+			const cloned = cloneNodeShallow(eb.node, depth + 1, config.actor);
+			merged = {
+				node: cloned.node,
+				dot: { ...eb.dot }
+			};
+			mergedNodeMaxObservedCtr = cloned.maxObservedCtr;
+		}
 		const td = tombstone.get(key);
 		if (td && compareDot(td, merged.dot) >= 0) continue;
 		entries.set(key, merged);
+		maxObservedCtr = Math.max(maxObservedCtr, mergedNodeMaxObservedCtr, maxObservedCtrForDot(merged.dot, config.actor));
 	}
 	return {
-		kind: "obj",
-		entries,
-		tombstone
+		node: {
+			kind: "obj",
+			entries,
+			tombstone
+		},
+		maxObservedCtr
 	};
 }
-function mergeSeq(a, b, depth, path) {
+function mergeSeq(a, b, depth, path, config) {
 	assertTraversalDepth(depth);
+	if (config.unrelatedArrays === "atomic-replace" && a.elems.size > 0 && b.elems.size > 0) {
+		let shared = false;
+		for (const id of a.elems.keys()) if (b.elems.has(id)) {
+			shared = true;
+			break;
+		}
+		if (!shared) return cloneNodeShallow(compareDot(repDot(a), repDot(b)) >= 0 ? a : b, depth, config.actor);
+	}
 	const elems = /* @__PURE__ */ new Map();
+	let maxObservedCtr = 0;
 	const allIds = new Set([...a.elems.keys(), ...b.elems.keys()]);
 	for (const id of allIds) {
 		const ea = a.elems.get(id);
 		const eb = b.elems.get(id);
 		if (ea && eb) {
-			if (ea.prev !== eb.prev) throw new SharedElementMetadataMismatchError(toPointer(path), id, "prev");
-			if (!sameDot(ea.insDot, eb.insDot)) throw new SharedElementMetadataMismatchError(toPointer(path), id, "insDot");
-			const mergedValue = mergeNodeAtDepth(ea.value, eb.value, depth + 1, [...path, id]);
+			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], config);
+			const mergedDeleteDot = mergeDeleteDot(ea.delDot, eb.delDot);
 			elems.set(id, {
 				id,
 				prev: ea.prev,
 				tombstone: ea.tombstone || eb.tombstone,
-				delDot: mergeDeleteDot(ea.delDot, eb.delDot),
-				value: mergedValue,
+				delDot: mergedDeleteDot,
+				value: mergedValue.node,
 				insDot: { ...ea.insDot }
 			});
-		} else if (ea) elems.set(id, cloneElem(ea, depth + 1));
-		else elems.set(id, cloneElem(eb, depth + 1));
+			maxObservedCtr = Math.max(maxObservedCtr, mergedValue.maxObservedCtr, maxObservedCtrForDot(ea.insDot, config.actor), maxObservedCtrForDot(mergedDeleteDot, config.actor));
+		} else if (ea) {
+			const cloned = cloneElem(ea, depth + 1, config.actor);
+			elems.set(id, cloned.elem);
+			maxObservedCtr = Math.max(maxObservedCtr, cloned.maxObservedCtr);
+		} else {
+			const cloned = cloneElem(eb, depth + 1, config.actor);
+			elems.set(id, cloned.elem);
+			maxObservedCtr = Math.max(maxObservedCtr, cloned.maxObservedCtr);
+		}
 	}
 	return {
-		kind: "seq",
-		elems
+		node: {
+			kind: "seq",
+			elems
+		},
+		maxObservedCtr
 	};
 }
 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) {
+function cloneElem(e, depth, actor) {
 	assertTraversalDepth(depth);
+	const value = cloneNodeShallow(e.value, depth + 1, actor);
 	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 }
+		elem: {
+			id: e.id,
+			prev: e.prev,
+			tombstone: e.tombstone,
+			delDot: e.delDot ? { ...e.delDot } : void 0,
+			value: value.node,
+			insDot: { ...e.insDot }
+		},
+		maxObservedCtr: Math.max(value.maxObservedCtr, maxObservedCtrForDot(e.insDot, actor), maxObservedCtrForDot(e.delDot, actor))
 	};
 }
 function mergeDeleteDot(a, b) {
@@ -3831,38 +4756,64 @@ function mergeDeleteDot(a, b) {
 	if (a) return { ...a };
 	if (b) return { ...b };
 }
-function cloneNodeShallow(node, depth) {
+function cloneNodeShallow(node, depth, actor) {
 	assertTraversalDepth(depth);
 	switch (node.kind) {
 		case "lww": return {
-			kind: "lww",
-			value: structuredClone(node.value),
-			dot: { ...node.dot }
+			node: {
+				kind: "lww",
+				value: structuredClone(node.value),
+				dot: { ...node.dot }
+			},
+			maxObservedCtr: maxObservedCtrForDot(node.dot, actor)
 		};
 		case "obj": {
 			const entries = /* @__PURE__ */ new Map();
-			for (const [k, v] of node.entries) entries.set(k, {
-				node: cloneNodeShallow(v.node, depth + 1),
-				dot: { ...v.dot }
-			});
+			let maxObservedCtr = 0;
+			for (const [k, v] of node.entries) {
+				const cloned = cloneNodeShallow(v.node, depth + 1, actor);
+				entries.set(k, {
+					node: cloned.node,
+					dot: { ...v.dot }
+				});
+				maxObservedCtr = Math.max(maxObservedCtr, cloned.maxObservedCtr, maxObservedCtrForDot(v.dot, actor));
+			}
 			const tombstone = /* @__PURE__ */ new Map();
-			for (const [k, d] of node.tombstone) tombstone.set(k, { ...d });
+			for (const [k, d] of node.tombstone) {
+				tombstone.set(k, { ...d });
+				maxObservedCtr = Math.max(maxObservedCtr, maxObservedCtrForDot(d, actor));
+			}
 			return {
-				kind: "obj",
-				entries,
-				tombstone
+				node: {
+					kind: "obj",
+					entries,
+					tombstone
+				},
+				maxObservedCtr
 			};
 		}
 		case "seq": {
 			const elems = /* @__PURE__ */ new Map();
-			for (const [id, e] of node.elems) elems.set(id, cloneElem(e, depth + 1));
+			let maxObservedCtr = 0;
+			for (const [id, e] of node.elems) {
+				const cloned = cloneElem(e, depth + 1, actor);
+				elems.set(id, cloned.elem);
+				maxObservedCtr = Math.max(maxObservedCtr, cloned.maxObservedCtr);
+			}
 			return {
-				kind: "seq",
-				elems
+				node: {
+					kind: "seq",
+					elems
+				},
+				maxObservedCtr
 			};
 		}
 	}
 }
+function maxObservedCtrForDot(dot, actor) {
+	if (!dot || !actor || dot.actor !== actor) return 0;
+	return dot.ctr;
+}
 
 //#endregion
 //#region src/compact.ts
@@ -4142,6 +5093,12 @@ Object.defineProperty(exports, 'getAtJson', {
     return getAtJson;
   }
 });
+Object.defineProperty(exports, 'intersectVersionVectors', {
+  enumerable: true,
+  get: function () {
+    return intersectVersionVectors;
+  }
+});
 Object.defineProperty(exports, 'jsonEquals', {
   enumerable: true,
   get: function () {
@@ -4184,6 +5141,12 @@ Object.defineProperty(exports, 'mergeState', {
     return mergeState;
   }
 });
+Object.defineProperty(exports, 'mergeVersionVectors', {
+  enumerable: true,
+  get: function () {
+    return mergeVersionVectors;
+  }
+});
 Object.defineProperty(exports, 'newObj', {
   enumerable: true,
   get: function () {
@@ -4232,6 +5195,12 @@ Object.defineProperty(exports, 'observeDot', {
     return observeDot;
   }
 });
+Object.defineProperty(exports, 'observedVersionVector', {
+  enumerable: true,
+  get: function () {
+    return observedVersionVector;
+  }
+});
 Object.defineProperty(exports, 'parseJsonPointer', {
   enumerable: true,
   get: function () {
@@ -4292,6 +5261,12 @@ Object.defineProperty(exports, 'serializeState', {
     return serializeState;
   }
 });
+Object.defineProperty(exports, 'stableJsonValueKey', {
+  enumerable: true,
+  get: function () {
+    return stableJsonValueKey;
+  }
+});
 Object.defineProperty(exports, 'stringifyJsonPointer', {
   enumerable: true,
   get: function () {
@@ -4364,6 +5339,12 @@ Object.defineProperty(exports, 'validateRgaSeq', {
     return validateRgaSeq;
   }
 });
+Object.defineProperty(exports, 'versionVectorCovers', {
+  enumerable: true,
+  get: function () {
+    return versionVectorCovers;
+  }
+});
 Object.defineProperty(exports, 'vvHasDot', {
   enumerable: true,
   get: function () {