json-patch-to-crdt 0.4.0 → 1.0.0

package/dist/{compact-CXfvMNCT.js → compact-BUXv4MXQ.js}

@@ -1,4 +1,130 @@
 
+//#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 {
@@ -27,6 +153,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];
@@ -43,6 +171,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.
 *
@@ -52,11 +195,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
@@ -88,6 +234,7 @@ function observedVersionVector(target) {
 			});
 		}
 	}
+	writeCachedObservedVersionVector(doc, vv);
 	return vv;
 }
 /** Combine version vectors using per-actor maxima. */
@@ -494,6 +641,7 @@ function rgaPrevForInsertAtIndex(seq, index) {
 //#endregion
 //#region src/materialize.ts
 let materializeObserver = null;
+const EMPTY_PATH = [];
 function createMaterializedObject() {
 	return Object.create(null);
 }
@@ -508,7 +656,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 = [];
@@ -539,7 +687,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);
@@ -577,7 +725,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") {
@@ -930,11 +1078,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;
@@ -949,14 +1099,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.
@@ -966,20 +1118,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();
@@ -1005,6 +1161,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);
@@ -1020,7 +1177,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
@@ -1028,7 +1185,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
@@ -1053,6 +1210,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({
@@ -1216,34 +1374,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,
@@ -1252,7 +1420,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) {
@@ -1267,20 +1436,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++) {
@@ -1291,11 +1460,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({
@@ -1314,8 +1483,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({
@@ -1328,26 +1497,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;
@@ -1370,11 +1549,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;
@@ -1384,11 +1564,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;
@@ -1434,9 +1615,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 [];
@@ -2066,54 +2248,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) {
@@ -2160,10 +2333,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;
 }
@@ -2315,7 +2502,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);
@@ -2377,38 +2567,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",
@@ -2473,7 +2713,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) {
@@ -2622,39 +2862,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,
@@ -2672,7 +2924,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 {
@@ -2713,6 +2965,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;
@@ -2837,6 +3129,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;
@@ -2862,8 +3183,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.
@@ -2873,7 +3193,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. */
@@ -2895,17 +3215,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__",
@@ -2914,108 +3244,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;
 	}
@@ -3080,26 +3698,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 = {}) {
@@ -3130,10 +3749,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
@@ -3176,28 +3798,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;
 		}
@@ -3245,10 +3866,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 };
 }
@@ -3256,7 +3877,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) {
@@ -3536,9 +4157,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)
@@ -3551,11 +4172,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) {
@@ -3603,6 +4226,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,
@@ -3619,6 +4244,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,
@@ -3630,6 +4262,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";
@@ -3665,17 +4359,24 @@ 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);
@@ -3686,6 +4387,20 @@ function tryDeserializeDoc(data) {
 		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 {
+			ok: false,
+			error: deserializeError
+		};
+		throw error;
+	}
+}
 /** Serialize a full CRDT state (document + clock) to a JSON-safe representation. */
 function serializeState(state) {
 	return {
@@ -3703,27 +4418,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, options = {}) {
+	try {
+		return {
+			ok: true,
+			state: deserializeState(data, options)
+		};
+	} catch (error) {
+		const deserializeError = toDeserializeFailure(error);
+		if (deserializeError) return {
+			ok: false,
+			error: deserializeError
+		};
+		throw error;
+	}
 }
-/** Non-throwing `deserializeState` variant with typed validation details. */
-function tryDeserializeState(data) {
+/** Validate a serialized CRDT state without throwing or returning runtime state. */
+function validateSerializedState(data, options = {}) {
 	try {
-		return {
-			ok: true,
-			state: deserializeState(data)
-		};
+		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 {
@@ -3795,33 +4539,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,
@@ -3830,17 +4596,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, {
@@ -3853,6 +4626,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`);
 	}
@@ -3862,6 +4636,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()) {
@@ -3882,6 +4716,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;
@@ -3919,28 +4773,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;
 }
@@ -3962,12 +4831,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;
 	}
 };
@@ -3992,20 +4869,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 {
@@ -4022,6 +4906,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;
 	}
 }
@@ -4031,7 +4923,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.
@@ -4043,29 +4935,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) {
@@ -4074,157 +5016,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) {
@@ -4232,38 +5294,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
@@ -4381,6 +5473,12 @@ Object.defineProperty(exports, 'MergeError', {
     return MergeError;
   }
 });
+Object.defineProperty(exports, 'OperationCancelledError', {
+  enumerable: true,
+  get: function () {
+    return OperationCancelledError;
+  }
+});
 Object.defineProperty(exports, 'PatchCompileError', {
   enumerable: true,
   get: function () {
@@ -4399,6 +5497,12 @@ Object.defineProperty(exports, 'ROOT_KEY', {
     return ROOT_KEY;
   }
 });
+Object.defineProperty(exports, 'ResourceBudgetError', {
+  enumerable: true,
+  get: function () {
+    return ResourceBudgetError;
+  }
+});
 Object.defineProperty(exports, 'TraversalDepthError', {
   enumerable: true,
   get: function () {
@@ -4411,6 +5515,12 @@ Object.defineProperty(exports, 'applyIntentsToCrdt', {
     return applyIntentsToCrdt;
   }
 });
+Object.defineProperty(exports, 'applyNormalizedPatch', {
+  enumerable: true,
+  get: function () {
+    return applyNormalizedPatch;
+  }
+});
 Object.defineProperty(exports, 'applyPatch', {
   enumerable: true,
   get: function () {
@@ -4429,6 +5539,12 @@ Object.defineProperty(exports, 'applyPatchInPlace', {
     return applyPatchInPlace;
   }
 });
+Object.defineProperty(exports, 'applySafePatch', {
+  enumerable: true,
+  get: function () {
+    return applySafePatch;
+  }
+});
 Object.defineProperty(exports, 'cloneClock', {
   enumerable: true,
   get: function () {
@@ -4489,6 +5605,18 @@ Object.defineProperty(exports, 'createClock', {
     return createClock;
   }
 });
+Object.defineProperty(exports, 'createNormalizedState', {
+  enumerable: true,
+  get: function () {
+    return createNormalizedState;
+  }
+});
+Object.defineProperty(exports, 'createSafeState', {
+  enumerable: true,
+  get: function () {
+    return createSafeState;
+  }
+});
 Object.defineProperty(exports, 'createState', {
   enumerable: true,
   get: function () {
@@ -4513,6 +5641,18 @@ Object.defineProperty(exports, 'diffJsonPatch', {
     return diffJsonPatch;
   }
 });
+Object.defineProperty(exports, 'diffNormalizedJsonPatch', {
+  enumerable: true,
+  get: function () {
+    return diffNormalizedJsonPatch;
+  }
+});
+Object.defineProperty(exports, 'diffSafeJsonPatch', {
+  enumerable: true,
+  get: function () {
+    return diffSafeJsonPatch;
+  }
+});
 Object.defineProperty(exports, 'docFromJson', {
   enumerable: true,
   get: function () {
@@ -4717,6 +5857,12 @@ Object.defineProperty(exports, 'stableJsonValueKey', {
     return stableJsonValueKey;
   }
 });
+Object.defineProperty(exports, 'strictRfc6902PatchOptions', {
+  enumerable: true,
+  get: function () {
+    return strictRfc6902PatchOptions;
+  }
+});
 Object.defineProperty(exports, 'stringifyJsonPointer', {
   enumerable: true,
   get: function () {
@@ -4789,6 +5935,18 @@ Object.defineProperty(exports, 'validateRgaSeq', {
     return validateRgaSeq;
   }
 });
+Object.defineProperty(exports, 'validateSerializedDoc', {
+  enumerable: true,
+  get: function () {
+    return validateSerializedDoc;
+  }
+});
+Object.defineProperty(exports, 'validateSerializedState', {
+  enumerable: true,
+  get: function () {
+    return validateSerializedState;
+  }
+});
 Object.defineProperty(exports, 'versionVectorCovers', {
   enumerable: true,
   get: function () {
@@ -4806,4 +5964,16 @@ Object.defineProperty(exports, 'vvMerge', {
   get: function () {
     return vvMerge;
   }
+});
+Object.defineProperty(exports, 'withLegacyMissingArrayParents', {
+  enumerable: true,
+  get: function () {
+    return withLegacyMissingArrayParents;
+  }
+});
+Object.defineProperty(exports, 'withStrictRfc6902Parents', {
+  enumerable: true,
+  get: function () {
+    return withStrictRfc6902Parents;
+  }
 });