json-patch-to-crdt 0.4.0 → 1.0.0

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

@@ -1,3 +1,129 @@
+//#region src/budget.ts
+function isNonNegativeSafeInteger(value) {
+	return Number.isSafeInteger(value) && value >= 0;
+}
+function formatPath(path) {
+	if (path === void 0 || path === "") return "";
+	return ` at ${path}`;
+}
+function formatOpIndex(opIndex) {
+	if (opIndex === void 0) return "";
+	return ` at op ${opIndex}`;
+}
+var ResourceBudgetError = class extends Error {
+	reason = "RESOURCE_BUDGET_EXCEEDED";
+	code = 409;
+	budget;
+	limit;
+	actual;
+	path;
+	opIndex;
+	constructor(budget, limit, actual, path, opIndex) {
+		super(`resource budget '${budget}' exceeded${formatPath(path)}${formatOpIndex(opIndex)}: ${actual} > ${limit}`);
+		this.name = "ResourceBudgetError";
+		this.budget = budget;
+		this.limit = limit;
+		this.actual = actual;
+		this.path = path;
+		this.opIndex = opIndex;
+	}
+};
+var ResourceBudgetMeter = class {
+	#budget;
+	#counts;
+	constructor(budget) {
+		this.#budget = validateBudget(budget);
+		this.#counts = {
+			patchOperations: 0,
+			objectEntries: 0,
+			sequenceElements: 0,
+			visitedNodes: 0,
+			serializedElements: 0,
+			arrayDiffCells: 0
+		};
+	}
+	count(kind, delta, path, opIndex) {
+		if (delta <= 0) return;
+		this.#counts[kind] += delta;
+		const limit = this.#budget[kind];
+		if (limit !== void 0 && this.#counts[kind] > limit) throw new ResourceBudgetError(kind, limit, this.#counts[kind], path, opIndex);
+	}
+};
+function createBudgetMeter(budget) {
+	if (budget === void 0) return;
+	return new ResourceBudgetMeter(budget);
+}
+function toBudgetApplyError(error) {
+	return {
+		ok: false,
+		code: error.code,
+		reason: error.reason,
+		message: error.message,
+		budget: error.budget,
+		limit: error.limit,
+		actual: error.actual,
+		path: error.path,
+		opIndex: error.opIndex
+	};
+}
+function toBudgetDeserializeFailure(error) {
+	return {
+		code: error.code,
+		reason: error.reason,
+		message: error.message,
+		budget: error.budget,
+		limit: error.limit,
+		actual: error.actual,
+		path: error.path
+	};
+}
+function validateBudget(budget) {
+	if (budget === void 0) return {};
+	const normalized = {};
+	const entries = Object.entries(budget);
+	for (const [key, value] of entries) {
+		if (value === void 0) continue;
+		if (!isNonNegativeSafeInteger(value)) throw new Error(`resource budget '${key}' must be a non-negative safe integer`);
+		normalized[key] = value;
+	}
+	return normalized;
+}
+
+//#endregion
+//#region src/cancellation.ts
+var OperationCancelledError = class extends Error {
+	reasonValue;
+	constructor(reason) {
+		super(toCancellationMessage(reason));
+		this.name = "OperationCancelledError";
+		this.reasonValue = reason;
+	}
+};
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new OperationCancelledError(signal.reason);
+}
+function toCancellationApplyError(error) {
+	return {
+		ok: false,
+		code: 409,
+		reason: "OPERATION_CANCELLED",
+		message: error.message
+	};
+}
+function toCancellationDeserializeFailure(error) {
+	return {
+		code: 409,
+		reason: "OPERATION_CANCELLED",
+		message: error.message
+	};
+}
+function toCancellationMessage(reason) {
+	if (reason instanceof Error && reason.message.length > 0) return `operation cancelled: ${reason.message}`;
+	if (typeof reason === "string" && reason.length > 0) return `operation cancelled: ${reason}`;
+	return "operation cancelled";
+}
+
+//#endregion
 //#region src/depth.ts
 const MAX_TRAVERSAL_DEPTH = 16384;
 var TraversalDepthError = class extends Error {
@@ -26,6 +152,8 @@ function toDepthApplyError(error) {
 
 //#endregion
 //#region src/version-vector.ts
+let observedVersionVectorObserverForTests = null;
+const observedVersionVectorCache = /* @__PURE__ */ new WeakMap();
 function readVersionVectorCounter(vv, actor) {
 	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return;
 	const counter = vv[actor];
@@ -42,6 +170,21 @@ function writeVersionVectorCounter(vv, actor, counter) {
 function observeVersionVectorDot(vv, dot) {
 	if ((readVersionVectorCounter(vv, dot.actor) ?? 0) < dot.ctr) writeVersionVectorCounter(vv, dot.actor, dot.ctr);
 }
+function cloneVersionVector(vv) {
+	return mergeVersionVectors(vv);
+}
+function readCachedObservedVersionVector(doc) {
+	const cached = observedVersionVectorCache.get(doc);
+	return cached ? cloneVersionVector(cached) : void 0;
+}
+function writeCachedObservedVersionVector(doc, vv) {
+	observedVersionVectorCache.set(doc, cloneVersionVector(vv));
+}
+function observeDocVersionVectorDot(doc, dot) {
+	const cached = observedVersionVectorCache.get(doc);
+	if (!cached) return;
+	observeVersionVectorDot(cached, dot);
+}
 /**
 * Inspect a document or state and return the highest observed counter per actor.
 *
@@ -51,11 +194,14 @@ function observeVersionVectorDot(vv, dot) {
 */
 function observedVersionVector(target) {
 	const doc = "doc" in target ? target.doc : target;
-	const vv = Object.create(null);
+	const cached = readCachedObservedVersionVector(doc);
+	const vv = cached ?? Object.create(null);
 	if ("clock" in target) observeVersionVectorDot(vv, {
 		actor: target.clock.actor,
 		ctr: target.clock.ctr
 	});
+	if (cached) return vv;
+	observedVersionVectorObserverForTests?.(target);
 	const stack = [{
 		node: doc.root,
 		depth: 0
@@ -87,6 +233,7 @@ function observedVersionVector(target) {
 			});
 		}
 	}
+	writeCachedObservedVersionVector(doc, vv);
 	return vv;
 }
 /** Combine version vectors using per-actor maxima. */
@@ -493,6 +640,7 @@ function rgaPrevForInsertAtIndex(seq, index) {
 //#endregion
 //#region src/materialize.ts
 let materializeObserver = null;
+const EMPTY_PATH = [];
 function createMaterializedObject() {
 	return Object.create(null);
 }
@@ -507,7 +655,7 @@ 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);
+	observer?.(EMPTY_PATH, node);
 	if (node.kind === "lww") return node.value;
 	const root = node.kind === "obj" ? createMaterializedObject() : [];
 	const stack = [];
@@ -538,7 +686,7 @@ function materialize(node) {
 			const child = entry.node;
 			const childDepth = frame.depth + 1;
 			assertTraversalDepth(childDepth);
-			const childPath = [...frame.path, key];
+			const childPath = observer ? [...frame.path, key] : EMPTY_PATH;
 			observer?.(childPath, child);
 			if (child.kind === "lww") {
 				setMaterializedProperty(frame.out, key, child.value);
@@ -576,7 +724,7 @@ function materialize(node) {
 		const child = elem.value;
 		const childDepth = frame.depth + 1;
 		assertTraversalDepth(childDepth);
-		const childPath = [...frame.path, String(frame.nextIndex)];
+		const childPath = observer ? [...frame.path, String(frame.nextIndex)] : EMPTY_PATH;
 		frame.nextIndex += 1;
 		observer?.(childPath, child);
 		if (child.kind === "lww") {
@@ -929,11 +1077,13 @@ function getAtJson(base, path) {
 */
 function compileJsonPatchToIntent(baseJson, patch, options = {}) {
 	const internalOptions = options;
+	const budgetMeter = internalOptions.budgetMeter ?? createBudgetMeter(options.resourceBudget);
 	const semantics = options.semantics ?? "sequential";
 	const opIndexOffset = internalOptions.opIndexOffset ?? 0;
 	let workingBase = baseJson;
 	const pointerCache = internalOptions.pointerCache ?? /* @__PURE__ */ new Map();
 	const intents = [];
+	budgetMeter?.count("patchOperations", patch.length);
 	for (let opIndex = 0; opIndex < patch.length; opIndex++) {
 		const op = patch[opIndex];
 		const absoluteOpIndex = opIndex + opIndexOffset;
@@ -948,14 +1098,16 @@ function compileJsonPatchOpToIntent(baseJson, op, options = {}) {
 	const internalOptions = options;
 	const semantics = options.semantics ?? "sequential";
 	const pointerCache = internalOptions.pointerCache ?? /* @__PURE__ */ new Map();
-	return compileSingleOp(baseJson, op, internalOptions.opIndexOffset ?? 0, semantics, pointerCache);
+	const opIndex = internalOptions.opIndexOffset ?? 0;
+	(internalOptions.budgetMeter ?? createBudgetMeter(options.resourceBudget))?.count("patchOperations", 1, void 0, opIndex);
+	return compileSingleOp(baseJson, op, opIndex, semantics, pointerCache);
 }
 /**
 * Compute a JSON Patch delta between two JSON values.
 * By default arrays use a deterministic LCS strategy.
 * Pass `{ arrayStrategy: "atomic" }` for single-op array replacement.
 * Pass `{ arrayStrategy: "lcs-linear" }` for a lower-memory LCS variant.
-* Use `lcsLinearMaxCells` to optionally cap worst-case `lcs-linear` work and
+* Use `lcsLinearMaxCells` to 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.
@@ -965,20 +1117,24 @@ function compileJsonPatchOpToIntent(baseJson, op, options = {}) {
 * @returns An array of JSON Patch operations that transform `base` into `next`.
 */
 function diffJsonPatch(base, next, options = {}) {
+	const budgetMeter = createBudgetMeter(options.resourceBudget);
 	const runtimeMode = options.jsonValidation ?? "none";
 	const runtimeBase = coerceRuntimeJsonValue(base, runtimeMode);
 	const runtimeNext = coerceRuntimeJsonValue(next, runtimeMode);
 	const ops = [];
-	diffValue([], runtimeBase, runtimeNext, ops, options);
+	const path = [];
+	throwIfAborted(options.signal);
+	diffValue(path, runtimeBase, runtimeNext, ops, options, budgetMeter);
 	return ops;
 }
-function diffValue(path, base, next, ops, options) {
+function diffValue(path, base, next, ops, options, budgetMeter) {
 	const stack = [{
 		kind: "value",
 		base,
 		next
 	}];
 	while (stack.length > 0) {
+		throwIfAborted(options.signal);
 		const frame = stack.pop();
 		if (frame.kind === "path-pop") {
 			path.pop();
@@ -1004,6 +1160,7 @@ function diffValue(path, base, next, ops, options) {
 			continue;
 		}
 		assertTraversalDepth(path.length);
+		budgetMeter?.count("visitedNodes", 1, stringifyJsonPointer(path));
 		if (frame.base === frame.next) continue;
 		const baseIsArray = Array.isArray(frame.base);
 		const nextIsArray = Array.isArray(frame.next);
@@ -1019,7 +1176,7 @@ function diffValue(path, base, next, ops, options) {
 			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({
+				if (!diffArrayWithLcsMatrix(path, frame.base, frame.next, ops, options, budgetMeter)) ops.push({
 					op: "replace",
 					path: stringifyJsonPointer(path),
 					value: frame.next
@@ -1027,7 +1184,7 @@ function diffValue(path, base, next, ops, options) {
 				continue;
 			}
 			if (arrayStrategy === "lcs-linear") {
-				if (!diffArrayWithLinearLcs(path, frame.base, frame.next, ops, options)) ops.push({
+				if (!diffArrayWithLinearLcs(path, frame.base, frame.next, ops, options, budgetMeter)) ops.push({
 					op: "replace",
 					path: stringifyJsonPointer(path),
 					value: frame.next
@@ -1052,6 +1209,7 @@ function diffValue(path, base, next, ops, options) {
 			continue;
 		}
 		const { sharedKeys, baseOnlyKeys, nextOnlyKeys } = collectObjectKeys(frame.base, frame.next);
+		budgetMeter?.count("objectEntries", sharedKeys.length + baseOnlyKeys.length + nextOnlyKeys.length, stringifyJsonPointer(path));
 		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({
@@ -1215,34 +1373,44 @@ function insertSortedKey(keys, key) {
 	}
 	keys.splice(low, 0, key);
 }
-function diffArrayWithLcsMatrix(path, base, next, ops, options) {
-	const window = trimEqualArrayEdges(base, next);
+function diffArrayWithLcsMatrix(path, base, next, ops, options, budgetMeter) {
+	const window = trimEqualArrayEdges(base, next, options);
 	const baseStart = window.baseStart;
 	const nextStart = window.nextStart;
 	const n = window.unmatchedBaseLength;
 	const m = window.unmatchedNextLength;
+	budgetMeter?.count("sequenceElements", n + m, stringifyJsonPointer(path));
 	if (!shouldUseLcsDiff(n, m, options.lcsMaxCells)) return false;
+	budgetMeter?.count("arrayDiffCells", (n + 1) * (m + 1), stringifyJsonPointer(path));
 	if (n === 0 && m === 0) return true;
 	const steps = [];
-	buildArrayEditScriptWithMatrix(base, baseStart, baseStart + n, next, nextStart, nextStart + m, steps);
+	buildArrayEditScriptWithMatrix(base, baseStart, baseStart + n, next, nextStart, nextStart + m, steps, options);
 	pushArrayPatchOps(path, window.prefixLength, steps, ops, base, options);
 	return true;
 }
-function diffArrayWithLinearLcs(path, base, next, ops, options) {
-	const window = trimEqualArrayEdges(base, next);
+function diffArrayWithLinearLcs(path, base, next, ops, options, budgetMeter) {
+	const window = trimEqualArrayEdges(base, next, options);
+	budgetMeter?.count("sequenceElements", window.unmatchedBaseLength + window.unmatchedNextLength, stringifyJsonPointer(path));
 	if (!shouldUseLinearLcsDiff(window.unmatchedBaseLength, window.unmatchedNextLength, options)) return false;
+	budgetMeter?.count("arrayDiffCells", (window.unmatchedBaseLength + 1) * (window.unmatchedNextLength + 1), stringifyJsonPointer(path));
 	const steps = [];
-	buildArrayEditScriptLinearSpace(base, window.baseStart, window.baseStart + window.unmatchedBaseLength, next, window.nextStart, window.nextStart + window.unmatchedNextLength, steps);
+	buildArrayEditScriptLinearSpace(base, window.baseStart, window.baseStart + window.unmatchedBaseLength, next, window.nextStart, window.nextStart + window.unmatchedNextLength, steps, options);
 	pushArrayPatchOps(path, window.prefixLength, steps, ops, base, options);
 	return true;
 }
-function trimEqualArrayEdges(base, next) {
+function trimEqualArrayEdges(base, next, options) {
 	const baseLength = base.length;
 	const nextLength = next.length;
 	let prefixLength = 0;
-	while (prefixLength < baseLength && prefixLength < nextLength && jsonEquals(base[prefixLength], next[prefixLength])) prefixLength += 1;
+	while (prefixLength < baseLength && prefixLength < nextLength && jsonEquals(base[prefixLength], next[prefixLength])) {
+		throwIfAborted(options.signal);
+		prefixLength += 1;
+	}
 	let suffixLength = 0;
-	while (suffixLength < baseLength - prefixLength && suffixLength < nextLength - prefixLength && jsonEquals(base[baseLength - 1 - suffixLength], next[nextLength - 1 - suffixLength])) suffixLength += 1;
+	while (suffixLength < baseLength - prefixLength && suffixLength < nextLength - prefixLength && jsonEquals(base[baseLength - 1 - suffixLength], next[nextLength - 1 - suffixLength])) {
+		throwIfAborted(options.signal);
+		suffixLength += 1;
+	}
 	return {
 		baseStart: prefixLength,
 		nextStart: prefixLength,
@@ -1251,7 +1419,8 @@ function trimEqualArrayEdges(base, next) {
 		unmatchedNextLength: nextLength - prefixLength - suffixLength
 	};
 }
-function buildArrayEditScriptLinearSpace(base, baseStart, baseEnd, next, nextStart, nextEnd, steps) {
+function buildArrayEditScriptLinearSpace(base, baseStart, baseEnd, next, nextStart, nextEnd, steps, options) {
+	throwIfAborted(options.signal);
 	const unmatchedBaseLength = baseEnd - baseStart;
 	const unmatchedNextLength = nextEnd - nextStart;
 	if (unmatchedBaseLength === 0) {
@@ -1266,20 +1435,20 @@ function buildArrayEditScriptLinearSpace(base, baseStart, baseEnd, next, nextSta
 		return;
 	}
 	if (unmatchedBaseLength === 1) {
-		pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps);
+		pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps, options);
 		return;
 	}
 	if (unmatchedNextLength === 1) {
-		pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps);
+		pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps, options);
 		return;
 	}
 	if (shouldUseMatrixBaseCase(unmatchedBaseLength, unmatchedNextLength)) {
-		buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps);
+		buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps, options);
 		return;
 	}
 	const baseMid = baseStart + Math.floor(unmatchedBaseLength / 2);
-	const forwardScores = computeLcsPrefixLengths(base, baseStart, baseMid, next, nextStart, nextEnd);
-	const reverseScores = computeLcsSuffixLengths(base, baseMid, baseEnd, next, nextStart, nextEnd);
+	const forwardScores = computeLcsPrefixLengths(base, baseStart, baseMid, next, nextStart, nextEnd, options);
+	const reverseScores = computeLcsSuffixLengths(base, baseMid, baseEnd, next, nextStart, nextEnd, options);
 	let bestOffset = 0;
 	let bestScore = Number.NEGATIVE_INFINITY;
 	for (let offset = 0; offset <= unmatchedNextLength; offset++) {
@@ -1290,11 +1459,11 @@ function buildArrayEditScriptLinearSpace(base, baseStart, baseEnd, next, nextSta
 		}
 	}
 	const nextMid = nextStart + bestOffset;
-	buildArrayEditScriptLinearSpace(base, baseStart, baseMid, next, nextStart, nextMid, steps);
-	buildArrayEditScriptLinearSpace(base, baseMid, baseEnd, next, nextMid, nextEnd, steps);
+	buildArrayEditScriptLinearSpace(base, baseStart, baseMid, next, nextStart, nextMid, steps, options);
+	buildArrayEditScriptLinearSpace(base, baseMid, baseEnd, next, nextMid, nextEnd, steps, options);
 }
-function pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps) {
-	const matchIndex = findFirstMatchingIndexInNext(base[baseStart], next, nextStart, nextEnd);
+function pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps, options) {
+	const matchIndex = findFirstMatchingIndexInNext(base[baseStart], next, nextStart, nextEnd, options);
 	if (matchIndex === -1) {
 		steps.push({ kind: "remove" });
 		for (let nextIndex = nextStart; nextIndex < nextEnd; nextIndex++) steps.push({
@@ -1313,8 +1482,8 @@ function pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, s
 		value: next[nextIndex]
 	});
 }
-function pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps) {
-	const matchIndex = findFirstMatchingIndexInBase(next[nextStart], base, baseStart, baseEnd);
+function pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps, options) {
+	const matchIndex = findFirstMatchingIndexInBase(next[nextStart], base, baseStart, baseEnd, options);
 	if (matchIndex === -1) {
 		for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) steps.push({ kind: "remove" });
 		steps.push({
@@ -1327,26 +1496,36 @@ function pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, s
 	steps.push({ kind: "equal" });
 	for (let baseIndex = matchIndex + 1; baseIndex < baseEnd; baseIndex++) steps.push({ kind: "remove" });
 }
-function findFirstMatchingIndexInNext(target, next, nextStart, nextEnd) {
-	for (let nextIndex = nextStart; nextIndex < nextEnd; nextIndex++) if (jsonEquals(target, next[nextIndex])) return nextIndex;
+function findFirstMatchingIndexInNext(target, next, nextStart, nextEnd, options) {
+	for (let nextIndex = nextStart; nextIndex < nextEnd; nextIndex++) {
+		throwIfAborted(options.signal);
+		if (jsonEquals(target, next[nextIndex])) return nextIndex;
+	}
 	return -1;
 }
-function findFirstMatchingIndexInBase(target, base, baseStart, baseEnd) {
-	for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) if (jsonEquals(target, base[baseIndex])) return baseIndex;
+function findFirstMatchingIndexInBase(target, base, baseStart, baseEnd, options) {
+	for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) {
+		throwIfAborted(options.signal);
+		if (jsonEquals(target, base[baseIndex])) return baseIndex;
+	}
 	return -1;
 }
 function shouldUseMatrixBaseCase(baseLength, nextLength) {
 	return (baseLength + 1) * (nextLength + 1) <= LINEAR_LCS_MATRIX_BASE_CASE_MAX_CELLS;
 }
-function buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps) {
+function buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps, options) {
 	const unmatchedBaseLength = baseEnd - baseStart;
 	const unmatchedNextLength = nextEnd - nextStart;
 	const lcs = Array.from({ length: unmatchedBaseLength + 1 }, () => Array(unmatchedNextLength + 1).fill(0));
-	for (let baseOffset = unmatchedBaseLength - 1; baseOffset >= 0; baseOffset--) for (let nextOffset = unmatchedNextLength - 1; nextOffset >= 0; nextOffset--) if (jsonEquals(base[baseStart + baseOffset], next[nextStart + nextOffset])) lcs[baseOffset][nextOffset] = 1 + lcs[baseOffset + 1][nextOffset + 1];
-	else lcs[baseOffset][nextOffset] = Math.max(lcs[baseOffset + 1][nextOffset], lcs[baseOffset][nextOffset + 1]);
+	for (let baseOffset = unmatchedBaseLength - 1; baseOffset >= 0; baseOffset--) {
+		throwIfAborted(options.signal);
+		for (let nextOffset = unmatchedNextLength - 1; nextOffset >= 0; nextOffset--) if (jsonEquals(base[baseStart + baseOffset], next[nextStart + nextOffset])) lcs[baseOffset][nextOffset] = 1 + lcs[baseOffset + 1][nextOffset + 1];
+		else lcs[baseOffset][nextOffset] = Math.max(lcs[baseOffset + 1][nextOffset], lcs[baseOffset][nextOffset + 1]);
+	}
 	let baseOffset = 0;
 	let nextOffset = 0;
 	while (baseOffset < unmatchedBaseLength || nextOffset < unmatchedNextLength) {
+		throwIfAborted(options.signal);
 		if (baseOffset < unmatchedBaseLength && nextOffset < unmatchedNextLength && jsonEquals(base[baseStart + baseOffset], next[nextStart + nextOffset])) {
 			steps.push({ kind: "equal" });
 			baseOffset += 1;
@@ -1369,11 +1548,12 @@ function buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStar
 		}
 	}
 }
-function computeLcsPrefixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd) {
+function computeLcsPrefixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd, options) {
 	const unmatchedNextLength = nextEnd - nextStart;
 	let previousRow = new Int32Array(unmatchedNextLength + 1);
 	let currentRow = new Int32Array(unmatchedNextLength + 1);
 	for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) {
+		throwIfAborted(options.signal);
 		for (let nextOffset = 0; nextOffset < unmatchedNextLength; nextOffset++) if (jsonEquals(base[baseIndex], next[nextStart + nextOffset])) currentRow[nextOffset + 1] = previousRow[nextOffset] + 1;
 		else currentRow[nextOffset + 1] = Math.max(previousRow[nextOffset + 1], currentRow[nextOffset]);
 		const nextPreviousRow = currentRow;
@@ -1383,11 +1563,12 @@ function computeLcsPrefixLengths(base, baseStart, baseEnd, next, nextStart, next
 	}
 	return previousRow;
 }
-function computeLcsSuffixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd) {
+function computeLcsSuffixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd, options) {
 	const unmatchedNextLength = nextEnd - nextStart;
 	let previousRow = new Int32Array(unmatchedNextLength + 1);
 	let currentRow = new Int32Array(unmatchedNextLength + 1);
 	for (let baseIndex = baseEnd - 1; baseIndex >= baseStart; baseIndex--) {
+		throwIfAborted(options.signal);
 		for (let nextOffset = unmatchedNextLength - 1; nextOffset >= 0; nextOffset--) if (jsonEquals(base[baseIndex], next[nextStart + nextOffset])) currentRow[nextOffset] = previousRow[nextOffset + 1] + 1;
 		else currentRow[nextOffset] = Math.max(previousRow[nextOffset], currentRow[nextOffset + 1]);
 		const nextPreviousRow = currentRow;
@@ -1433,9 +1614,10 @@ function shouldUseLcsDiff(baseLength, nextLength, lcsMaxCells) {
 }
 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;
+	if (cap === Number.POSITIVE_INFINITY) return true;
+	const effectiveCap = cap ?? DEFAULT_LCS_MAX_CELLS;
+	if (!Number.isFinite(effectiveCap) || effectiveCap < 1) return false;
+	return (baseLength + 1) * (nextLength + 1) <= effectiveCap;
 }
 function finalizeArrayOps(arrayPath, base, ops, options) {
 	if (ops.length === 0) return [];
@@ -2065,54 +2247,45 @@ function isSamePath(a, b) {
 * @returns A new CRDT `Doc`.
 */
 function docFromJson(value, nextDot) {
-	return { root: nodeFromJson(value, nextDot) };
+	const vv = Object.create(null);
+	const doc = { root: nodeFromJson(value, () => {
+		const dot = nextDot();
+		observeVersionVectorDot(vv, dot);
+		return dot;
+	}) };
+	writeCachedObservedVersionVector(doc, vv);
+	return doc;
 }
 /**
-* 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) {
@@ -2159,10 +2332,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;
 }
@@ -2314,7 +2501,10 @@ function nodeFromJson(value, nextDot) {
 }
 /** Deep-clone a CRDT document. The clone is fully independent of the original. */
 function cloneDoc(doc) {
-	return { root: cloneNode(doc.root) };
+	const cloned = { root: cloneNode(doc.root) };
+	const cached = readCachedObservedVersionVector(doc);
+	if (cached) writeCachedObservedVersionVector(cloned, cached);
+	return cloned;
 }
 function cloneNode(node) {
 	return cloneNodeAtDepth(node, 0);
@@ -2376,38 +2566,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",
@@ -2472,7 +2712,7 @@ function createArrayIndexLookupSession() {
 		return created;
 	} };
 }
-function applyArrInsert(base, head, it, newDot, indexSession, bumpCounterAbove, strictParents = false) {
+function applyArrInsert(base, head, it, newDot, indexSession, bumpCounterAbove, strictParents = true) {
 	const pointer = `/${it.path.join("/")}`;
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) {
@@ -2621,39 +2861,51 @@ function applyArrReplace(base, head, it, newDot, indexSession) {
 * @param evalTestAgainst - Whether `test` ops are evaluated against `"head"` or `"base"`.
 * @param bumpCounterAbove - Optional hook that can fast-forward the underlying counter before inserts.
 * @param options - Optional behavior toggles.
-* @param options.strictParents - When `true`, reject array inserts whose base parent path is missing.
+* @param options.strictParents - Reject array inserts whose base parent path is missing.
+*   Defaults to `true`; pass `false` only for legacy missing-parent array auto-creation.
 * @returns `{ ok: true }` on success, or `{ ok: false, code: 409, message }` on conflict.
 */
 function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head", bumpCounterAbove, options = {}) {
 	const arrayIndexSession = createArrayIndexLookupSession();
+	let pendingObservedDots = [];
+	const observedNewDot = () => {
+		const dot = newDot();
+		pendingObservedDots.push(dot);
+		return dot;
+	};
 	for (const it of intents) {
 		let fail = null;
+		pendingObservedDots = [];
 		switch (it.t) {
 			case "Test":
 				fail = applyTest(base, head, it, evalTestAgainst);
 				break;
 			case "ObjSet":
-				fail = applyObjSet(head, it, newDot);
+				fail = applyObjSet(head, it, observedNewDot);
 				break;
 			case "ObjRemove":
-				fail = applyObjRemove(head, it, newDot);
+				fail = applyObjRemove(head, it, observedNewDot);
 				break;
 			case "ArrInsert":
-				fail = applyArrInsert(base, head, it, newDot, arrayIndexSession, bumpCounterAbove, options.strictParents ?? false);
+				fail = applyArrInsert(base, head, it, observedNewDot, arrayIndexSession, bumpCounterAbove, options.strictParents ?? true);
 				break;
 			case "ArrDelete":
-				fail = applyArrDelete(base, head, it, newDot, arrayIndexSession);
+				fail = applyArrDelete(base, head, it, observedNewDot, arrayIndexSession);
 				break;
 			case "ArrReplace":
-				fail = applyArrReplace(base, head, it, newDot, arrayIndexSession);
+				fail = applyArrReplace(base, head, it, observedNewDot, arrayIndexSession);
 				break;
 			default: assertNever(it, "Unhandled intent type");
 		}
-		if (fail) return fail;
+		if (fail) {
+			pendingObservedDots = [];
+			return fail;
+		}
+		for (const dot of pendingObservedDots) observeDocVersionVectorDot(head, dot);
 	}
 	return { ok: true };
 }
-function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = false) {
+function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = true) {
 	if (isJsonPatchToCrdtOptions(baseOrOptions)) return jsonPatchToCrdtInternal(baseOrOptions);
 	if (!head || !patch || !newDot) return {
 		ok: false,
@@ -2671,7 +2923,7 @@ function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "
 		strictParents
 	});
 }
-function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = false) {
+function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = true) {
 	try {
 		if (isJsonPatchToCrdtOptions(baseOrOptions)) return jsonPatchToCrdt(baseOrOptions);
 		if (!head || !patch || !newDot) return {
@@ -2712,6 +2964,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;
@@ -2836,6 +3128,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;
@@ -2861,8 +3182,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.
@@ -2872,7 +3192,7 @@ function diffNodeToPatch(path, baseNode, headNode, options, ops, depth) {
 * @returns An array of JSON Patch operations that transform base into head.
 */
 function crdtToJsonPatch(base, head, options) {
-	if ((options?.jsonValidation ?? "none") !== "none") return diffJsonPatch(materialize(base.root), materialize(head.root), options);
+	if ((options?.jsonValidation ?? "none") !== "none" || options?.resourceBudget !== void 0) return diffJsonPatch(materialize(base.root), materialize(head.root), options);
 	return crdtNodesToJsonPatch(base.root, head.root, options);
 }
 /** Internals-only helper for diffing CRDT nodes from an existing traversal depth. */
@@ -2894,17 +3214,27 @@ function crdtToFullReplace(doc) {
 }
 function jsonPatchToCrdtInternal(options) {
 	const evalTestAgainst = options.evalTestAgainst ?? "head";
-	if ((options.semantics ?? "sequential") === "base") {
+	const semantics = options.semantics ?? "sequential";
+	const budgetMeter = createBudgetMeter(options.resourceBudget);
+	try {
+		budgetMeter?.count("patchOperations", options.patch.length);
+	} catch (error) {
+		return toApplyError$1(error);
+	}
+	if (semantics === "base") {
 		const baseJson = materialize(options.base.root);
 		let intents;
 		try {
-			intents = compileJsonPatchToIntent(baseJson, options.patch, { semantics: "base" });
+			intents = compileJsonPatchToIntent(baseJson, options.patch, {
+				semantics: "base",
+				resourceBudget: options.resourceBudget
+			});
 		} catch (error) {
 			return toApplyError$1(error);
 		}
 		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__",
@@ -2913,108 +3243,396 @@ 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
+		...resolved.error,
+		path: pointer,
+		opIndex
 	};
 	return {
-		ok: false,
-		code: 409,
-		reason: "INVALID_PATCH",
-		message: error instanceof Error ? error.message : "failed to compile/apply patch"
+		ok: true,
+		value: nodeToJsonForPatch(resolved.node)
 	};
 }
-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;
+function compilePreparedSingleIntentFromDoc$1(baseDoc, op, pointerCache, opIndex) {
+	const parsedPath = parsePointerWithCache$1(op.path, pointerCache, opIndex);
+	if (!parsedPath.ok) return parsedPath;
+	const path = parsedPath.path;
+	if (op.op === "test") return {
+		ok: true,
+		intents: [{
+			t: "Test",
+			path,
+			value: op.value
+		}]
+	};
+	if (path.length === 0) {
+		if (op.op === "remove") return {
+			ok: false,
+			code: 409,
+			reason: "INVALID_TARGET",
+			message: "remove at root path is not supported in RFC-compliant mode",
+			path: op.path,
+			opIndex
+		};
+		return {
+			ok: true,
+			intents: [{
+				t: "ObjSet",
+				path: [],
+				key: ROOT_KEY,
+				value: op.value
+			}]
+		};
+	}
+	const parentPath = path.slice(0, -1);
+	const parentPointer = stringifyJsonPointer(parentPath);
+	const key = path[path.length - 1];
+	const resolvedParent = parentPath.length === 0 ? {
+		ok: true,
+		node: baseDoc.root
+	} : resolveNodeAtPath$1(baseDoc.root, parentPath);
+	if (!resolvedParent.ok) return {
+		ok: false,
+		...resolvedParent.error,
+		path: parentPointer,
+		opIndex
+	};
+	const parentNode = resolvedParent.node;
+	if (parentNode.kind === "seq") {
+		const parsedIndex = parseArrayIndexTokenForDoc$1(key, op.op, op.path, opIndex);
+		if (!parsedIndex.ok) return parsedIndex;
+		const boundedIndex = validateArrayIndexBounds$1(parsedIndex.index, op.op, rgaLength(parentNode), op.path, opIndex);
+		if (!boundedIndex.ok) return boundedIndex;
+		if (op.op === "add") return {
+			ok: true,
+			intents: [{
+				t: "ArrInsert",
+				path: parentPath,
+				index: boundedIndex.index,
+				value: op.value
+			}]
+		};
+		if (op.op === "remove") return {
+			ok: true,
+			intents: [{
+				t: "ArrDelete",
+				path: parentPath,
+				index: boundedIndex.index
+			}]
+		};
+		return {
+			ok: true,
+			intents: [{
+				t: "ArrReplace",
+				path: parentPath,
+				index: boundedIndex.index,
+				value: op.value
+			}]
+		};
+	}
+	if (parentNode.kind !== "obj") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_TARGET",
+		message: `expected object or array parent at ${parentPointer}`,
+		path: parentPointer,
+		opIndex
+	};
+	if (key === "__proto__") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_POINTER",
+		message: `unsafe object key at ${op.path}`,
+		path: op.path,
+		opIndex
+	};
+	const entry = parentNode.entries.get(key);
+	if ((op.op === "replace" || op.op === "remove") && !entry) return {
+		ok: false,
+		code: 409,
+		reason: "MISSING_TARGET",
+		message: `missing key ${key} at ${parentPointer}`,
+		path: op.path,
+		opIndex
+	};
+	if (op.op === "remove") return {
+		ok: true,
+		intents: [{
+			t: "ObjRemove",
+			path: parentPath,
+			key
+		}]
+	};
+	return {
+		ok: true,
+		intents: [{
+			t: "ObjSet",
+			path: parentPath,
+			key,
+			value: op.value,
+			mode: op.op
+		}]
+	};
+}
+function parsePointerWithCache$1(pointer, pointerCache, opIndex) {
+	const cachedPath = pointerCache.get(pointer);
+	if (cachedPath !== void 0) return {
+		ok: true,
+		path: cachedPath.slice()
+	};
+	try {
+		const parsedPath = parseJsonPointer(pointer);
+		pointerCache.set(pointer, parsedPath);
+		return {
+			ok: true,
+			path: parsedPath.slice()
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			code: 409,
+			reason: "INVALID_POINTER",
+			message: error instanceof Error ? error.message : "invalid pointer",
+			path: pointer,
+			opIndex
+		};
+	}
+}
+function resolveNodeAtPath$1(root, path) {
+	let current = root;
+	for (const segment of path) {
+		if (current.kind === "obj") {
+			const entry = current.entries.get(segment);
+			if (!entry) return {
+				ok: false,
+				error: {
+					code: 409,
+					reason: "MISSING_PARENT",
+					message: `Missing key '${segment}'`
+				}
+			};
+			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;
+	budget;
+	limit;
+	actual;
+	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;
+		if (errorOrMessage.reason === "RESOURCE_BUDGET_EXCEEDED") {
+			this.budget = errorOrMessage.budget;
+			this.limit = errorOrMessage.limit;
+			this.actual = errorOrMessage.actual;
+		}
 		this.path = errorOrMessage.path;
 		this.opIndex = errorOrMessage.opIndex;
 	}
@@ -3079,26 +3697,27 @@ function applyPatchInPlace(state, patch, options = {}) {
 }
 /** Non-throwing immutable patch application variant. */
 function tryApplyPatch(state, patch, options = {}) {
-	const nextState = {
-		doc: cloneDoc(state.doc),
-		clock: cloneClock(state.clock)
-	};
 	try {
+		throwIfAborted(options.signal);
+		const nextState = {
+			doc: cloneDoc(state.doc),
+			clock: cloneClock(state.clock)
+		};
 		const result = applyPatchInternal(nextState, patch, options, "batch");
 		if (!result.ok) return {
 			ok: false,
 			error: result
 		};
+		return {
+			ok: true,
+			state: nextState
+		};
 	} 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 = {}) {
@@ -3129,10 +3748,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
@@ -3175,28 +3797,27 @@ function toApplyPatchOptionsForActor(options) {
 		testAgainst: options.testAgainst,
 		strictParents: options.strictParents,
 		jsonValidation: options.jsonValidation,
+		signal: options.signal,
 		base: options.base ? {
 			doc: options.base,
 			clock: createClock("__base__", 0)
 		} : void 0
 	};
 }
-function applyPatchInternal(state, patch, options, execution) {
+function applyPatchInternal(state, patch, options, _execution) {
+	throwIfAborted(options.signal);
 	const preparedPatch = preparePatchPayloadsSafe(patch, options.jsonValidation ?? "none");
 	if (!preparedPatch.ok) return preparedPatch;
+	createBudgetMeter(options.resourceBudget)?.count("patchOperations", preparedPatch.patch.length);
 	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() };
 		for (const [opIndex, op] of runtimePatch.entries()) {
+			throwIfAborted(options.signal);
 			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : state.doc, explicitBaseState, opIndex, session);
 			if (!step.ok) return step;
 		}
@@ -3244,10 +3865,10 @@ function applySinglePatchOpSequentialStep(state, baseDoc, op, options, explicitB
 	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 };
 }
@@ -3255,7 +3876,7 @@ function applySinglePatchOpExplicitShadowStep(explicitBaseState, op, options, op
 	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 (!shadowStep.ok) return withOpIndex(shadowStep, opIndex);
 	return { ok: true };
 }
 function resolveValueAtPointerInDoc(doc, pointer, opIndex, pointerCache) {
@@ -3535,9 +4156,9 @@ function validateArrayIndexBounds(index, op, arrLength, path, opIndex) {
 function bumpClockCounter(state, ctr) {
 	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
 }
-function compilePreparedIntents(baseJson, patch, semantics = "sequential", pointerCache, opIndexOffset = 0) {
+function compilePreparedIntents(baseJson, patch, semantics = "sequential", pointerCache, opIndexOffset = 0, budgetMeter) {
 	try {
-		const compileOptions = toCompilePatchOptions(semantics, pointerCache, opIndexOffset);
+		const compileOptions = toCompilePatchOptions(semantics, pointerCache, opIndexOffset, budgetMeter);
 		if (patch.length === 1) return {
 			ok: true,
 			intents: compileJsonPatchOpToIntent(baseJson, patch[0], compileOptions)
@@ -3550,11 +4171,13 @@ function compilePreparedIntents(baseJson, patch, semantics = "sequential", point
 		return toApplyError(error);
 	}
 }
-function toCompilePatchOptions(semantics, pointerCache, opIndexOffset = 0) {
+function toCompilePatchOptions(semantics, pointerCache, opIndexOffset = 0, budgetMeter) {
 	return {
 		semantics,
+		resourceBudget: void 0,
 		pointerCache,
-		opIndexOffset
+		opIndexOffset,
+		budgetMeter
 	};
 }
 function preparePatchPayloadsSafe(patch, mode) {
@@ -3602,6 +4225,8 @@ function mergePointerPaths(basePointer, nestedPointer) {
 	return `${basePointer}${nestedPointer}`;
 }
 function toApplyError(error) {
+	if (error instanceof OperationCancelledError) return toCancellationApplyError(error);
+	if (error instanceof ResourceBudgetError) return toBudgetApplyError(error);
 	if (error instanceof TraversalDepthError) return toDepthApplyError(error);
 	if (error instanceof PatchCompileError) return {
 		ok: false,
@@ -3618,6 +4243,13 @@ function toApplyError(error) {
 		message: error instanceof Error ? error.message : "failed to compile patch"
 	};
 }
+function withOpIndex(error, opIndex) {
+	if (error.opIndex !== void 0) return error;
+	return {
+		...error,
+		opIndex
+	};
+}
 function toPointerParseApplyError(error, pointer, opIndex) {
 	return {
 		ok: false,
@@ -3629,6 +4261,68 @@ function toPointerParseApplyError(error, pointer, opIndex) {
 	};
 }
 
+//#endregion
+//#region src/safe.ts
+/** Create a state with strict runtime JSON validation enabled by default. */
+function createSafeState(initial, options) {
+	return createState(initial, {
+		...options,
+		jsonValidation: "strict"
+	});
+}
+/** Apply a patch with strict runtime JSON validation enabled by default. */
+function applySafePatch(state, patch, options = {}) {
+	return applyPatch(state, patch, {
+		...options,
+		jsonValidation: "strict"
+	});
+}
+/** Diff JSON values with strict runtime JSON validation enabled by default. */
+function diffSafeJsonPatch(base, next, options = {}) {
+	return diffJsonPatch(base, next, {
+		...options,
+		jsonValidation: "strict"
+	});
+}
+/** Create a state with normalizing runtime JSON validation enabled by default. */
+function createNormalizedState(initial, options) {
+	return createState(initial, {
+		...options,
+		jsonValidation: "normalize"
+	});
+}
+/** Apply a patch with normalizing runtime JSON validation enabled by default. */
+function applyNormalizedPatch(state, patch, options = {}) {
+	return applyPatch(state, patch, {
+		...options,
+		jsonValidation: "normalize"
+	});
+}
+/** Diff JSON values with normalizing runtime JSON validation enabled by default. */
+function diffNormalizedJsonPatch(base, next, options = {}) {
+	return diffJsonPatch(base, next, {
+		...options,
+		jsonValidation: "normalize"
+	});
+}
+
+//#endregion
+//#region src/options.ts
+/** Options that reject legacy missing-parent array auto-creation. */
+const strictRfc6902PatchOptions = { strictParents: true };
+function withStrictRfc6902Parents(options) {
+	return {
+		...options,
+		strictParents: true
+	};
+}
+function withLegacyMissingArrayParents(options) {
+	return {
+		...options,
+		strictParents: false
+	};
+}
+
 //#endregion
 //#region src/serialize.ts
 const HEAD_ELEM_ID = "HEAD";
@@ -3664,18 +4358,39 @@ function serializeDoc(doc) {
 	};
 }
 /** Reconstruct a CRDT document from its serialized form. */
-function deserializeDoc(data) {
+function deserializeDoc(data, options = {}) {
+	return deserializeDocInternal(data, createBudgetMeter(options.resourceBudget), options.signal);
+}
+function deserializeDocInternal(data, budgetMeter, signal) {
+	throwIfAborted(signal);
 	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) };
+	const observed = Object.create(null);
+	const doc = { root: deserializeNode(raw.root, "/root", 0, budgetMeter, observed, signal) };
+	writeCachedObservedVersionVector(doc, observed);
+	return doc;
 }
 /** Non-throwing `deserializeDoc` variant with typed validation details. */
-function tryDeserializeDoc(data) {
+function tryDeserializeDoc(data, options = {}) {
 	try {
 		return {
 			ok: true,
-			doc: deserializeDoc(data)
+			doc: deserializeDoc(data, options)
+		};
+	} catch (error) {
+		const deserializeError = toDeserializeFailure(error);
+		if (deserializeError) return {
+			ok: false,
+			error: deserializeError
 		};
+		throw error;
+	}
+}
+/** Validate a serialized CRDT document without throwing or returning runtime state. */
+function validateSerializedDoc(data, options = {}) {
+	try {
+		validateSerializedDocInternal(data, createBudgetMeter(options.resourceBudget), options.signal);
+		return { ok: true };
 	} catch (error) {
 		const deserializeError = toDeserializeFailure(error);
 		if (deserializeError) return {
@@ -3702,27 +4417,56 @@ function serializeState(state) {
 * May throw `TraversalDepthError` when the payload exceeds the maximum
 * supported nesting depth.
 */
-function deserializeState(data) {
-	const raw = readSerializedStateEnvelope(data);
-	if (!("doc" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/doc", "serialized state is missing doc");
-	if (!("clock" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/clock", "serialized state is missing clock");
-	const clockRaw = asRecord(raw.clock, "/clock");
-	const actor = readActor(clockRaw.actor, "/clock/actor");
-	const ctr = readCounter(clockRaw.ctr, "/clock/ctr");
-	const doc = deserializeDoc(raw.doc);
-	const observedCtr = observedVersionVector(doc)[actor] ?? 0;
-	return {
-		doc,
-		clock: createClock(actor, Math.max(ctr, observedCtr))
-	};
+function deserializeState(data, options = {}) {
+	try {
+		const raw = readSerializedStateEnvelope(data);
+		const budgetMeter = createBudgetMeter(options.resourceBudget);
+		throwIfAborted(options.signal);
+		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 = deserializeDocInternal(raw.doc, budgetMeter, options.signal);
+		const observedCtr = readCachedObservedVersionVector(doc)?.[actor] ?? 0;
+		return {
+			doc,
+			clock: createClock(actor, Math.max(ctr, observedCtr))
+		};
+	} catch (error) {
+		if (error instanceof OperationCancelledError) throw new DeserializeError("OPERATION_CANCELLED", "/", error.message);
+		throw error;
+	}
 }
 /** Non-throwing `deserializeState` variant with typed validation details. */
-function tryDeserializeState(data) {
+function tryDeserializeState(data, options = {}) {
 	try {
 		return {
 			ok: true,
-			state: deserializeState(data)
+			state: deserializeState(data, options)
+		};
+	} catch (error) {
+		const deserializeError = toDeserializeFailure(error);
+		if (deserializeError) return {
+			ok: false,
+			error: deserializeError
 		};
+		throw error;
+	}
+}
+/** Validate a serialized CRDT state without throwing or returning runtime state. */
+function validateSerializedState(data, options = {}) {
+	try {
+		const raw = readSerializedStateEnvelope(data);
+		const budgetMeter = createBudgetMeter(options.resourceBudget);
+		throwIfAborted(options.signal);
+		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");
+		readActor(clockRaw.actor, "/clock/actor");
+		readCounter(clockRaw.ctr, "/clock/ctr");
+		validateSerializedDocInternal(raw.doc, budgetMeter, options.signal);
+		return { ok: true };
 	} catch (error) {
 		const deserializeError = toDeserializeFailure(error);
 		if (deserializeError) return {
@@ -3794,33 +4538,55 @@ function readSerializedStateEnvelope(data) {
 	assertSerializedEnvelopeVersion(raw, "/version", SERIALIZED_STATE_VERSION, "state");
 	return raw;
 }
-function deserializeNode(node, path, depth) {
+function validateSerializedDocInternal(data, budgetMeter, signal) {
+	throwIfAborted(signal);
+	const raw = readSerializedDocEnvelope(data);
+	if (!("root" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/root", "serialized doc is missing root");
+	validateSerializedNode(raw.root, "/root", 0, budgetMeter, signal);
+}
+function deserializeNode(node, path, depth, budgetMeter, observed, signal) {
+	throwIfAborted(signal);
 	assertTraversalDepth(depth);
+	budgetMeter?.count("visitedNodes", 1, path);
 	const raw = asRecord(node, path);
 	const kind = readString(raw.kind, `${path}/kind`);
 	if (kind === "lww") {
 		if (!("value" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/value`, "lww node is missing value");
 		if (!("dot" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/dot`, "lww node is missing dot");
+		const dot = readDot(raw.dot, `${path}/dot`);
+		if (observed) observeVersionVectorDot(observed, dot);
 		return {
 			kind: "lww",
-			value: structuredClone(readJsonValue(raw.value, `${path}/value`, depth + 1)),
-			dot: readDot(raw.dot, `${path}/dot`)
+			value: structuredClone(readJsonValue(raw.value, `${path}/value`, depth + 1, budgetMeter, signal)),
+			dot
 		};
 	}
 	if (kind === "obj") {
 		const entriesRaw = asRecord(raw.entries, `${path}/entries`);
 		const tombstoneRaw = asRecord(raw.tombstone, `${path}/tombstone`);
+		budgetMeter?.count("objectEntries", Object.keys(entriesRaw).length, `${path}/entries`);
+		budgetMeter?.count("serializedElements", Object.keys(entriesRaw).length, `${path}/entries`);
+		budgetMeter?.count("objectEntries", Object.keys(tombstoneRaw).length, `${path}/tombstone`);
+		budgetMeter?.count("serializedElements", Object.keys(tombstoneRaw).length, `${path}/tombstone`);
 		const entries = /* @__PURE__ */ new Map();
 		for (const [k, v] of Object.entries(entriesRaw)) {
+			throwIfAborted(signal);
 			const entryPath = `${path}/entries/${k}`;
 			const entryRaw = asRecord(v, entryPath);
+			const dot = readDot(entryRaw.dot, `${entryPath}/dot`);
+			if (observed) observeVersionVectorDot(observed, dot);
 			entries.set(k, {
-				node: deserializeNode(entryRaw.node, `${entryPath}/node`, depth + 1),
-				dot: readDot(entryRaw.dot, `${entryPath}/dot`)
+				node: deserializeNode(entryRaw.node, `${entryPath}/node`, depth + 1, budgetMeter, observed, signal),
+				dot
 			});
 		}
 		const tombstone = /* @__PURE__ */ new Map();
-		for (const [k, d] of Object.entries(tombstoneRaw)) tombstone.set(k, readDot(d, `${path}/tombstone/${k}`));
+		for (const [k, d] of Object.entries(tombstoneRaw)) {
+			throwIfAborted(signal);
+			const dot = readDot(d, `${path}/tombstone/${k}`);
+			if (observed) observeVersionVectorDot(observed, dot);
+			tombstone.set(k, dot);
+		}
 		return {
 			kind: "obj",
 			entries,
@@ -3829,17 +4595,24 @@ function deserializeNode(node, path, depth) {
 	}
 	if (kind !== "seq") fail("INVALID_SERIALIZED_SHAPE", `${path}/kind`, `unsupported node kind '${kind}'`);
 	const elemsRaw = asRecord(raw.elems, `${path}/elems`);
+	budgetMeter?.count("sequenceElements", Object.keys(elemsRaw).length, `${path}/elems`);
+	budgetMeter?.count("serializedElements", Object.keys(elemsRaw).length, `${path}/elems`);
 	const elems = /* @__PURE__ */ new Map();
 	for (const [id, rawElem] of Object.entries(elemsRaw)) {
+		throwIfAborted(signal);
 		const elemPath = `${path}/elems/${id}`;
 		const elem = asRecord(rawElem, elemPath);
 		const elemId = readString(elem.id, `${elemPath}/id`);
 		if (elemId !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/id`, `sequence element id '${elemId}' does not match key '${id}'`);
 		const prev = readString(elem.prev, `${elemPath}/prev`);
 		const tombstone = readBoolean(elem.tombstone, `${elemPath}/tombstone`);
-		const value = deserializeNode(elem.value, `${elemPath}/value`, depth + 1);
+		const value = deserializeNode(elem.value, `${elemPath}/value`, depth + 1, budgetMeter, observed, signal);
 		const insDot = readDot(elem.insDot, `${elemPath}/insDot`);
 		const delDot = "delDot" in elem && elem.delDot !== void 0 ? readDot(elem.delDot, `${elemPath}/delDot`) : void 0;
+		if (observed) {
+			observeVersionVectorDot(observed, insDot);
+			if (delDot) observeVersionVectorDot(observed, delDot);
+		}
 		if (dotToElemId(insDot) !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/insDot`, "sequence element id must match its insertion dot");
 		if (!tombstone && delDot) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/delDot`, "live sequence elements must not include delete metadata");
 		elems.set(id, {
@@ -3852,6 +4625,7 @@ function deserializeNode(node, path, depth) {
 		});
 	}
 	for (const elem of elems.values()) {
+		throwIfAborted(signal);
 		if (elem.prev === elem.id) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${elem.id}/prev`, "sequence element cannot reference itself as predecessor");
 		if (elem.prev !== HEAD_ELEM_ID && !elems.has(elem.prev)) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${elem.id}/prev`, `sequence predecessor '${elem.prev}' does not exist`);
 	}
@@ -3861,6 +4635,66 @@ function deserializeNode(node, path, depth) {
 		elems
 	};
 }
+function validateSerializedNode(node, path, depth, budgetMeter, signal) {
+	throwIfAborted(signal);
+	assertTraversalDepth(depth);
+	budgetMeter?.count("visitedNodes", 1, path);
+	const raw = asRecord(node, path);
+	const kind = readString(raw.kind, `${path}/kind`);
+	if (kind === "lww") {
+		if (!("value" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/value`, "lww node is missing value");
+		if (!("dot" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/dot`, "lww node is missing dot");
+		readDot(raw.dot, `${path}/dot`);
+		readJsonValue(raw.value, `${path}/value`, depth + 1, budgetMeter, signal);
+		return;
+	}
+	if (kind === "obj") {
+		const entriesRaw = asRecord(raw.entries, `${path}/entries`);
+		const tombstoneRaw = asRecord(raw.tombstone, `${path}/tombstone`);
+		budgetMeter?.count("objectEntries", Object.keys(entriesRaw).length, `${path}/entries`);
+		budgetMeter?.count("serializedElements", Object.keys(entriesRaw).length, `${path}/entries`);
+		budgetMeter?.count("objectEntries", Object.keys(tombstoneRaw).length, `${path}/tombstone`);
+		budgetMeter?.count("serializedElements", Object.keys(tombstoneRaw).length, `${path}/tombstone`);
+		for (const [k, v] of Object.entries(entriesRaw)) {
+			throwIfAborted(signal);
+			const entryPath = `${path}/entries/${k}`;
+			const entryRaw = asRecord(v, entryPath);
+			readDot(entryRaw.dot, `${entryPath}/dot`);
+			validateSerializedNode(entryRaw.node, `${entryPath}/node`, depth + 1, budgetMeter, signal);
+		}
+		for (const [k, d] of Object.entries(tombstoneRaw)) {
+			throwIfAborted(signal);
+			readDot(d, `${path}/tombstone/${k}`);
+		}
+		return;
+	}
+	if (kind !== "seq") fail("INVALID_SERIALIZED_SHAPE", `${path}/kind`, `unsupported node kind '${kind}'`);
+	const elemsRaw = asRecord(raw.elems, `${path}/elems`);
+	budgetMeter?.count("sequenceElements", Object.keys(elemsRaw).length, `${path}/elems`);
+	budgetMeter?.count("serializedElements", Object.keys(elemsRaw).length, `${path}/elems`);
+	const predecessors = /* @__PURE__ */ new Map();
+	for (const [id, rawElem] of Object.entries(elemsRaw)) {
+		throwIfAborted(signal);
+		const elemPath = `${path}/elems/${id}`;
+		const elem = asRecord(rawElem, elemPath);
+		const elemId = readString(elem.id, `${elemPath}/id`);
+		if (elemId !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/id`, `sequence element id '${elemId}' does not match key '${id}'`);
+		const prev = readString(elem.prev, `${elemPath}/prev`);
+		const tombstone = readBoolean(elem.tombstone, `${elemPath}/tombstone`);
+		validateSerializedNode(elem.value, `${elemPath}/value`, depth + 1, budgetMeter, signal);
+		const insDot = readDot(elem.insDot, `${elemPath}/insDot`);
+		const delDot = "delDot" in elem && elem.delDot !== void 0 ? readDot(elem.delDot, `${elemPath}/delDot`) : void 0;
+		if (dotToElemId(insDot) !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/insDot`, "sequence element id must match its insertion dot");
+		if (!tombstone && delDot) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/delDot`, "live sequence elements must not include delete metadata");
+		predecessors.set(id, prev);
+	}
+	for (const [id, prev] of predecessors) {
+		throwIfAborted(signal);
+		if (prev === id) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${id}/prev`, "sequence element cannot reference itself as predecessor");
+		if (prev !== HEAD_ELEM_ID && !predecessors.has(prev)) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${id}/prev`, `sequence predecessor '${prev}' does not exist`);
+	}
+	assertAcyclicSerializedRgaPredecessors(predecessors, path);
+}
 function assertAcyclicRgaPredecessors(elems, path) {
 	const visitState = /* @__PURE__ */ new Map();
 	for (const startId of elems.keys()) {
@@ -3881,6 +4715,26 @@ function assertAcyclicRgaPredecessors(elems, path) {
 		for (const id of trail) visitState.set(id, 2);
 	}
 }
+function assertAcyclicSerializedRgaPredecessors(predecessors, path) {
+	const visitState = /* @__PURE__ */ new Map();
+	for (const startId of predecessors.keys()) {
+		if (visitState.get(startId) === 2) continue;
+		const trail = [];
+		const trailSet = /* @__PURE__ */ new Set();
+		let currentId = startId;
+		while (currentId) {
+			if (trailSet.has(currentId)) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${currentId}/prev`, `sequence predecessor cycle detected at '${currentId}'`);
+			if (visitState.get(currentId) === 2) break;
+			trail.push(currentId);
+			trailSet.add(currentId);
+			visitState.set(currentId, 1);
+			const prev = predecessors.get(currentId);
+			if (!prev || prev === HEAD_ELEM_ID) break;
+			currentId = prev;
+		}
+		for (const id of trail) visitState.set(id, 2);
+	}
+}
 function asRecord(value, path) {
 	if (!isRecord(value)) fail("INVALID_SERIALIZED_SHAPE", path, "expected object");
 	return value;
@@ -3918,28 +4772,43 @@ function readBoolean(value, path) {
 	if (typeof value !== "boolean") fail("INVALID_SERIALIZED_SHAPE", path, "expected boolean");
 	return value;
 }
-function readJsonValue(value, path, depth) {
-	assertJsonValue(value, path, depth);
+function readJsonValue(value, path, depth, budgetMeter, signal) {
+	assertJsonValue(value, path, depth, budgetMeter, signal);
 	return value;
 }
-function assertJsonValue(value, path, depth) {
+function assertJsonValue(value, path, depth, budgetMeter, signal) {
+	throwIfAborted(signal);
 	assertTraversalDepth(depth);
+	budgetMeter?.count("visitedNodes", 1, path);
 	if (value === null || typeof value === "string" || typeof value === "boolean") return;
 	if (typeof value === "number") {
 		if (!Number.isFinite(value)) fail("INVALID_SERIALIZED_SHAPE", path, "json number must be finite");
 		return;
 	}
 	if (Array.isArray(value)) {
-		for (const [index, item] of value.entries()) assertJsonValue(item, `${path}/${index}`, depth + 1);
+		budgetMeter?.count("sequenceElements", value.length, path);
+		budgetMeter?.count("serializedElements", value.length, path);
+		for (const [index, item] of value.entries()) {
+			throwIfAborted(signal);
+			assertJsonValue(item, `${path}/${index}`, depth + 1, budgetMeter, signal);
+		}
 		return;
 	}
 	if (!isRecord(value)) fail("INVALID_SERIALIZED_SHAPE", path, "expected JSON value");
-	for (const [key, child] of Object.entries(value)) assertJsonValue(child, `${path}/${key}`, depth + 1);
+	const entries = Object.entries(value);
+	budgetMeter?.count("objectEntries", entries.length, path);
+	budgetMeter?.count("serializedElements", entries.length, path);
+	for (const [key, child] of entries) {
+		throwIfAborted(signal);
+		assertJsonValue(child, `${path}/${key}`, depth + 1, budgetMeter, signal);
+	}
 }
 function fail(reason, path, message) {
 	throw new DeserializeError(reason, path, message);
 }
 function toDeserializeFailure(error) {
+	if (error instanceof ResourceBudgetError) return toBudgetDeserializeFailure(error);
+	if (error instanceof OperationCancelledError) return toCancellationDeserializeFailure(error);
 	if (error instanceof DeserializeError || error instanceof TraversalDepthError) return error;
 	return null;
 }
@@ -3961,12 +4830,20 @@ var SharedElementMetadataMismatchError = class extends Error {
 var MergeError = class extends Error {
 	code;
 	reason;
+	budget;
+	limit;
+	actual;
 	path;
 	constructor(error) {
 		super(error.message);
 		this.name = "MergeError";
 		this.code = error.code;
 		this.reason = error.reason;
+		if (error.reason === "RESOURCE_BUDGET_EXCEEDED") {
+			this.budget = error.budget;
+			this.limit = error.limit;
+			this.actual = error.actual;
+		}
 		this.path = error.path;
 	}
 };
@@ -3991,20 +4868,27 @@ 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 !== null) return {
-			ok: false,
-			error: {
-				ok: false,
-				code: 409,
-				reason: "LINEAGE_MISMATCH",
-				message: `merge requires shared array origin at ${mismatchPath}`,
-				path: mismatchPath
-			}
+		const config = {
+			unrelatedArrays: resolveUnrelatedArraysStrategy(options),
+			budgetMeter: createBudgetMeter(options.resourceBudget),
+			signal: options.signal
 		};
+		if (config.unrelatedArrays === "reject") {
+			const mismatchPath = findSeqLineageMismatch(a.root, b.root, [], config);
+			if (mismatchPath !== null) return {
+				ok: false,
+				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 {
@@ -4021,6 +4905,14 @@ function tryMergeDoc(a, b, options = {}) {
 			ok: false,
 			error: toDepthApplyError(error)
 		};
+		if (error instanceof ResourceBudgetError) return {
+			ok: false,
+			error: toBudgetApplyError(error)
+		};
+		if (error instanceof OperationCancelledError) return {
+			ok: false,
+			error: toCancellationApplyError(error)
+		};
 		throw error;
 	}
 }
@@ -4030,7 +4922,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.
@@ -4042,29 +4934,79 @@ 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),
+			budgetMeter: createBudgetMeter(options.resourceBudget),
+			signal: options.signal
+		};
+		if (config.unrelatedArrays === "reject") {
+			const mismatchPath = findSeqLineageMismatch(a.doc.root, b.doc.root, [], config);
+			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)
+		};
+		if (error instanceof ResourceBudgetError) return {
+			ok: false,
+			error: toBudgetApplyError(error)
+		};
+		if (error instanceof OperationCancelledError) return {
+			ok: false,
+			error: toCancellationApplyError(error)
+		};
+		throw error;
+	}
 }
-function findSeqLineageMismatch(a, b, path) {
+function findSeqLineageMismatch(a, b, path, config) {
+	const pathBuffer = [...path];
 	const stack = [{
 		a,
 		b,
-		path,
 		depth: path.length
 	}];
 	while (stack.length > 0) {
+		throwIfAborted(config.signal);
 		const frame = stack.pop();
 		assertTraversalDepth(frame.depth);
+		pathBuffer.length = frame.depth;
+		if (frame.key !== void 0) pathBuffer[frame.depth - 1] = frame.key;
+		const budgetPath = config.budgetMeter ? stringifyJsonPointer(pathBuffer) : void 0;
+		config.budgetMeter?.count("visitedNodes", 1, budgetPath);
 		if (frame.a.kind === "seq" && frame.b.kind === "seq") {
+			config.budgetMeter?.count("sequenceElements", frame.a.elems.size + frame.b.elems.size, budgetPath);
 			const hasElemsA = frame.a.elems.size > 0;
 			const hasElemsB = frame.b.elems.size > 0;
 			if (hasElemsA && hasElemsB) {
@@ -4073,157 +5015,277 @@ function findSeqLineageMismatch(a, b, path) {
 					shared = true;
 					break;
 				}
-				if (!shared) return stringifyJsonPointer(frame.path);
+				if (!shared) return stringifyJsonPointer(pathBuffer);
 			}
 		}
 		if (frame.a.kind === "obj" && frame.b.kind === "obj") {
 			const left = frame.a;
 			const right = frame.b;
-			const sharedKeys = [...left.entries.keys()].filter((key) => right.entries.has(key));
-			for (let i = sharedKeys.length - 1; i >= 0; i--) {
-				const key = sharedKeys[i];
+			if (config.budgetMeter) {
+				let sharedKeyCount = 0;
+				for (const key of left.entries.keys()) if (right.entries.has(key)) sharedKeyCount += 1;
+				config.budgetMeter.count("objectEntries", sharedKeyCount, budgetPath);
+			}
+			const sharedKeysInOrder = [];
+			for (const key of left.entries.keys()) if (right.entries.has(key)) sharedKeysInOrder.push(key);
+			for (let i = sharedKeysInOrder.length - 1; i >= 0; i--) {
+				const key = sharedKeysInOrder[i];
 				const nextA = left.entries.get(key).node;
 				const nextB = right.entries.get(key).node;
 				stack.push({
 					a: nextA,
 					b: nextB,
-					path: [...frame.path, key],
-					depth: frame.depth + 1
+					depth: frame.depth + 1,
+					key
 				});
 			}
 		}
 	}
 	return null;
 }
-function maxObservedCtrForActor(doc, actor, a, b) {
-	let best = observedVersionVector(doc)[actor] ?? 0;
+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 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 repDot(node, signal) {
+	let best = {
+		actor: "",
+		ctr: 0
+	};
+	const stack = [{
+		node,
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		throwIfAborted(signal);
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		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 mergeNode(a, b) {
-	return mergeNodeAtDepth(a, b, 0, []);
-}
-function mergeNodeAtDepth(a, b, depth, path) {
+function mergeNodeAtDepth(a, b, depth, path, config) {
+	throwIfAborted(config.signal);
 	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);
-}
-function mergeLww(a, b) {
+	config.budgetMeter?.count("visitedNodes", 1, stringifyJsonPointer(path));
+	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, config.signal), repDot(b, config.signal)) >= 0) return cloneNodeShallow(a, depth + 1, config.actor, config.signal);
+	return cloneNodeShallow(b, depth + 1, config.actor, config.signal);
+}
+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()]);
+	config.budgetMeter?.count("objectEntries", allTombKeys.size, stringifyJsonPointer(path));
 	for (const key of allTombKeys) {
+		throwIfAborted(config.signal);
 		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()]);
+	config.budgetMeter?.count("objectEntries", allKeys.size, stringifyJsonPointer(path));
 	for (const key of allKeys) {
+		throwIfAborted(config.signal);
 		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) {
+			path.push(key);
+			const mergedNode = (() => {
+				try {
+					return mergeNodeAtDepth(ea.node, eb.node, depth + 1, path, config);
+				} finally {
+					path.pop();
+				}
+			})();
+			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, config.signal);
+			merged = {
+				node: cloned.node,
+				dot: { ...ea.dot }
+			};
+			mergedNodeMaxObservedCtr = cloned.maxObservedCtr;
+		} else {
+			const cloned = cloneNodeShallow(eb.node, depth + 1, config.actor, config.signal);
+			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);
+	config.budgetMeter?.count("visitedNodes", 1, stringifyJsonPointer(path));
+	if (config.unrelatedArrays === "atomic-replace" && a.elems.size > 0 && b.elems.size > 0) {
+		let shared = false;
+		for (const id of a.elems.keys()) {
+			throwIfAborted(config.signal);
+			if (b.elems.has(id)) {
+				shared = true;
+				break;
+			}
+		}
+		if (!shared) {
+			config.budgetMeter?.count("sequenceElements", a.elems.size + b.elems.size, stringifyJsonPointer(path));
+			return cloneNodeShallow(compareDot(repDot(a, config.signal), repDot(b, config.signal)) >= 0 ? a : b, depth, config.actor, config.signal);
+		}
+	}
 	const elems = /* @__PURE__ */ new Map();
+	let maxObservedCtr = 0;
 	const allIds = new Set([...a.elems.keys(), ...b.elems.keys()]);
+	config.budgetMeter?.count("sequenceElements", allIds.size, stringifyJsonPointer(path));
 	for (const id of allIds) {
+		throwIfAborted(config.signal);
 		const ea = a.elems.get(id);
 		const eb = b.elems.get(id);
 		if (ea && eb) {
 			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]);
+			path.push(id);
+			const mergedValue = (() => {
+				try {
+					return mergeNodeAtDepth(ea.value, eb.value, depth + 1, path, config);
+				} finally {
+					path.pop();
+				}
+			})();
+			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, config.signal);
+			elems.set(id, cloned.elem);
+			maxObservedCtr = Math.max(maxObservedCtr, cloned.maxObservedCtr);
+		} else {
+			const cloned = cloneElem(eb, depth + 1, config.actor, config.signal);
+			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 cloneElem(e, depth) {
+function cloneElem(e, depth, actor, signal) {
+	throwIfAborted(signal);
 	assertTraversalDepth(depth);
+	const value = cloneNodeShallow(e.value, depth + 1, actor, signal);
 	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) {
@@ -4231,38 +5293,68 @@ function mergeDeleteDot(a, b) {
 	if (a) return { ...a };
 	if (b) return { ...b };
 }
-function cloneNodeShallow(node, depth) {
+function cloneNodeShallow(node, depth, actor, signal) {
+	throwIfAborted(signal);
 	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) {
+				throwIfAborted(signal);
+				const cloned = cloneNodeShallow(v.node, depth + 1, actor, signal);
+				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) {
+				throwIfAborted(signal);
+				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) {
+				throwIfAborted(signal);
+				const cloned = cloneElem(e, depth + 1, actor, signal);
+				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
@@ -4344,4 +5436,4 @@ function compactStateTombstones(state, options) {
 }
 
 //#endregion
-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 };
+export { stableJsonValueKey as $, createState as A, mergeVersionVectors as At, crdtToFullReplace as B, createSafeState as C, vvMerge as Ct, applyPatch as D, nextDotForActor as Dt, PatchError as E, createClock as Et, tryApplyPatchInPlace as F, OperationCancelledError as Ft, jsonPatchToCrdtSafe as G, docFromJson as H, validateJsonPatch as I, ResourceBudgetError as It, compileJsonPatchToIntent as J, tryJsonPatchToCrdt as K, applyIntentsToCrdt as L, toJson as M, versionVectorCovers as Mt, tryApplyPatch as N, MAX_TRAVERSAL_DEPTH as Nt, applyPatchAsActor as O, observeDot as Ot, tryApplyPatchAsActor as P, TraversalDepthError as Pt, parseJsonPointer as Q, cloneDoc as R, createNormalizedState as S, vvHasDot as St, diffSafeJsonPatch as T, cloneClock as Tt, docFromJsonWithDot as U, crdtToJsonPatch as V, jsonPatchToCrdt as W, getAtJson as X, diffJsonPatch as Y, jsonEquals as Z, strictRfc6902PatchOptions as _, rgaLinearizeIds as _t, mergeState as a, newReg as at, applyNormalizedPatch as b, compareDot as bt, DeserializeError as c, objRemove as ct, serializeDoc as d, HEAD as dt, stringifyJsonPointer as et, serializeState as f, rgaCompactTombstones as ft, validateSerializedState as g, rgaInsertAfterChecked as gt, validateSerializedDoc as h, rgaInsertAfter as ht, mergeDoc as i, newObj as it, forkState as j, observedVersionVector as jt, applyPatchInPlace as k, intersectVersionVectors as kt, deserializeDoc as l, objSet as lt, tryDeserializeState as m, rgaIdAtIndex as mt, compactStateTombstones as n, JsonValueValidationError as nt, tryMergeDoc as o, newSeq as ot, tryDeserializeDoc as p, rgaDelete as pt, PatchCompileError as q, MergeError as r, lwwSet as rt, tryMergeState as s, objCompactTombstones as st, compactDocTombstones as t, ROOT_KEY as tt, deserializeState as u, materialize as ut, withLegacyMissingArrayParents as v, rgaPrevForInsertAtIndex as vt, diffNormalizedJsonPatch as w, ClockValidationError as wt, applySafePatch as x, dotToElemId as xt, withStrictRfc6902Parents as y, validateRgaSeq as yt, crdtNodesToJsonPatch as z };