json-patch-to-crdt 0.3.0 → 0.4.0

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

@@ -1,18 +1,37 @@
-//#region src/clock.ts
-var ClockValidationError = class extends TypeError {
-	reason;
-	constructor(reason, message) {
-		super(message);
-		this.name = "ClockValidationError";
-		this.reason = reason;
+//#region src/depth.ts
+const MAX_TRAVERSAL_DEPTH = 16384;
+var TraversalDepthError = class extends Error {
+	code = 409;
+	reason = "MAX_DEPTH_EXCEEDED";
+	depth;
+	maxDepth;
+	constructor(depth, maxDepth = MAX_TRAVERSAL_DEPTH) {
+		super(`maximum nesting depth ${maxDepth} exceeded at depth ${depth}`);
+		this.name = "TraversalDepthError";
+		this.depth = depth;
+		this.maxDepth = maxDepth;
 	}
 };
-function readVvCounter$1(vv, actor) {
-	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return 0;
+function assertTraversalDepth(depth, maxDepth = MAX_TRAVERSAL_DEPTH) {
+	if (depth > maxDepth) throw new TraversalDepthError(depth, maxDepth);
+}
+function toDepthApplyError(error) {
+	return {
+		ok: false,
+		code: error.code,
+		reason: error.reason,
+		message: error.message
+	};
+}
+
+//#endregion
+//#region src/version-vector.ts
+function readVersionVectorCounter(vv, actor) {
+	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return;
 	const counter = vv[actor];
-	return typeof counter === "number" ? counter : 0;
+	return typeof counter === "number" ? counter : void 0;
 }
-function writeVvCounter$1(vv, actor, counter) {
+function writeVersionVectorCounter(vv, actor, counter) {
 	Object.defineProperty(vv, actor, {
 		configurable: true,
 		enumerable: true,
@@ -20,6 +39,104 @@ function writeVvCounter$1(vv, actor, counter) {
 		writable: true
 	});
 }
+function observeVersionVectorDot(vv, dot) {
+	if ((readVersionVectorCounter(vv, dot.actor) ?? 0) < dot.ctr) writeVersionVectorCounter(vv, dot.actor, dot.ctr);
+}
+/**
+* Inspect a document or state and return the highest observed counter per actor.
+*
+* When a `CrdtState` is provided, the returned vector is also seeded from the
+* state's local clock so callers do not lose counters that have advanced ahead
+* of the currently materialized document tree.
+*/
+function observedVersionVector(target) {
+	const doc = "doc" in target ? target.doc : target;
+	const vv = Object.create(null);
+	if ("clock" in target) observeVersionVectorDot(vv, {
+		actor: target.clock.actor,
+		ctr: target.clock.ctr
+	});
+	const stack = [{
+		node: doc.root,
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (frame.node.kind === "lww") {
+			observeVersionVectorDot(vv, frame.node.dot);
+			continue;
+		}
+		if (frame.node.kind === "obj") {
+			for (const entry of frame.node.entries.values()) {
+				observeVersionVectorDot(vv, entry.dot);
+				stack.push({
+					node: entry.node,
+					depth: frame.depth + 1
+				});
+			}
+			for (const tombstone of frame.node.tombstone.values()) observeVersionVectorDot(vv, tombstone);
+			continue;
+		}
+		for (const elem of frame.node.elems.values()) {
+			observeVersionVectorDot(vv, elem.insDot);
+			if (elem.delDot) observeVersionVectorDot(vv, elem.delDot);
+			stack.push({
+				node: elem.value,
+				depth: frame.depth + 1
+			});
+		}
+	}
+	return vv;
+}
+/** Combine version vectors using per-actor maxima. */
+function mergeVersionVectors(...vectors) {
+	const merged = Object.create(null);
+	for (const vv of vectors) for (const actor of Object.keys(vv)) {
+		const counter = readVersionVectorCounter(vv, actor);
+		if (counter === void 0) continue;
+		writeVersionVectorCounter(merged, actor, Math.max(readVersionVectorCounter(merged, actor) ?? 0, counter));
+	}
+	return merged;
+}
+/**
+* Derive a causally-stable checkpoint by taking the per-actor minimum.
+*
+* When called with a single vector the result equals that vector. In practice,
+* a meaningful shared-stability checkpoint usually needs acknowledgements from
+* at least two peers or from an explicit quorum.
+*/
+function intersectVersionVectors(...vectors) {
+	if (vectors.length === 0) return Object.create(null);
+	const actors = /* @__PURE__ */ new Set();
+	for (const vv of vectors) for (const actor of Object.keys(vv)) actors.add(actor);
+	const intersection = Object.create(null);
+	for (const actor of actors) {
+		const counters = vectors.map((vv) => readVersionVectorCounter(vv, actor) ?? 0);
+		const counter = Math.min(...counters);
+		if (counter > 0) writeVersionVectorCounter(intersection, actor, counter);
+	}
+	return intersection;
+}
+/** Check whether one version vector has observed every counter in another. */
+function versionVectorCovers(observed, required) {
+	for (const actor of Object.keys(required)) {
+		const requiredCounter = readVersionVectorCounter(required, actor) ?? 0;
+		if ((readVersionVectorCounter(observed, actor) ?? 0) < requiredCounter) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/clock.ts
+var ClockValidationError = class extends TypeError {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.name = "ClockValidationError";
+		this.reason = reason;
+	}
+};
 /**
 * Create a new clock for the given actor. Each call to `clock.next()` yields a fresh `Dot`.
 * @param actor - Unique identifier for this peer.
@@ -56,8 +173,8 @@ function cloneClock(clock) {
 * Useful when a server needs to mint dots for many actors.
 */
 function nextDotForActor(vv, actor) {
-	const ctr = readVvCounter$1(vv, actor) + 1;
-	writeVvCounter$1(vv, actor, ctr);
+	const ctr = (readVersionVectorCounter(vv, actor) ?? 0) + 1;
+	writeVersionVectorCounter(vv, actor, ctr);
 	return {
 		actor,
 		ctr
@@ -65,63 +182,20 @@ function nextDotForActor(vv, actor) {
 }
 /** Record an observed dot in a version vector. */
 function observeDot(vv, dot) {
-	if (readVvCounter$1(vv, dot.actor) < dot.ctr) writeVvCounter$1(vv, dot.actor, dot.ctr);
-}
-
-//#endregion
-//#region src/depth.ts
-const MAX_TRAVERSAL_DEPTH = 16384;
-var TraversalDepthError = class extends Error {
-	code = 409;
-	reason = "MAX_DEPTH_EXCEEDED";
-	depth;
-	maxDepth;
-	constructor(depth, maxDepth = MAX_TRAVERSAL_DEPTH) {
-		super(`maximum nesting depth ${maxDepth} exceeded at depth ${depth}`);
-		this.name = "TraversalDepthError";
-		this.depth = depth;
-		this.maxDepth = maxDepth;
-	}
-};
-function assertTraversalDepth(depth, maxDepth = MAX_TRAVERSAL_DEPTH) {
-	if (depth > maxDepth) throw new TraversalDepthError(depth, maxDepth);
-}
-function toDepthApplyError(error) {
-	return {
-		ok: false,
-		code: error.code,
-		reason: error.reason,
-		message: error.message
-	};
+	observeVersionVectorDot(vv, dot);
 }
 
 //#endregion
 //#region src/dot.ts
-function readVvCounter(vv, actor) {
-	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return;
-	const counter = vv[actor];
-	return typeof counter === "number" ? counter : void 0;
-}
-function writeVvCounter(vv, actor, counter) {
-	Object.defineProperty(vv, actor, {
-		configurable: true,
-		enumerable: true,
-		value: counter,
-		writable: true
-	});
-}
 function compareDot(a, b) {
 	if (a.ctr !== b.ctr) return a.ctr - b.ctr;
 	return a.actor < b.actor ? -1 : a.actor > b.actor ? 1 : 0;
 }
 function vvHasDot(vv, d) {
-	return (readVvCounter(vv, d.actor) ?? 0) >= d.ctr;
+	return (readVersionVectorCounter(vv, d.actor) ?? 0) >= d.ctr;
 }
 function vvMerge(a, b) {
-	const out = Object.create(null);
-	for (const [actor, ctr] of Object.entries(a)) writeVvCounter(out, actor, ctr);
-	for (const [actor, ctr] of Object.entries(b)) writeVvCounter(out, actor, Math.max(readVvCounter(out, actor) ?? 0, ctr));
-	return out;
+	return mergeVersionVectors(a, b);
 }
 function dotToElemId(d) {
 	return `${d.actor}:${d.ctr}`;
@@ -205,6 +279,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 +492,7 @@ function rgaPrevForInsertAtIndex(seq, index) {
 
 //#endregion
 //#region src/materialize.ts
+let materializeObserver = null;
 function createMaterializedObject() {
 	return Object.create(null);
 }
@@ -425,6 +506,8 @@ function setMaterializedProperty(out, key, value) {
 }
 /** Convert a CRDT node graph into a plain JSON value using an explicit stack. */
 function materialize(node) {
+	const observer = materializeObserver;
+	observer?.([], node);
 	if (node.kind === "lww") return node.value;
 	const root = node.kind === "obj" ? createMaterializedObject() : [];
 	const stack = [];
@@ -432,13 +515,16 @@ function materialize(node) {
 		kind: "obj",
 		depth: 0,
 		entries: node.entries.entries(),
-		out: root
+		out: root,
+		path: []
 	});
 	else stack.push({
 		kind: "seq",
 		depth: 0,
 		cursor: rgaCreateLinearCursor(node),
-		out: root
+		out: root,
+		path: [],
+		nextIndex: 0
 	});
 	while (stack.length > 0) {
 		const frame = stack[stack.length - 1];
@@ -452,6 +538,8 @@ function materialize(node) {
 			const child = entry.node;
 			const childDepth = frame.depth + 1;
 			assertTraversalDepth(childDepth);
+			const childPath = [...frame.path, key];
+			observer?.(childPath, child);
 			if (child.kind === "lww") {
 				setMaterializedProperty(frame.out, key, child.value);
 				continue;
@@ -463,7 +551,8 @@ function materialize(node) {
 					kind: "obj",
 					depth: childDepth,
 					entries: child.entries.entries(),
-					out: outObj
+					out: outObj,
+					path: childPath
 				});
 				continue;
 			}
@@ -473,7 +562,9 @@ function materialize(node) {
 				kind: "seq",
 				depth: childDepth,
 				cursor: rgaCreateLinearCursor(child),
-				out: outArr
+				out: outArr,
+				path: childPath,
+				nextIndex: 0
 			});
 			continue;
 		}
@@ -485,6 +576,9 @@ function materialize(node) {
 		const child = elem.value;
 		const childDepth = frame.depth + 1;
 		assertTraversalDepth(childDepth);
+		const childPath = [...frame.path, String(frame.nextIndex)];
+		frame.nextIndex += 1;
+		observer?.(childPath, child);
 		if (child.kind === "lww") {
 			frame.out.push(child.value);
 			continue;
@@ -496,7 +590,8 @@ function materialize(node) {
 				kind: "obj",
 				depth: childDepth,
 				entries: child.entries.entries(),
-				out: outObj
+				out: outObj,
+				path: childPath
 			});
 			continue;
 		}
@@ -506,7 +601,9 @@ function materialize(node) {
 			kind: "seq",
 			depth: childDepth,
 			cursor: rgaCreateLinearCursor(child),
-			out: outArr
+			out: outArr,
+			path: childPath,
+			nextIndex: 0
 		});
 	}
 	return root;
@@ -617,6 +714,7 @@ function assertRuntimeJsonValue(value) {
 /**
 * Normalize a runtime value to JSON-compatible data.
 * - non-finite numbers -> null
+* - non-plain objects -> null at the root / in arrays, omitted from object properties
 * - invalid object-property values -> key omitted
 * - invalid root / array values -> null
 */
@@ -703,7 +801,10 @@ function isJsonPrimitive$1(value) {
 	return typeof value === "number" && Number.isFinite(value);
 }
 function isJsonObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || Object.getPrototypeOf(prototype) === null;
 }
 function isNonFiniteNumber(value) {
 	return typeof value === "number" && !Number.isFinite(value);
@@ -714,8 +815,16 @@ function describeInvalidValue(value) {
 	if (typeof value === "bigint") return "bigint is not valid JSON";
 	if (typeof value === "symbol") return "symbol is not valid JSON";
 	if (typeof value === "function") return "function is not valid JSON";
+	if (typeof value === "object" && value !== null) return `non-plain object (${describeObjectKind(value)}) is not valid JSON`;
 	return `unsupported value type (${typeof value})`;
 }
+function describeObjectKind(value) {
+	const tag = Object.prototype.toString.call(value).slice(8, -1);
+	if (tag !== "Object") return tag;
+	const constructor = value.constructor;
+	if (typeof constructor === "function" && constructor.name !== "" && constructor.name !== "Object") return constructor.name;
+	return "Object";
+}
 
 //#endregion
 //#region src/types.ts
@@ -846,8 +955,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 +973,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
+		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;
 	}
-	if (!isPlainObject(base) || !isPlainObject(next)) {
-		ops.push({
-			op: "replace",
-			path: stringifyJsonPointer(path),
-			value: next
-		});
-		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 +1096,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 +1123,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 +1139,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 +1158,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 +1172,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 +1181,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 +1193,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 +1230,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 +1431,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 +1485,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 +1524,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 +1612,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 +1682,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 +1745,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;
 }
@@ -2810,7 +3153,7 @@ function applyPatchAsActor(doc, vv, actor, patch, options = {}) {
 }
 /** Non-throwing `applyPatchAsActor` variant for internals sync flows. */
 function tryApplyPatchAsActor(doc, vv, actor, patch, options = {}) {
-	const observedCtr = maxCtrInNodeForActor$1(doc.root, actor);
+	const observedCtr = observedVersionVector(doc)[actor] ?? 0;
 	const applied = tryApplyPatch({
 		doc,
 		clock: createClock(actor, Math.max(vv[actor] ?? 0, observedCtr))
@@ -2852,18 +3195,10 @@ function applyPatchInternal(state, patch, options, execution) {
 			doc: cloneDoc(options.base.doc),
 			clock: createClock("__base__", 0)
 		} : null;
-		const session = {
-			pointerCache: /* @__PURE__ */ new Map(),
-			baseShadowParentCache: /* @__PURE__ */ new Map(),
-			headShadowParentCache: /* @__PURE__ */ new Map()
-		};
-		let sequentialHeadJson = materialize(state.doc.root);
-		let sequentialBaseJson = explicitBaseState ? materialize(explicitBaseState.doc.root) : sequentialHeadJson;
+		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 +3207,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,30 +3222,26 @@ 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;
@@ -2918,121 +3249,157 @@ function applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, op
 		const shadowStep = applyIntentsToCrdt(explicitBaseState.doc, explicitBaseState.doc, compiled.intents, () => explicitBaseState.clock.next(), "base", (ctr) => bumpClockCounter(explicitBaseState, ctr), { strictParents: options.strictParents });
 		if (!shadowStep.ok) return shadowStep;
 	}
-	if (op.op === "test") return {
-		ok: true,
-		baseJson,
-		headJson
-	};
-	const nextBaseJson = applyJsonPatchOpToShadow(baseJson, op, explicitBaseState ? session.baseShadowParentCache : session.headShadowParentCache, {
-		pointerCache: session.pointerCache,
-		opIndex
-	});
-	return {
-		ok: true,
-		baseJson: nextBaseJson,
-		headJson: explicitBaseState ? applyJsonPatchOpToShadow(headJson, op, session.headShadowParentCache, {
-			pointerCache: session.pointerCache,
-			opIndex
-		}) : nextBaseJson
-	};
+	return { ok: true };
 }
-function applySinglePatchOpExplicitShadowStep(explicitBaseState, baseJson, op, options, opIndex, session) {
-	const compiled = compilePreparedIntents(baseJson, [op], "base", session.pointerCache, opIndex);
+function applySinglePatchOpExplicitShadowStep(explicitBaseState, op, options, opIndex, session) {
+	const compiled = compilePreparedSingleIntentFromDoc(explicitBaseState.doc, op, session.pointerCache, opIndex);
 	if (!compiled.ok) return compiled;
 	const shadowStep = applyIntentsToCrdt(explicitBaseState.doc, explicitBaseState.doc, compiled.intents, () => explicitBaseState.clock.next(), "base", (ctr) => bumpClockCounter(explicitBaseState, ctr), { strictParents: options.strictParents });
 	if (!shadowStep.ok) return shadowStep;
-	if (op.op === "test") return {
-		ok: true,
-		baseJson
+	return { ok: true };
+}
+function resolveValueAtPointerInDoc(doc, pointer, opIndex, pointerCache) {
+	let path;
+	try {
+		path = parsePointerWithCache(pointer, pointerCache);
+	} catch (error) {
+		return toPointerParseApplyError(error, pointer, opIndex);
+	}
+	const resolved = resolveNodeAtPath(doc.root, path);
+	if (!resolved.ok) return {
+		ok: false,
+		...resolved.error,
+		path: pointer,
+		opIndex
 	};
 	return {
 		ok: true,
-		baseJson: applyJsonPatchOpToShadow(baseJson, op, session.baseShadowParentCache, {
-			pointerCache: session.pointerCache,
-			opIndex
-		})
+		value: materialize(resolved.node)
 	};
 }
-function applyJsonPatchOpToShadow(baseJson, op, parentCache, pointerContext) {
+function compilePreparedSingleIntentFromDoc(baseDoc, op, pointerCache, opIndex) {
 	let path;
 	try {
-		path = parsePointerWithCache(op.path, pointerContext.pointerCache);
+		path = parsePointerWithCache(op.path, pointerCache);
 	} catch (error) {
-		throw toPointerParseCompileError(error, op.path, pointerContext.opIndex);
+		return toPointerParseApplyError(error, op.path, opIndex);
 	}
+	if (op.op === "test") return {
+		ok: true,
+		intents: [{
+			t: "Test",
+			path,
+			value: op.value
+		}]
+	};
 	if (path.length === 0) {
-		parentCache.clear();
-		if (op.op === "test") return baseJson;
-		if (op.op === "remove") return null;
-		return structuredClone(op.value);
+		if (op.op === "remove") return {
+			ok: false,
+			code: 409,
+			reason: "INVALID_TARGET",
+			message: "remove at root path is not supported in RFC-compliant mode",
+			path: op.path,
+			opIndex
+		};
+		return {
+			ok: true,
+			intents: [{
+				t: "ObjSet",
+				path: [],
+				key: ROOT_KEY,
+				value: op.value
+			}]
+		};
 	}
-	const pathPointer = op.path;
 	const parentPath = path.slice(0, -1);
-	const parentPointer = pointerParent(pathPointer);
+	const parentPointer = stringifyJsonPointer(parentPath);
 	const key = path[path.length - 1];
-	const parent = resolveShadowParent(baseJson, parentPath, parentPointer, parentCache);
-	if (Array.isArray(parent)) {
-		const idx = key === "-" ? parent.length : Number(key);
-		if (!Number.isInteger(idx)) throw new Error(`Invalid array index ${key}`);
-		if (op.op === "add") {
-			parent.splice(idx, 0, structuredClone(op.value));
-			invalidateArrayShadowParentCache(parentCache, parentPointer);
-			return baseJson;
-		}
-		if (op.op === "remove") {
-			parent.splice(idx, 1);
-			invalidateArrayShadowParentCache(parentCache, parentPointer);
-			return baseJson;
-		}
-		if (op.op === "replace") {
-			parent[idx] = structuredClone(op.value);
-			invalidateShadowPointerCache(parentCache, pathPointer);
-			return baseJson;
-		}
-		return baseJson;
-	}
-	const obj = parent;
-	if (op.op === "add" || op.op === "replace") {
-		obj[key] = structuredClone(op.value);
-		invalidateShadowPointerCache(parentCache, pathPointer);
-		return baseJson;
-	}
-	if (op.op === "remove") {
-		delete obj[key];
-		invalidateShadowPointerCache(parentCache, pathPointer);
-		return baseJson;
-	}
-	return baseJson;
-}
-function resolveShadowParent(baseJson, parentPath, parentPointer, parentCache) {
-	const cachedParent = parentCache.get(parentPointer);
-	if (cachedParent !== void 0) return cachedParent;
-	const parentValue = parentPath.length === 0 ? baseJson : getAtJson(baseJson, parentPath);
-	if (!Array.isArray(parentValue) && !(parentValue && typeof parentValue === "object")) throw new Error(`Cannot mutate JSON shadow at non-container parent ${parentPointer || "<root>"}`);
-	parentCache.set(parentPointer, parentValue);
-	return parentValue;
-}
-function invalidateShadowPointerCache(parentCache, pointer) {
-	if (pointer === "") {
-		parentCache.clear();
-		return;
-	}
-	const pointerPrefix = `${pointer}/`;
-	for (const cachedPointer of parentCache.keys()) if (cachedPointer === pointer || cachedPointer.startsWith(pointerPrefix)) parentCache.delete(cachedPointer);
-}
-function invalidateArrayShadowParentCache(parentCache, parentPointer) {
-	if (parentPointer === "") {
-		for (const cachedPointer of parentCache.keys()) if (cachedPointer !== "") parentCache.delete(cachedPointer);
-		return;
+	const resolvedParent = parentPath.length === 0 ? {
+		ok: true,
+		node: baseDoc.root
+	} : resolveNodeAtPath(baseDoc.root, parentPath);
+	if (!resolvedParent.ok) return {
+		ok: false,
+		...resolvedParent.error,
+		path: parentPointer,
+		opIndex
+	};
+	const parentNode = resolvedParent.node;
+	if (parentNode.kind === "seq") {
+		const parsedIndex = parseArrayIndexTokenForDoc(key, op.op, op.path, opIndex);
+		if (!parsedIndex.ok) return parsedIndex;
+		const boundedIndex = validateArrayIndexBounds(parsedIndex.index, op.op, rgaLength(parentNode), op.path, opIndex);
+		if (!boundedIndex.ok) return boundedIndex;
+		if (op.op === "add") return {
+			ok: true,
+			intents: [{
+				t: "ArrInsert",
+				path: parentPath,
+				index: boundedIndex.index,
+				value: op.value
+			}]
+		};
+		if (op.op === "remove") return {
+			ok: true,
+			intents: [{
+				t: "ArrDelete",
+				path: parentPath,
+				index: boundedIndex.index
+			}]
+		};
+		return {
+			ok: true,
+			intents: [{
+				t: "ArrReplace",
+				path: parentPath,
+				index: boundedIndex.index,
+				value: op.value
+			}]
+		};
 	}
-	const pointerPrefix = `${parentPointer}/`;
-	for (const cachedPointer of parentCache.keys()) if (cachedPointer.startsWith(pointerPrefix)) parentCache.delete(cachedPointer);
-}
-function pointerParent(pointer) {
-	if (pointer === "") return "";
-	const lastSlash = pointer.lastIndexOf("/");
-	if (lastSlash <= 0) return "";
-	return pointer.slice(0, lastSlash);
+	if (parentNode.kind !== "obj") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_TARGET",
+		message: `expected object or array parent at ${parentPointer}`,
+		path: parentPointer,
+		opIndex
+	};
+	if (key === "__proto__") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_POINTER",
+		message: `unsafe object key at ${op.path}`,
+		path: op.path,
+		opIndex
+	};
+	const entry = parentNode.entries.get(key);
+	if ((op.op === "replace" || op.op === "remove") && !entry) return {
+		ok: false,
+		code: 409,
+		reason: "MISSING_TARGET",
+		message: `missing key ${key} at ${parentPointer}`,
+		path: op.path,
+		opIndex
+	};
+	if (op.op === "remove") return {
+		ok: true,
+		intents: [{
+			t: "ObjRemove",
+			path: parentPath,
+			key
+		}]
+	};
+	return {
+		ok: true,
+		intents: [{
+			t: "ObjSet",
+			path: parentPath,
+			key,
+			value: op.value,
+			mode: op.op
+		}]
+	};
 }
 function parsePointerWithCache(pointer, pointerCache) {
 	const cachedPath = pointerCache.get(pointer);
@@ -3041,21 +3408,129 @@ function parsePointerWithCache(pointer, pointerCache) {
 	pointerCache.set(pointer, parsedPath);
 	return parsedPath.slice();
 }
-function resolveValueAtPointer(baseJson, pointer, opIndex, pointerCache) {
-	let path;
-	try {
-		path = parsePointerWithCache(pointer, pointerCache);
-	} catch (error) {
-		return toPointerParseApplyError(error, pointer, opIndex);
+function resolveNodeAtPath(root, path) {
+	let current = root;
+	for (const segment of path) {
+		if (current.kind === "obj") {
+			const entry = current.entries.get(segment);
+			if (!entry) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "MISSING_PARENT",
+					message: `Missing key '${segment}'`
+				}
+			};
+			current = entry.node;
+			continue;
+		}
+		if (current.kind === "seq") {
+			if (!ARRAY_INDEX_TOKEN_PATTERN.test(segment)) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "INVALID_POINTER",
+					message: `Expected array index, got '${segment}'`
+				}
+			};
+			const index = Number(segment);
+			if (!Number.isSafeInteger(index)) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "OUT_OF_BOUNDS",
+					message: `Index out of bounds at '${segment}'`
+				}
+			};
+			const elemId = rgaIdAtIndex(current, index);
+			if (elemId === void 0) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "OUT_OF_BOUNDS",
+					message: `Index out of bounds at '${segment}'`
+				}
+			};
+			current = current.elems.get(elemId).value;
+			continue;
+		}
+		return {
+			ok: false,
+			error: {
+				code: 409,
+				reason: "INVALID_TARGET",
+				message: `Cannot traverse into non-container at '${segment}'`
+			}
+		};
 	}
-	try {
+	return {
+		ok: true,
+		node: current
+	};
+}
+function parseArrayIndexTokenForDoc(token, op, path, opIndex) {
+	if (token === "-") {
+		if (op !== "add") return {
+			ok: false,
+			code: 409,
+			reason: "INVALID_POINTER",
+			message: `'-' index is only valid for add at ${path}`,
+			path,
+			opIndex
+		};
 		return {
 			ok: true,
-			value: getAtJson(baseJson, path)
+			index: Number.POSITIVE_INFINITY
 		};
-	} catch (error) {
-		return toPointerLookupApplyError(error, pointer, opIndex);
 	}
+	if (!ARRAY_INDEX_TOKEN_PATTERN.test(token)) return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_POINTER",
+		message: `expected array index at ${path}`,
+		path,
+		opIndex
+	};
+	const index = Number(token);
+	if (!Number.isSafeInteger(index)) return {
+		ok: false,
+		code: 409,
+		reason: "OUT_OF_BOUNDS",
+		message: `array index is too large at ${path}`,
+		path,
+		opIndex
+	};
+	return {
+		ok: true,
+		index
+	};
+}
+function validateArrayIndexBounds(index, op, arrLength, path, opIndex) {
+	if (op === "add") {
+		if (index === Number.POSITIVE_INFINITY) return {
+			ok: true,
+			index
+		};
+		if (index > arrLength) return {
+			ok: false,
+			code: 409,
+			reason: "OUT_OF_BOUNDS",
+			message: `index out of bounds at ${path}; expected 0..${arrLength}`,
+			path,
+			opIndex
+		};
+	} else if (index >= arrLength) return {
+		ok: false,
+		code: 409,
+		reason: "OUT_OF_BOUNDS",
+		message: `index out of bounds at ${path}; expected 0..${Math.max(arrLength - 1, 0)}`,
+		path,
+		opIndex
+	};
+	return {
+		ok: true,
+		index
+	};
 }
 function bumpClockCounter(state, ctr) {
 	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
@@ -3126,40 +3601,6 @@ function mergePointerPaths(basePointer, nestedPointer) {
 	if (basePointer === "") return nestedPointer;
 	return `${basePointer}${nestedPointer}`;
 }
-function maxCtrInNodeForActor$1(node, actor) {
-	let best = 0;
-	const stack = [{
-		node,
-		depth: 0
-	}];
-	while (stack.length > 0) {
-		const frame = stack.pop();
-		assertTraversalDepth(frame.depth);
-		if (frame.node.kind === "lww") {
-			if (frame.node.dot.actor === actor && frame.node.dot.ctr > best) best = frame.node.dot.ctr;
-			continue;
-		}
-		if (frame.node.kind === "obj") {
-			for (const entry of frame.node.entries.values()) {
-				if (entry.dot.actor === actor && entry.dot.ctr > best) best = entry.dot.ctr;
-				stack.push({
-					node: entry.node,
-					depth: frame.depth + 1
-				});
-			}
-			for (const tomb of frame.node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
-			continue;
-		}
-		for (const elem of frame.node.elems.values()) {
-			if (elem.insDot.actor === actor && elem.insDot.ctr > best) best = elem.insDot.ctr;
-			stack.push({
-				node: elem.value,
-				depth: frame.depth + 1
-			});
-		}
-	}
-	return best;
-}
 function toApplyError(error) {
 	if (error instanceof TraversalDepthError) return toDepthApplyError(error);
 	if (error instanceof PatchCompileError) return {
@@ -3187,24 +3628,12 @@ function toPointerParseApplyError(error, pointer, opIndex) {
 		opIndex
 	};
 }
-function toPointerParseCompileError(error, pointer, opIndex) {
-	return new PatchCompileError("INVALID_POINTER", error instanceof Error ? error.message : "invalid pointer", pointer, opIndex);
-}
-function toPointerLookupApplyError(error, pointer, opIndex) {
-	const mapped = mapLookupErrorToPatchReason(error);
-	return {
-		ok: false,
-		code: 409,
-		reason: mapped.reason,
-		message: mapped.message,
-		path: pointer,
-		opIndex
-	};
-}
 
 //#endregion
 //#region src/serialize.ts
 const HEAD_ELEM_ID = "HEAD";
+const SERIALIZED_DOC_VERSION = 1;
+const SERIALIZED_STATE_VERSION = 1;
 function createSerializedRecord() {
 	return Object.create(null);
 }
@@ -3229,13 +3658,16 @@ var DeserializeError = class extends Error {
 };
 /** Serialize a CRDT document to a JSON-safe representation (Maps become plain objects). */
 function serializeDoc(doc) {
-	return { root: serializeNode(doc.root) };
+	return {
+		version: SERIALIZED_DOC_VERSION,
+		root: serializeNode(doc.root)
+	};
 }
 /** Reconstruct a CRDT document from its serialized form. */
 function deserializeDoc(data) {
-	if (!isRecord(data)) fail("INVALID_SERIALIZED_SHAPE", "/", "serialized doc must be an object");
-	if (!("root" in data)) fail("INVALID_SERIALIZED_SHAPE", "/root", "serialized doc is missing root");
-	return { root: deserializeNode(data.root, "/root", 0) };
+	const raw = readSerializedDocEnvelope(data);
+	if (!("root" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/root", "serialized doc is missing root");
+	return { root: deserializeNode(raw.root, "/root", 0) };
 }
 /** Non-throwing `deserializeDoc` variant with typed validation details. */
 function tryDeserializeDoc(data) {
@@ -3256,6 +3688,7 @@ function tryDeserializeDoc(data) {
 /** Serialize a full CRDT state (document + clock) to a JSON-safe representation. */
 function serializeState(state) {
 	return {
+		version: SERIALIZED_STATE_VERSION,
 		doc: serializeDoc(state.doc),
 		clock: {
 			actor: state.clock.actor,
@@ -3263,16 +3696,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 +3784,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 +3881,19 @@ function assertAcyclicRgaPredecessors(elems, path) {
 		for (const id of trail) visitState.set(id, 2);
 	}
 }
-function maxObservedCounterForActorInNode(node, actor) {
-	if (node.kind === "lww") return node.dot.actor === actor ? node.dot.ctr : 0;
-	if (node.kind === "obj") {
-		let maxCtr = 0;
-		for (const entry of node.entries.values()) {
-			if (entry.dot.actor === actor) maxCtr = Math.max(maxCtr, entry.dot.ctr);
-			maxCtr = Math.max(maxCtr, maxObservedCounterForActorInNode(entry.node, actor));
-		}
-		for (const tombstoneDot of node.tombstone.values()) if (tombstoneDot.actor === actor) maxCtr = Math.max(maxCtr, tombstoneDot.ctr);
-		return maxCtr;
-	}
-	let maxCtr = 0;
-	for (const elem of node.elems.values()) {
-		if (elem.insDot.actor === actor) maxCtr = Math.max(maxCtr, elem.insDot.ctr);
-		maxCtr = Math.max(maxCtr, maxObservedCounterForActorInNode(elem.value, actor));
-	}
-	return maxCtr;
-}
 function asRecord(value, path) {
 	if (!isRecord(value)) fail("INVALID_SERIALIZED_SHAPE", path, "expected object");
 	return value;
 }
+function assertSerializedEnvelopeVersion(raw, path, expectedVersion, label) {
+	if (!("version" in raw)) return;
+	const version = readVersion(raw.version, path);
+	if (version !== expectedVersion) fail("INVALID_SERIALIZED_SHAPE", path, `unsupported serialized ${label} version '${version}'`);
+}
+function readVersion(value, path) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) fail("INVALID_SERIALIZED_SHAPE", path, "envelope version must be a non-negative safe integer");
+	return value;
+}
 function readDot(value, path) {
 	const raw = asRecord(value, path);
 	return {
@@ -3553,7 +3992,7 @@ function mergeDoc(a, b, options = {}) {
 function tryMergeDoc(a, b, options = {}) {
 	try {
 		const mismatchPath = options.requireSharedOrigin ?? true ? findSeqLineageMismatch(a.root, b.root, []) : null;
-		if (mismatchPath) return {
+		if (mismatchPath !== null) return {
 			ok: false,
 			error: {
 				ok: false,
@@ -3634,7 +4073,7 @@ function findSeqLineageMismatch(a, b, path) {
 					shared = true;
 					break;
 				}
-				if (!shared) return `/${frame.path.join("/")}`;
+				if (!shared) return stringifyJsonPointer(frame.path);
 			}
 		}
 		if (frame.a.kind === "obj" && frame.b.kind === "obj") {
@@ -3657,45 +4096,11 @@ function findSeqLineageMismatch(a, b, path) {
 	return null;
 }
 function maxObservedCtrForActor(doc, actor, a, b) {
-	let best = maxCtrInNodeForActor(doc.root, actor);
+	let best = observedVersionVector(doc)[actor] ?? 0;
 	if (a.clock.actor === actor && a.clock.ctr > best) best = a.clock.ctr;
 	if (b.clock.actor === actor && b.clock.ctr > best) best = b.clock.ctr;
 	return best;
 }
-function maxCtrInNodeForActor(node, actor) {
-	let best = 0;
-	const stack = [{
-		node,
-		depth: 0
-	}];
-	while (stack.length > 0) {
-		const frame = stack.pop();
-		assertTraversalDepth(frame.depth);
-		if (frame.node.kind === "lww") {
-			if (frame.node.dot.actor === actor && frame.node.dot.ctr > best) best = frame.node.dot.ctr;
-			continue;
-		}
-		if (frame.node.kind === "obj") {
-			for (const entry of frame.node.entries.values()) {
-				if (entry.dot.actor === actor && entry.dot.ctr > best) best = entry.dot.ctr;
-				stack.push({
-					node: entry.node,
-					depth: frame.depth + 1
-				});
-			}
-			for (const tomb of frame.node.tombstone.values()) if (tomb.actor === actor && tomb.ctr > best) best = tomb.ctr;
-			continue;
-		}
-		for (const elem of frame.node.elems.values()) {
-			if (elem.insDot.actor === actor && elem.insDot.ctr > best) best = elem.insDot.ctr;
-			stack.push({
-				node: elem.value,
-				depth: frame.depth + 1
-			});
-		}
-	}
-	return best;
-}
 function repDot(node) {
 	switch (node.kind) {
 		case "lww": return node.dot;
@@ -3788,8 +4193,8 @@ function mergeSeq(a, b, depth, path) {
 		const ea = a.elems.get(id);
 		const eb = b.elems.get(id);
 		if (ea && eb) {
-			if (ea.prev !== eb.prev) throw new SharedElementMetadataMismatchError(toPointer(path), id, "prev");
-			if (!sameDot(ea.insDot, eb.insDot)) throw new SharedElementMetadataMismatchError(toPointer(path), id, "insDot");
+			if (ea.prev !== eb.prev) throw new SharedElementMetadataMismatchError(stringifyJsonPointer(path), id, "prev");
+			if (!sameDot(ea.insDot, eb.insDot)) throw new SharedElementMetadataMismatchError(stringifyJsonPointer(path), id, "insDot");
 			const mergedValue = mergeNodeAtDepth(ea.value, eb.value, depth + 1, [...path, id]);
 			elems.set(id, {
 				id,
@@ -3810,10 +4215,6 @@ function mergeSeq(a, b, depth, path) {
 function sameDot(a, b) {
 	return a.actor === b.actor && a.ctr === b.ctr;
 }
-function toPointer(path) {
-	if (path.length === 0) return "/";
-	return `/${path.join("/")}`;
-}
 function cloneElem(e, depth) {
 	assertTraversalDepth(depth);
 	return {
@@ -3943,4 +4344,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 };