json-patch-to-crdt 0.3.0 → 0.5.0

package/dist/{compact-BS7F604m.mjs → compact-Dj0BYeY5.mjs}

@@ -1,18 +1,38 @@
-//#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,
@@ -20,6 +40,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.
@@ -56,8 +175,8 @@ function cloneClock(clock) {
 * Useful when a server needs to mint dots for many actors.
 */
 function nextDotForActor(vv, actor) {
-	const ctr = readVvCounter$1(vv, actor) + 1;
-	writeVvCounter$1(vv, actor, ctr);
+	const ctr = (readVersionVectorCounter(vv, actor) ?? 0) + 1;
+	writeVersionVectorCounter(vv, actor, ctr);
 	return {
 		actor,
 		ctr
@@ -65,63 +184,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}`;
@@ -205,6 +281,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 {
@@ -412,6 +494,8 @@ function rgaPrevForInsertAtIndex(seq, index) {
 
 //#endregion
 //#region src/materialize.ts
+let materializeObserver = null;
+const EMPTY_PATH = [];
 function createMaterializedObject() {
 	return Object.create(null);
 }
@@ -425,6 +509,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 = [];
@@ -432,13 +518,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];
@@ -452,6 +541,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;
@@ -463,7 +554,8 @@ function materialize(node) {
 					kind: "obj",
 					depth: childDepth,
 					entries: child.entries.entries(),
-					out: outObj
+					out: outObj,
+					path: childPath
 				});
 				continue;
 			}
@@ -473,7 +565,9 @@ function materialize(node) {
 				kind: "seq",
 				depth: childDepth,
 				cursor: rgaCreateLinearCursor(child),
-				out: outArr
+				out: outArr,
+				path: childPath,
+				nextIndex: 0
 			});
 			continue;
 		}
@@ -485,6 +579,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;
@@ -496,7 +593,8 @@ function materialize(node) {
 				kind: "obj",
 				depth: childDepth,
 				entries: child.entries.entries(),
-				out: outObj
+				out: outObj,
+				path: childPath
 			});
 			continue;
 		}
@@ -506,7 +604,9 @@ function materialize(node) {
 			kind: "seq",
 			depth: childDepth,
 			cursor: rgaCreateLinearCursor(child),
-			out: outArr
+			out: outArr,
+			path: childPath,
+			nextIndex: 0
 		});
 	}
 	return root;
@@ -617,6 +717,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
 */
@@ -703,7 +804,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);
@@ -714,8 +818,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
@@ -846,8 +958,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.
@@ -864,39 +976,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 = [];
@@ -929,12 +1099,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) {
@@ -957,18 +1126,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();
@@ -977,12 +1142,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);
@@ -998,12 +1161,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);
@@ -1013,8 +1175,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;
 			}
 		}
@@ -1023,8 +1184,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;
@@ -1036,8 +1196,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;
@@ -1064,9 +1233,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;
@@ -1263,17 +1434,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",
@@ -1312,7 +1488,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",
@@ -1351,10 +1527,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 = [];
@@ -1374,9 +1615,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);
@@ -1388,29 +1685,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}"`);
@@ -1420,21 +1748,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;
 }
@@ -1725,51 +2071,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("/")}`
-		};
-		const entry = cur.entries.get(seg);
-		seen.push(seg);
-		if (!entry || entry.node.kind !== "obj") return {
 			ok: false,
-			message: `expected object at /${seen.join("/")}`
+			message: `expected object at ${pointer === "" ? "/" : pointer}`
 		};
-		cur = entry.node;
 	}
 	return {
 		ok: true,
-		obj: cur
+		obj: node
 	};
 }
 function ensureSeqAtPath(head, path, dotForCreate) {
@@ -1816,10 +2146,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;
 }
@@ -2033,38 +2377,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",
@@ -2369,6 +2763,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;
@@ -2493,6 +2927,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;
@@ -2518,8 +2981,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.
@@ -2561,7 +3023,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__",
@@ -2570,196 +3032,476 @@ 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 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 };
-	};
-	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 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;
-			continue;
-		}
-		const step = applySequentialOp(op, 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 withOpIndex(error, opIndex) {
-	if (error.opIndex !== void 0) return error;
-	return {
-		...error,
-		opIndex
-	};
+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 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 isJsonPatchToCrdtOptions(value) {
-	return typeof value === "object" && value !== null && "base" in value && "head" in value && "patch" in value && "newDot" in value;
+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 toApplyError$1(error) {
-	if (error instanceof TraversalDepthError) return toDepthApplyError(error);
-	if (error instanceof PatchCompileError) return {
+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,
-		code: 409,
-		reason: error.reason,
-		message: error.message,
-		path: error.path,
-		opIndex: error.opIndex
-	};
-	return {
-		ok: false,
-		code: 409,
-		reason: "INVALID_PATCH",
-		message: error instanceof Error ? error.message : "failed to compile/apply patch"
-	};
-}
-function assertNever(_value, message) {
-	throw new Error(message);
-}
-
-//#endregion
-//#region src/state.ts
-/** Error thrown when a JSON Patch cannot be applied. Includes structured conflict metadata. */
-var PatchError = class extends Error {
-	code;
-	reason;
-	path;
-	opIndex;
-	constructor(errorOrMessage, code = 409, reason = "INVALID_PATCH") {
-		super(typeof errorOrMessage === "string" ? errorOrMessage : errorOrMessage.message);
-		this.name = "PatchError";
-		if (typeof errorOrMessage === "string") {
-			this.code = code;
-			this.reason = reason;
-			return;
-		}
-		this.code = errorOrMessage.code;
-		this.reason = errorOrMessage.reason;
-		this.path = errorOrMessage.path;
-		this.opIndex = errorOrMessage.opIndex;
-	}
-};
-/**
-* Create a new CRDT state from an initial JSON value.
-* @param initial - The initial JSON document.
-* @param options - Actor ID and optional starting counter.
-* @returns A new `CrdtState` containing the document and clock.
-*/
-function createState(initial, options) {
-	const clock = createClock(options.actor, options.start ?? 0);
-	return {
-		doc: docFromJson(coerceRuntimeJsonValue(initial, options.jsonValidation ?? "none"), clock.next),
-		clock
+		...resolved.error,
+		path: pointer,
+		opIndex
 	};
-}
-/**
-* Fork a replica from a shared origin state while assigning a new local actor ID.
-* The forked state has an independent document clone and clock.
-* By default this rejects actor reuse to prevent duplicate-dot collisions across peers.
-*/
-function forkState(origin, actor, options = {}) {
-	if (actor === origin.clock.actor && !options.allowActorReuse) throw new Error(`forkState actor must be unique; refusing to reuse origin actor '${actor}'`);
 	return {
-		doc: cloneDoc(origin.doc),
-		clock: createClock(actor, origin.clock.ctr)
+		ok: true,
+		value: nodeToJsonForPatch(resolved.node)
 	};
 }
-/**
-* Materialize a CRDT document or state back to a plain JSON value.
-* @param target - A `Doc` or `CrdtState` to materialize.
-* @returns The JSON representation of the current document.
-*/
-function toJson(target) {
-	if ("doc" in target) return materialize(target.doc.root);
-	return materialize(target.root);
-}
-/**
-* Apply a JSON Patch to the state, returning a new immutable state.
-* Throws `PatchError` on conflict (e.g. out-of-bounds index, failed test op).
-* @param state - The current CRDT state.
-* @param patch - Array of RFC 6902 JSON Patch operations.
-* @param options - Optional base state snapshot and patch semantics.
-* @returns A new `CrdtState` with the patch applied.
-*/
-function applyPatch(state, patch, options = {}) {
-	const result = tryApplyPatch(state, patch, options);
-	if (!result.ok) throw new PatchError(result.error);
-	return result.state;
-}
-/**
-* Apply a JSON Patch to the state in place, mutating the existing state.
-* Throws `PatchError` on conflict.
-* @param state - The CRDT state to mutate.
-* @param patch - Array of RFC 6902 JSON Patch operations.
-* @param options - Optional base state snapshot, patch semantics, and atomicity.
-*/
-function applyPatchInPlace(state, patch, options = {}) {
-	const result = tryApplyPatchInPlace(state, patch, options);
-	if (!result.ok) throw new PatchError(result.error);
-}
-/** Non-throwing immutable patch application variant. */
-function tryApplyPatch(state, patch, options = {}) {
-	const nextState = {
-		doc: cloneDoc(state.doc),
-		clock: cloneClock(state.clock)
+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
+		}]
 	};
-	try {
-		const result = applyPatchInternal(nextState, patch, options, "batch");
-		if (!result.ok) return {
+	if (path.length === 0) {
+		if (op.op === "remove") return {
 			ok: false,
-			error: result
+			code: 409,
+			reason: "INVALID_TARGET",
+			message: "remove at root path is not supported in RFC-compliant mode",
+			path: op.path,
+			opIndex
 		};
-	} catch (error) {
 		return {
-			ok: false,
-			error: toApplyError(error)
+			ok: true,
+			intents: [{
+				t: "ObjSet",
+				path: [],
+				key: ROOT_KEY,
+				value: op.value
+			}]
 		};
 	}
-	return {
+	const parentPath = path.slice(0, -1);
+	const parentPointer = stringifyJsonPointer(parentPath);
+	const key = path[path.length - 1];
+	const resolvedParent = parentPath.length === 0 ? {
 		ok: true,
-		state: nextState
+		node: baseDoc.root
+	} : resolveNodeAtPath$1(baseDoc.root, parentPath);
+	if (!resolvedParent.ok) return {
+		ok: false,
+		...resolvedParent.error,
+		path: parentPointer,
+		opIndex
 	};
-}
-/** Non-throwing in-place patch application variant. */
-function tryApplyPatchInPlace(state, patch, options = {}) {
-	const { atomic = true, ...applyOptions } = options;
+	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}'`
+				}
+			};
+			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}'`
+			}
+		};
+	}
+	return {
+		ok: true,
+		node: current
+	};
+}
+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,
+		opIndex
+	};
+}
+function isJsonPatchToCrdtOptions(value) {
+	return typeof value === "object" && value !== null && "base" in value && "head" in value && "patch" in value && "newDot" in value;
+}
+function toApplyError$1(error) {
+	if (error instanceof TraversalDepthError) return toDepthApplyError(error);
+	if (error instanceof PatchCompileError) return {
+		ok: false,
+		code: 409,
+		reason: error.reason,
+		message: error.message,
+		path: error.path,
+		opIndex: error.opIndex
+	};
+	return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_PATCH",
+		message: error instanceof Error ? error.message : "failed to compile/apply patch"
+	};
+}
+function assertNever(_value, message) {
+	throw new Error(message);
+}
+
+//#endregion
+//#region src/state.ts
+/** Error thrown when a JSON Patch cannot be applied. Includes structured conflict metadata. */
+var PatchError = class extends Error {
+	code;
+	reason;
+	path;
+	opIndex;
+	constructor(errorOrMessage, code = 409, reason = "INVALID_PATCH") {
+		super(typeof errorOrMessage === "string" ? errorOrMessage : errorOrMessage.message);
+		this.name = "PatchError";
+		if (typeof errorOrMessage === "string") {
+			this.code = code;
+			this.reason = reason;
+			return;
+		}
+		this.code = errorOrMessage.code;
+		this.reason = errorOrMessage.reason;
+		this.path = errorOrMessage.path;
+		this.opIndex = errorOrMessage.opIndex;
+	}
+};
+/**
+* Create a new CRDT state from an initial JSON value.
+* @param initial - The initial JSON document.
+* @param options - Actor ID and optional starting counter.
+* @returns A new `CrdtState` containing the document and clock.
+*/
+function createState(initial, options) {
+	const clock = createClock(options.actor, options.start ?? 0);
+	return {
+		doc: docFromJson(coerceRuntimeJsonValue(initial, options.jsonValidation ?? "none"), clock.next),
+		clock
+	};
+}
+/**
+* Fork a replica from a shared origin state while assigning a new local actor ID.
+* The forked state has an independent document clone and clock.
+* By default this rejects actor reuse to prevent duplicate-dot collisions across peers.
+*/
+function forkState(origin, actor, options = {}) {
+	if (actor === origin.clock.actor && !options.allowActorReuse) throw new Error(`forkState actor must be unique; refusing to reuse origin actor '${actor}'`);
+	return {
+		doc: cloneDoc(origin.doc),
+		clock: createClock(actor, origin.clock.ctr)
+	};
+}
+/**
+* Materialize a CRDT document or state back to a plain JSON value.
+* @param target - A `Doc` or `CrdtState` to materialize.
+* @returns The JSON representation of the current document.
+*/
+function toJson(target) {
+	if ("doc" in target) return materialize(target.doc.root);
+	return materialize(target.root);
+}
+/**
+* Apply a JSON Patch to the state, returning a new immutable state.
+* Throws `PatchError` on conflict (e.g. out-of-bounds index, failed test op).
+* @param state - The current CRDT state.
+* @param patch - Array of RFC 6902 JSON Patch operations.
+* @param options - Optional base state snapshot and patch semantics.
+* @returns A new `CrdtState` with the patch applied.
+*/
+function applyPatch(state, patch, options = {}) {
+	const result = tryApplyPatch(state, patch, options);
+	if (!result.ok) throw new PatchError(result.error);
+	return result.state;
+}
+/**
+* Apply a JSON Patch to the state in place, mutating the existing state.
+* Throws `PatchError` on conflict.
+* @param state - The CRDT state to mutate.
+* @param patch - Array of RFC 6902 JSON Patch operations.
+* @param options - Optional base state snapshot, patch semantics, and atomicity.
+*/
+function applyPatchInPlace(state, patch, options = {}) {
+	const result = tryApplyPatchInPlace(state, patch, options);
+	if (!result.ok) throw new PatchError(result.error);
+}
+/** Non-throwing immutable patch application variant. */
+function tryApplyPatch(state, patch, options = {}) {
+	const nextState = {
+		doc: cloneDoc(state.doc),
+		clock: cloneClock(state.clock)
+	};
+	try {
+		const result = applyPatchInternal(nextState, patch, options, "batch");
+		if (!result.ok) return {
+			ok: false,
+			error: result
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			error: toApplyError(error)
+		};
+	}
+	return {
+		ok: true,
+		state: nextState
+	};
+}
+/** Non-throwing in-place patch application variant. */
+function tryApplyPatchInPlace(state, patch, options = {}) {
+	const { atomic = true, ...applyOptions } = options;
 	if (atomic) {
 		const next = tryApplyPatch(state, patch, applyOptions);
 		if (!next.ok) return next;
@@ -2786,10 +3528,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
@@ -2810,7 +3555,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))
@@ -2838,32 +3583,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 };
 	}
@@ -2872,12 +3604,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);
@@ -2887,176 +3619,316 @@ 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);
+	}
+	return { ok: true };
+}
+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 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,
+		value: materialize(resolved.node)
+	};
+}
+function compilePreparedSingleIntentFromDoc(baseDoc, op, pointerCache, opIndex) {
+	let path;
+	try {
+		path = parsePointerWithCache(op.path, pointerCache);
+	} catch (error) {
+		return toPointerParseApplyError(error, op.path, opIndex);
 	}
 	if (op.op === "test") return {
 		ok: true,
-		baseJson,
-		headJson
+		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(baseDoc.root, parentPath);
+	if (!resolvedParent.ok) return {
+		ok: false,
+		...resolvedParent.error,
+		path: parentPointer,
+		opIndex
+	};
+	const parentNode = resolvedParent.node;
+	if (parentNode.kind === "seq") {
+		const parsedIndex = parseArrayIndexTokenForDoc(key, op.op, op.path, opIndex);
+		if (!parsedIndex.ok) return parsedIndex;
+		const boundedIndex = validateArrayIndexBounds(parsedIndex.index, op.op, rgaLength(parentNode), op.path, opIndex);
+		if (!boundedIndex.ok) return boundedIndex;
+		if (op.op === "add") return {
+			ok: true,
+			intents: [{
+				t: "ArrInsert",
+				path: parentPath,
+				index: boundedIndex.index,
+				value: op.value
+			}]
+		};
+		if (op.op === "remove") return {
+			ok: true,
+			intents: [{
+				t: "ArrDelete",
+				path: parentPath,
+				index: boundedIndex.index
+			}]
+		};
+		return {
+			ok: true,
+			intents: [{
+				t: "ArrReplace",
+				path: parentPath,
+				index: boundedIndex.index,
+				value: op.value
+			}]
+		};
+	}
+	if (parentNode.kind !== "obj") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_TARGET",
+		message: `expected object or array parent at ${parentPointer}`,
+		path: parentPointer,
+		opIndex
+	};
+	if (key === "__proto__") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_POINTER",
+		message: `unsafe object key at ${op.path}`,
+		path: op.path,
+		opIndex
+	};
+	const entry = parentNode.entries.get(key);
+	if ((op.op === "replace" || op.op === "remove") && !entry) return {
+		ok: false,
+		code: 409,
+		reason: "MISSING_TARGET",
+		message: `missing key ${key} at ${parentPointer}`,
+		path: op.path,
+		opIndex
+	};
+	if (op.op === "remove") return {
+		ok: true,
+		intents: [{
+			t: "ObjRemove",
+			path: parentPath,
+			key
+		}]
+	};
+	return {
+		ok: true,
+		intents: [{
+			t: "ObjSet",
+			path: parentPath,
+			key,
+			value: op.value,
+			mode: op.op
+		}]
+	};
+}
+function parsePointerWithCache(pointer, pointerCache) {
+	const cachedPath = pointerCache.get(pointer);
+	if (cachedPath !== void 0) return cachedPath.slice();
+	const parsedPath = parseJsonPointer(pointer);
+	pointerCache.set(pointer, parsedPath);
+	return parsedPath.slice();
+}
+function resolveNodeAtPath(root, path) {
+	let current = root;
+	for (const segment of path) {
+		if (current.kind === "obj") {
+			const entry = current.entries.get(segment);
+			if (!entry) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "MISSING_PARENT",
+					message: `Missing key '${segment}'`
+				}
+			};
+			current = entry.node;
+			continue;
+		}
+		if (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,
+		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,
+			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 nextBaseJson = applyJsonPatchOpToShadow(baseJson, op, explicitBaseState ? session.baseShadowParentCache : session.headShadowParentCache, {
-		pointerCache: session.pointerCache,
+	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,
-		baseJson: nextBaseJson,
-		headJson: explicitBaseState ? applyJsonPatchOpToShadow(headJson, op, session.headShadowParentCache, {
-			pointerCache: session.pointerCache,
-			opIndex
-		}) : nextBaseJson
+		index
 	};
 }
-function applySinglePatchOpExplicitShadowStep(explicitBaseState, baseJson, op, options, opIndex, session) {
-	const compiled = compilePreparedIntents(baseJson, [op], "base", session.pointerCache, opIndex);
-	if (!compiled.ok) return compiled;
-	const shadowStep = applyIntentsToCrdt(explicitBaseState.doc, explicitBaseState.doc, compiled.intents, () => explicitBaseState.clock.next(), "base", (ctr) => bumpClockCounter(explicitBaseState, ctr), { strictParents: options.strictParents });
-	if (!shadowStep.ok) return shadowStep;
-	if (op.op === "test") return {
-		ok: true,
-		baseJson
+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,
-		baseJson: applyJsonPatchOpToShadow(baseJson, op, session.baseShadowParentCache, {
-			pointerCache: session.pointerCache,
-			opIndex
-		})
+		index
 	};
 }
-function applyJsonPatchOpToShadow(baseJson, op, parentCache, pointerContext) {
-	let path;
-	try {
-		path = parsePointerWithCache(op.path, pointerContext.pointerCache);
-	} catch (error) {
-		throw toPointerParseCompileError(error, op.path, pointerContext.opIndex);
-	}
-	if (path.length === 0) {
-		parentCache.clear();
-		if (op.op === "test") return baseJson;
-		if (op.op === "remove") return null;
-		return structuredClone(op.value);
-	}
-	const pathPointer = op.path;
-	const parentPath = path.slice(0, -1);
-	const parentPointer = pointerParent(pathPointer);
-	const key = path[path.length - 1];
-	const parent = 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 pointerPrefix = `${parentPointer}/`;
-	for (const cachedPointer of parentCache.keys()) if (cachedPointer.startsWith(pointerPrefix)) parentCache.delete(cachedPointer);
-}
-function pointerParent(pointer) {
-	if (pointer === "") return "";
-	const lastSlash = pointer.lastIndexOf("/");
-	if (lastSlash <= 0) return "";
-	return pointer.slice(0, lastSlash);
-}
-function parsePointerWithCache(pointer, pointerCache) {
-	const cachedPath = pointerCache.get(pointer);
-	if (cachedPath !== void 0) return cachedPath.slice();
-	const parsedPath = parseJsonPointer(pointer);
-	pointerCache.set(pointer, parsedPath);
-	return parsedPath.slice();
-}
-function resolveValueAtPointer(baseJson, pointer, opIndex, pointerCache) {
-	let path;
-	try {
-		path = parsePointerWithCache(pointer, pointerCache);
-	} catch (error) {
-		return toPointerParseApplyError(error, pointer, opIndex);
-	}
-	try {
-		return {
-			ok: true,
-			value: getAtJson(baseJson, path)
-		};
-	} catch (error) {
-		return toPointerLookupApplyError(error, pointer, opIndex);
-	}
-}
 function bumpClockCounter(state, ctr) {
 	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
 }
@@ -3126,40 +3998,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 {
@@ -3177,26 +4015,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
 	};
@@ -3205,6 +4036,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);
 }
@@ -3229,13 +4062,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) {
@@ -3256,6 +4092,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,
@@ -3263,16 +4100,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))
@@ -3346,6 +4188,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);
@@ -3433,28 +4285,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 {
@@ -3552,20 +4395,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 {
@@ -3591,7 +4437,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.
@@ -3603,17 +4449,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 = [{
@@ -3634,7 +4514,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") {
@@ -3656,14 +4536,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
@@ -3671,158 +4566,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) {
@@ -3830,38 +4755,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
@@ -3943,4 +4894,4 @@ function compactStateTombstones(state, options) {
 }
 
 //#endregion
-export { HEAD as $, crdtToJsonPatch as A, jsonEquals as B, tryApplyPatchAsActor as C, cloneDoc as D, applyIntentsToCrdt as E, tryJsonPatchToCrdt as F, lwwSet as G, stringifyJsonPointer as H, PatchCompileError as I, newSeq as J, newObj as K, compileJsonPatchToIntent as L, docFromJsonWithDot as M, jsonPatchToCrdt as N, crdtNodesToJsonPatch as O, jsonPatchToCrdtSafe as P, materialize as Q, diffJsonPatch as R, tryApplyPatch as S, validateJsonPatch as T, ROOT_KEY as U, parseJsonPointer as V, JsonValueValidationError as W, objRemove as X, objCompactTombstones as Y, objSet as Z, applyPatchAsActor as _, nextDotForActor as _t, mergeState as a, rgaLinearizeIds as at, forkState as b, DeserializeError as c, compareDot as ct, serializeDoc as d, vvMerge as dt, rgaCompactTombstones as et, serializeState as f, MAX_TRAVERSAL_DEPTH as ft, applyPatch as g, createClock as gt, PatchError as h, cloneClock as ht, mergeDoc as i, rgaInsertAfterChecked as it, docFromJson as j, crdtToFullReplace as k, deserializeDoc as l, dotToElemId as lt, tryDeserializeState as m, ClockValidationError as mt, compactStateTombstones as n, rgaIdAtIndex as nt, tryMergeDoc as o, rgaPrevForInsertAtIndex as ot, tryDeserializeDoc as p, TraversalDepthError as pt, newReg as q, MergeError as r, rgaInsertAfter as rt, tryMergeState as s, validateRgaSeq as st, compactDocTombstones as t, rgaDelete as tt, deserializeState as u, vvHasDot as ut, applyPatchInPlace as v, observeDot as vt, tryApplyPatchInPlace as w, toJson as x, createState as y, getAtJson as z };
+export { materialize as $, crdtToJsonPatch as A, jsonEquals as B, tryApplyPatchAsActor as C, TraversalDepthError as Ct, cloneDoc as D, applyIntentsToCrdt as E, tryJsonPatchToCrdt as F, JsonValueValidationError as G, stableJsonValueKey as H, PatchCompileError as I, newReg as J, lwwSet as K, compileJsonPatchToIntent as L, docFromJsonWithDot as M, jsonPatchToCrdt as N, crdtNodesToJsonPatch as O, jsonPatchToCrdtSafe as P, objSet as Q, diffJsonPatch as R, tryApplyPatch as S, MAX_TRAVERSAL_DEPTH as St, validateJsonPatch as T, stringifyJsonPointer as U, parseJsonPointer as V, ROOT_KEY as W, objCompactTombstones as X, newSeq as Y, objRemove as Z, applyPatchAsActor as _, observeDot as _t, mergeState as a, rgaInsertAfterChecked as at, forkState as b, observedVersionVector as bt, DeserializeError as c, validateRgaSeq as ct, serializeDoc as d, vvHasDot as dt, HEAD as et, serializeState as f, vvMerge as ft, applyPatch as g, nextDotForActor as gt, PatchError as h, createClock as ht, mergeDoc as i, rgaInsertAfter as it, docFromJson as j, crdtToFullReplace as k, deserializeDoc as l, compareDot as lt, tryDeserializeState as m, cloneClock as mt, compactStateTombstones as n, rgaDelete as nt, tryMergeDoc as o, rgaLinearizeIds as ot, tryDeserializeDoc as p, ClockValidationError as pt, newObj as q, MergeError as r, rgaIdAtIndex as rt, tryMergeState as s, rgaPrevForInsertAtIndex as st, compactDocTombstones as t, rgaCompactTombstones as tt, deserializeState as u, dotToElemId as ut, applyPatchInPlace as v, intersectVersionVectors as vt, tryApplyPatchInPlace as w, toJson as x, versionVectorCovers as xt, createState as y, mergeVersionVectors as yt, getAtJson as z };