json-patch-to-crdt 0.5.0 → 1.0.0

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

@@ -1,3 +1,129 @@
+//#region src/budget.ts
+function isNonNegativeSafeInteger(value) {
+	return Number.isSafeInteger(value) && value >= 0;
+}
+function formatPath(path) {
+	if (path === void 0 || path === "") return "";
+	return ` at ${path}`;
+}
+function formatOpIndex(opIndex) {
+	if (opIndex === void 0) return "";
+	return ` at op ${opIndex}`;
+}
+var ResourceBudgetError = class extends Error {
+	reason = "RESOURCE_BUDGET_EXCEEDED";
+	code = 409;
+	budget;
+	limit;
+	actual;
+	path;
+	opIndex;
+	constructor(budget, limit, actual, path, opIndex) {
+		super(`resource budget '${budget}' exceeded${formatPath(path)}${formatOpIndex(opIndex)}: ${actual} > ${limit}`);
+		this.name = "ResourceBudgetError";
+		this.budget = budget;
+		this.limit = limit;
+		this.actual = actual;
+		this.path = path;
+		this.opIndex = opIndex;
+	}
+};
+var ResourceBudgetMeter = class {
+	#budget;
+	#counts;
+	constructor(budget) {
+		this.#budget = validateBudget(budget);
+		this.#counts = {
+			patchOperations: 0,
+			objectEntries: 0,
+			sequenceElements: 0,
+			visitedNodes: 0,
+			serializedElements: 0,
+			arrayDiffCells: 0
+		};
+	}
+	count(kind, delta, path, opIndex) {
+		if (delta <= 0) return;
+		this.#counts[kind] += delta;
+		const limit = this.#budget[kind];
+		if (limit !== void 0 && this.#counts[kind] > limit) throw new ResourceBudgetError(kind, limit, this.#counts[kind], path, opIndex);
+	}
+};
+function createBudgetMeter(budget) {
+	if (budget === void 0) return;
+	return new ResourceBudgetMeter(budget);
+}
+function toBudgetApplyError(error) {
+	return {
+		ok: false,
+		code: error.code,
+		reason: error.reason,
+		message: error.message,
+		budget: error.budget,
+		limit: error.limit,
+		actual: error.actual,
+		path: error.path,
+		opIndex: error.opIndex
+	};
+}
+function toBudgetDeserializeFailure(error) {
+	return {
+		code: error.code,
+		reason: error.reason,
+		message: error.message,
+		budget: error.budget,
+		limit: error.limit,
+		actual: error.actual,
+		path: error.path
+	};
+}
+function validateBudget(budget) {
+	if (budget === void 0) return {};
+	const normalized = {};
+	const entries = Object.entries(budget);
+	for (const [key, value] of entries) {
+		if (value === void 0) continue;
+		if (!isNonNegativeSafeInteger(value)) throw new Error(`resource budget '${key}' must be a non-negative safe integer`);
+		normalized[key] = value;
+	}
+	return normalized;
+}
+
+//#endregion
+//#region src/cancellation.ts
+var OperationCancelledError = class extends Error {
+	reasonValue;
+	constructor(reason) {
+		super(toCancellationMessage(reason));
+		this.name = "OperationCancelledError";
+		this.reasonValue = reason;
+	}
+};
+function throwIfAborted(signal) {
+	if (signal?.aborted) throw new OperationCancelledError(signal.reason);
+}
+function toCancellationApplyError(error) {
+	return {
+		ok: false,
+		code: 409,
+		reason: "OPERATION_CANCELLED",
+		message: error.message
+	};
+}
+function toCancellationDeserializeFailure(error) {
+	return {
+		code: 409,
+		reason: "OPERATION_CANCELLED",
+		message: error.message
+	};
+}
+function toCancellationMessage(reason) {
+	if (reason instanceof Error && reason.message.length > 0) return `operation cancelled: ${reason.message}`;
+	if (typeof reason === "string" && reason.length > 0) return `operation cancelled: ${reason}`;
+	return "operation cancelled";
+}
+
+//#endregion
 //#region src/depth.ts
 const MAX_TRAVERSAL_DEPTH = 16384;
 var TraversalDepthError = class extends Error {
@@ -27,6 +153,7 @@ 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 +170,21 @@ function writeVersionVectorCounter(vv, actor, counter) {
 function observeVersionVectorDot(vv, dot) {
 	if ((readVersionVectorCounter(vv, dot.actor) ?? 0) < dot.ctr) writeVersionVectorCounter(vv, dot.actor, dot.ctr);
 }
+function cloneVersionVector(vv) {
+	return mergeVersionVectors(vv);
+}
+function readCachedObservedVersionVector(doc) {
+	const cached = observedVersionVectorCache.get(doc);
+	return cached ? cloneVersionVector(cached) : void 0;
+}
+function writeCachedObservedVersionVector(doc, vv) {
+	observedVersionVectorCache.set(doc, cloneVersionVector(vv));
+}
+function observeDocVersionVectorDot(doc, dot) {
+	const cached = observedVersionVectorCache.get(doc);
+	if (!cached) return;
+	observeVersionVectorDot(cached, dot);
+}
 /**
 * Inspect a document or state and return the highest observed counter per actor.
 *
@@ -51,13 +193,15 @@ function observeVersionVectorDot(vv, dot) {
 * of the currently materialized document tree.
 */
 function observedVersionVector(target) {
-	observedVersionVectorObserverForTests?.(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
@@ -89,6 +233,7 @@ function observedVersionVector(target) {
 			});
 		}
 	}
+	writeCachedObservedVersionVector(doc, vv);
 	return vv;
 }
 /** Combine version vectors using per-actor maxima. */
@@ -932,11 +1077,13 @@ function getAtJson(base, path) {
 */
 function compileJsonPatchToIntent(baseJson, patch, options = {}) {
 	const internalOptions = options;
+	const budgetMeter = internalOptions.budgetMeter ?? createBudgetMeter(options.resourceBudget);
 	const semantics = options.semantics ?? "sequential";
 	const opIndexOffset = internalOptions.opIndexOffset ?? 0;
 	let workingBase = baseJson;
 	const pointerCache = internalOptions.pointerCache ?? /* @__PURE__ */ new Map();
 	const intents = [];
+	budgetMeter?.count("patchOperations", patch.length);
 	for (let opIndex = 0; opIndex < patch.length; opIndex++) {
 		const op = patch[opIndex];
 		const absoluteOpIndex = opIndex + opIndexOffset;
@@ -951,14 +1098,16 @@ function compileJsonPatchOpToIntent(baseJson, op, options = {}) {
 	const internalOptions = options;
 	const semantics = options.semantics ?? "sequential";
 	const pointerCache = internalOptions.pointerCache ?? /* @__PURE__ */ new Map();
-	return compileSingleOp(baseJson, op, internalOptions.opIndexOffset ?? 0, semantics, pointerCache);
+	const opIndex = internalOptions.opIndexOffset ?? 0;
+	(internalOptions.budgetMeter ?? createBudgetMeter(options.resourceBudget))?.count("patchOperations", 1, void 0, opIndex);
+	return compileSingleOp(baseJson, op, opIndex, semantics, pointerCache);
 }
 /**
 * Compute a JSON Patch delta between two JSON values.
 * By default arrays use a deterministic LCS strategy.
 * Pass `{ arrayStrategy: "atomic" }` for single-op array replacement.
 * Pass `{ arrayStrategy: "lcs-linear" }` for a lower-memory LCS variant.
-* Use `lcsLinearMaxCells` to optionally cap worst-case `lcs-linear` work and
+* Use `lcsLinearMaxCells` to cap worst-case `lcs-linear` work and
 * fall back to an atomic array replacement for very large unmatched windows.
 * Pass `{ emitMoves: true }` or `{ emitCopies: true }` to opt into RFC 6902
 * move/copy emission when a deterministic rewrite is available.
@@ -968,20 +1117,24 @@ function compileJsonPatchOpToIntent(baseJson, op, options = {}) {
 * @returns An array of JSON Patch operations that transform `base` into `next`.
 */
 function diffJsonPatch(base, next, options = {}) {
+	const budgetMeter = createBudgetMeter(options.resourceBudget);
 	const runtimeMode = options.jsonValidation ?? "none";
 	const runtimeBase = coerceRuntimeJsonValue(base, runtimeMode);
 	const runtimeNext = coerceRuntimeJsonValue(next, runtimeMode);
 	const ops = [];
-	diffValue([], runtimeBase, runtimeNext, ops, options);
+	const path = [];
+	throwIfAborted(options.signal);
+	diffValue(path, runtimeBase, runtimeNext, ops, options, budgetMeter);
 	return ops;
 }
-function diffValue(path, base, next, ops, options) {
+function diffValue(path, base, next, ops, options, budgetMeter) {
 	const stack = [{
 		kind: "value",
 		base,
 		next
 	}];
 	while (stack.length > 0) {
+		throwIfAborted(options.signal);
 		const frame = stack.pop();
 		if (frame.kind === "path-pop") {
 			path.pop();
@@ -1007,6 +1160,7 @@ function diffValue(path, base, next, ops, options) {
 			continue;
 		}
 		assertTraversalDepth(path.length);
+		budgetMeter?.count("visitedNodes", 1, stringifyJsonPointer(path));
 		if (frame.base === frame.next) continue;
 		const baseIsArray = Array.isArray(frame.base);
 		const nextIsArray = Array.isArray(frame.next);
@@ -1022,7 +1176,7 @@ function diffValue(path, base, next, ops, options) {
 			if (jsonEquals(frame.base, frame.next)) continue;
 			const arrayStrategy = options.arrayStrategy ?? "lcs";
 			if (arrayStrategy === "lcs") {
-				if (!diffArrayWithLcsMatrix(path, frame.base, frame.next, ops, options)) ops.push({
+				if (!diffArrayWithLcsMatrix(path, frame.base, frame.next, ops, options, budgetMeter)) ops.push({
 					op: "replace",
 					path: stringifyJsonPointer(path),
 					value: frame.next
@@ -1030,7 +1184,7 @@ function diffValue(path, base, next, ops, options) {
 				continue;
 			}
 			if (arrayStrategy === "lcs-linear") {
-				if (!diffArrayWithLinearLcs(path, frame.base, frame.next, ops, options)) ops.push({
+				if (!diffArrayWithLinearLcs(path, frame.base, frame.next, ops, options, budgetMeter)) ops.push({
 					op: "replace",
 					path: stringifyJsonPointer(path),
 					value: frame.next
@@ -1055,6 +1209,7 @@ function diffValue(path, base, next, ops, options) {
 			continue;
 		}
 		const { sharedKeys, baseOnlyKeys, nextOnlyKeys } = collectObjectKeys(frame.base, frame.next);
+		budgetMeter?.count("objectEntries", sharedKeys.length + baseOnlyKeys.length + nextOnlyKeys.length, stringifyJsonPointer(path));
 		if (!(baseOnlyKeys.length > 0 || nextOnlyKeys.length > 0) && (path.length === 0 || sharedKeys.length > 1) && jsonEquals(frame.base, frame.next)) continue;
 		emitObjectStructuralOps(path, frame.base, frame.next, sharedKeys, baseOnlyKeys, nextOnlyKeys, ops, options);
 		if (sharedKeys.length > 0) stack.push({
@@ -1218,34 +1373,44 @@ function insertSortedKey(keys, key) {
 	}
 	keys.splice(low, 0, key);
 }
-function diffArrayWithLcsMatrix(path, base, next, ops, options) {
-	const window = trimEqualArrayEdges(base, next);
+function diffArrayWithLcsMatrix(path, base, next, ops, options, budgetMeter) {
+	const window = trimEqualArrayEdges(base, next, options);
 	const baseStart = window.baseStart;
 	const nextStart = window.nextStart;
 	const n = window.unmatchedBaseLength;
 	const m = window.unmatchedNextLength;
+	budgetMeter?.count("sequenceElements", n + m, stringifyJsonPointer(path));
 	if (!shouldUseLcsDiff(n, m, options.lcsMaxCells)) return false;
+	budgetMeter?.count("arrayDiffCells", (n + 1) * (m + 1), stringifyJsonPointer(path));
 	if (n === 0 && m === 0) return true;
 	const steps = [];
-	buildArrayEditScriptWithMatrix(base, baseStart, baseStart + n, next, nextStart, nextStart + m, steps);
+	buildArrayEditScriptWithMatrix(base, baseStart, baseStart + n, next, nextStart, nextStart + m, steps, options);
 	pushArrayPatchOps(path, window.prefixLength, steps, ops, base, options);
 	return true;
 }
-function diffArrayWithLinearLcs(path, base, next, ops, options) {
-	const window = trimEqualArrayEdges(base, next);
+function diffArrayWithLinearLcs(path, base, next, ops, options, budgetMeter) {
+	const window = trimEqualArrayEdges(base, next, options);
+	budgetMeter?.count("sequenceElements", window.unmatchedBaseLength + window.unmatchedNextLength, stringifyJsonPointer(path));
 	if (!shouldUseLinearLcsDiff(window.unmatchedBaseLength, window.unmatchedNextLength, options)) return false;
+	budgetMeter?.count("arrayDiffCells", (window.unmatchedBaseLength + 1) * (window.unmatchedNextLength + 1), stringifyJsonPointer(path));
 	const steps = [];
-	buildArrayEditScriptLinearSpace(base, window.baseStart, window.baseStart + window.unmatchedBaseLength, next, window.nextStart, window.nextStart + window.unmatchedNextLength, steps);
+	buildArrayEditScriptLinearSpace(base, window.baseStart, window.baseStart + window.unmatchedBaseLength, next, window.nextStart, window.nextStart + window.unmatchedNextLength, steps, options);
 	pushArrayPatchOps(path, window.prefixLength, steps, ops, base, options);
 	return true;
 }
-function trimEqualArrayEdges(base, next) {
+function trimEqualArrayEdges(base, next, options) {
 	const baseLength = base.length;
 	const nextLength = next.length;
 	let prefixLength = 0;
-	while (prefixLength < baseLength && prefixLength < nextLength && jsonEquals(base[prefixLength], next[prefixLength])) prefixLength += 1;
+	while (prefixLength < baseLength && prefixLength < nextLength && jsonEquals(base[prefixLength], next[prefixLength])) {
+		throwIfAborted(options.signal);
+		prefixLength += 1;
+	}
 	let suffixLength = 0;
-	while (suffixLength < baseLength - prefixLength && suffixLength < nextLength - prefixLength && jsonEquals(base[baseLength - 1 - suffixLength], next[nextLength - 1 - suffixLength])) suffixLength += 1;
+	while (suffixLength < baseLength - prefixLength && suffixLength < nextLength - prefixLength && jsonEquals(base[baseLength - 1 - suffixLength], next[nextLength - 1 - suffixLength])) {
+		throwIfAborted(options.signal);
+		suffixLength += 1;
+	}
 	return {
 		baseStart: prefixLength,
 		nextStart: prefixLength,
@@ -1254,7 +1419,8 @@ function trimEqualArrayEdges(base, next) {
 		unmatchedNextLength: nextLength - prefixLength - suffixLength
 	};
 }
-function buildArrayEditScriptLinearSpace(base, baseStart, baseEnd, next, nextStart, nextEnd, steps) {
+function buildArrayEditScriptLinearSpace(base, baseStart, baseEnd, next, nextStart, nextEnd, steps, options) {
+	throwIfAborted(options.signal);
 	const unmatchedBaseLength = baseEnd - baseStart;
 	const unmatchedNextLength = nextEnd - nextStart;
 	if (unmatchedBaseLength === 0) {
@@ -1269,20 +1435,20 @@ function buildArrayEditScriptLinearSpace(base, baseStart, baseEnd, next, nextSta
 		return;
 	}
 	if (unmatchedBaseLength === 1) {
-		pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps);
+		pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps, options);
 		return;
 	}
 	if (unmatchedNextLength === 1) {
-		pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps);
+		pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps, options);
 		return;
 	}
 	if (shouldUseMatrixBaseCase(unmatchedBaseLength, unmatchedNextLength)) {
-		buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps);
+		buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps, options);
 		return;
 	}
 	const baseMid = baseStart + Math.floor(unmatchedBaseLength / 2);
-	const forwardScores = computeLcsPrefixLengths(base, baseStart, baseMid, next, nextStart, nextEnd);
-	const reverseScores = computeLcsSuffixLengths(base, baseMid, baseEnd, next, nextStart, nextEnd);
+	const forwardScores = computeLcsPrefixLengths(base, baseStart, baseMid, next, nextStart, nextEnd, options);
+	const reverseScores = computeLcsSuffixLengths(base, baseMid, baseEnd, next, nextStart, nextEnd, options);
 	let bestOffset = 0;
 	let bestScore = Number.NEGATIVE_INFINITY;
 	for (let offset = 0; offset <= unmatchedNextLength; offset++) {
@@ -1293,11 +1459,11 @@ function buildArrayEditScriptLinearSpace(base, baseStart, baseEnd, next, nextSta
 		}
 	}
 	const nextMid = nextStart + bestOffset;
-	buildArrayEditScriptLinearSpace(base, baseStart, baseMid, next, nextStart, nextMid, steps);
-	buildArrayEditScriptLinearSpace(base, baseMid, baseEnd, next, nextMid, nextEnd, steps);
+	buildArrayEditScriptLinearSpace(base, baseStart, baseMid, next, nextStart, nextMid, steps, options);
+	buildArrayEditScriptLinearSpace(base, baseMid, baseEnd, next, nextMid, nextEnd, steps, options);
 }
-function pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps) {
-	const matchIndex = findFirstMatchingIndexInNext(base[baseStart], next, nextStart, nextEnd);
+function pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, steps, options) {
+	const matchIndex = findFirstMatchingIndexInNext(base[baseStart], next, nextStart, nextEnd, options);
 	if (matchIndex === -1) {
 		steps.push({ kind: "remove" });
 		for (let nextIndex = nextStart; nextIndex < nextEnd; nextIndex++) steps.push({
@@ -1316,8 +1482,8 @@ function pushSingleBaseElementSteps(base, baseStart, next, nextStart, nextEnd, s
 		value: next[nextIndex]
 	});
 }
-function pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps) {
-	const matchIndex = findFirstMatchingIndexInBase(next[nextStart], base, baseStart, baseEnd);
+function pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, steps, options) {
+	const matchIndex = findFirstMatchingIndexInBase(next[nextStart], base, baseStart, baseEnd, options);
 	if (matchIndex === -1) {
 		for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) steps.push({ kind: "remove" });
 		steps.push({
@@ -1330,26 +1496,36 @@ function pushSingleNextElementSteps(base, baseStart, baseEnd, next, nextStart, s
 	steps.push({ kind: "equal" });
 	for (let baseIndex = matchIndex + 1; baseIndex < baseEnd; baseIndex++) steps.push({ kind: "remove" });
 }
-function findFirstMatchingIndexInNext(target, next, nextStart, nextEnd) {
-	for (let nextIndex = nextStart; nextIndex < nextEnd; nextIndex++) if (jsonEquals(target, next[nextIndex])) return nextIndex;
+function findFirstMatchingIndexInNext(target, next, nextStart, nextEnd, options) {
+	for (let nextIndex = nextStart; nextIndex < nextEnd; nextIndex++) {
+		throwIfAborted(options.signal);
+		if (jsonEquals(target, next[nextIndex])) return nextIndex;
+	}
 	return -1;
 }
-function findFirstMatchingIndexInBase(target, base, baseStart, baseEnd) {
-	for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) if (jsonEquals(target, base[baseIndex])) return baseIndex;
+function findFirstMatchingIndexInBase(target, base, baseStart, baseEnd, options) {
+	for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) {
+		throwIfAborted(options.signal);
+		if (jsonEquals(target, base[baseIndex])) return baseIndex;
+	}
 	return -1;
 }
 function shouldUseMatrixBaseCase(baseLength, nextLength) {
 	return (baseLength + 1) * (nextLength + 1) <= LINEAR_LCS_MATRIX_BASE_CASE_MAX_CELLS;
 }
-function buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps) {
+function buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStart, nextEnd, steps, options) {
 	const unmatchedBaseLength = baseEnd - baseStart;
 	const unmatchedNextLength = nextEnd - nextStart;
 	const lcs = Array.from({ length: unmatchedBaseLength + 1 }, () => Array(unmatchedNextLength + 1).fill(0));
-	for (let baseOffset = unmatchedBaseLength - 1; baseOffset >= 0; baseOffset--) for (let nextOffset = unmatchedNextLength - 1; nextOffset >= 0; nextOffset--) if (jsonEquals(base[baseStart + baseOffset], next[nextStart + nextOffset])) lcs[baseOffset][nextOffset] = 1 + lcs[baseOffset + 1][nextOffset + 1];
-	else lcs[baseOffset][nextOffset] = Math.max(lcs[baseOffset + 1][nextOffset], lcs[baseOffset][nextOffset + 1]);
+	for (let baseOffset = unmatchedBaseLength - 1; baseOffset >= 0; baseOffset--) {
+		throwIfAborted(options.signal);
+		for (let nextOffset = unmatchedNextLength - 1; nextOffset >= 0; nextOffset--) if (jsonEquals(base[baseStart + baseOffset], next[nextStart + nextOffset])) lcs[baseOffset][nextOffset] = 1 + lcs[baseOffset + 1][nextOffset + 1];
+		else lcs[baseOffset][nextOffset] = Math.max(lcs[baseOffset + 1][nextOffset], lcs[baseOffset][nextOffset + 1]);
+	}
 	let baseOffset = 0;
 	let nextOffset = 0;
 	while (baseOffset < unmatchedBaseLength || nextOffset < unmatchedNextLength) {
+		throwIfAborted(options.signal);
 		if (baseOffset < unmatchedBaseLength && nextOffset < unmatchedNextLength && jsonEquals(base[baseStart + baseOffset], next[nextStart + nextOffset])) {
 			steps.push({ kind: "equal" });
 			baseOffset += 1;
@@ -1372,11 +1548,12 @@ function buildArrayEditScriptWithMatrix(base, baseStart, baseEnd, next, nextStar
 		}
 	}
 }
-function computeLcsPrefixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd) {
+function computeLcsPrefixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd, options) {
 	const unmatchedNextLength = nextEnd - nextStart;
 	let previousRow = new Int32Array(unmatchedNextLength + 1);
 	let currentRow = new Int32Array(unmatchedNextLength + 1);
 	for (let baseIndex = baseStart; baseIndex < baseEnd; baseIndex++) {
+		throwIfAborted(options.signal);
 		for (let nextOffset = 0; nextOffset < unmatchedNextLength; nextOffset++) if (jsonEquals(base[baseIndex], next[nextStart + nextOffset])) currentRow[nextOffset + 1] = previousRow[nextOffset] + 1;
 		else currentRow[nextOffset + 1] = Math.max(previousRow[nextOffset + 1], currentRow[nextOffset]);
 		const nextPreviousRow = currentRow;
@@ -1386,11 +1563,12 @@ function computeLcsPrefixLengths(base, baseStart, baseEnd, next, nextStart, next
 	}
 	return previousRow;
 }
-function computeLcsSuffixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd) {
+function computeLcsSuffixLengths(base, baseStart, baseEnd, next, nextStart, nextEnd, options) {
 	const unmatchedNextLength = nextEnd - nextStart;
 	let previousRow = new Int32Array(unmatchedNextLength + 1);
 	let currentRow = new Int32Array(unmatchedNextLength + 1);
 	for (let baseIndex = baseEnd - 1; baseIndex >= baseStart; baseIndex--) {
+		throwIfAborted(options.signal);
 		for (let nextOffset = unmatchedNextLength - 1; nextOffset >= 0; nextOffset--) if (jsonEquals(base[baseIndex], next[nextStart + nextOffset])) currentRow[nextOffset] = previousRow[nextOffset + 1] + 1;
 		else currentRow[nextOffset] = Math.max(previousRow[nextOffset], currentRow[nextOffset + 1]);
 		const nextPreviousRow = currentRow;
@@ -1436,9 +1614,10 @@ function shouldUseLcsDiff(baseLength, nextLength, lcsMaxCells) {
 }
 function shouldUseLinearLcsDiff(baseLength, nextLength, options) {
 	const cap = options.lcsLinearMaxCells;
-	if (cap === void 0 || cap === Number.POSITIVE_INFINITY) return true;
-	if (!Number.isFinite(cap) || cap < 1) return false;
-	return (baseLength + 1) * (nextLength + 1) <= cap;
+	if (cap === Number.POSITIVE_INFINITY) return true;
+	const effectiveCap = cap ?? DEFAULT_LCS_MAX_CELLS;
+	if (!Number.isFinite(effectiveCap) || effectiveCap < 1) return false;
+	return (baseLength + 1) * (nextLength + 1) <= effectiveCap;
 }
 function finalizeArrayOps(arrayPath, base, ops, options) {
 	if (ops.length === 0) return [];
@@ -2068,7 +2247,14 @@ 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 helper for tests and fixtures that seeds an entire document from one dot.
@@ -2315,7 +2501,10 @@ function nodeFromJson(value, nextDot) {
 }
 /** Deep-clone a CRDT document. The clone is fully independent of the original. */
 function cloneDoc(doc) {
-	return { root: cloneNode(doc.root) };
+	const cloned = { root: cloneNode(doc.root) };
+	const cached = readCachedObservedVersionVector(doc);
+	if (cached) writeCachedObservedVersionVector(cloned, cached);
+	return cloned;
 }
 function cloneNode(node) {
 	return cloneNodeAtDepth(node, 0);
@@ -2523,7 +2712,7 @@ function createArrayIndexLookupSession() {
 		return created;
 	} };
 }
-function applyArrInsert(base, head, it, newDot, indexSession, bumpCounterAbove, strictParents = false) {
+function applyArrInsert(base, head, it, newDot, indexSession, bumpCounterAbove, strictParents = true) {
 	const pointer = `/${it.path.join("/")}`;
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) {
@@ -2672,39 +2861,51 @@ function applyArrReplace(base, head, it, newDot, indexSession) {
 * @param evalTestAgainst - Whether `test` ops are evaluated against `"head"` or `"base"`.
 * @param bumpCounterAbove - Optional hook that can fast-forward the underlying counter before inserts.
 * @param options - Optional behavior toggles.
-* @param options.strictParents - When `true`, reject array inserts whose base parent path is missing.
+* @param options.strictParents - Reject array inserts whose base parent path is missing.
+*   Defaults to `true`; pass `false` only for legacy missing-parent array auto-creation.
 * @returns `{ ok: true }` on success, or `{ ok: false, code: 409, message }` on conflict.
 */
 function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head", bumpCounterAbove, options = {}) {
 	const arrayIndexSession = createArrayIndexLookupSession();
+	let pendingObservedDots = [];
+	const observedNewDot = () => {
+		const dot = newDot();
+		pendingObservedDots.push(dot);
+		return dot;
+	};
 	for (const it of intents) {
 		let fail = null;
+		pendingObservedDots = [];
 		switch (it.t) {
 			case "Test":
 				fail = applyTest(base, head, it, evalTestAgainst);
 				break;
 			case "ObjSet":
-				fail = applyObjSet(head, it, newDot);
+				fail = applyObjSet(head, it, observedNewDot);
 				break;
 			case "ObjRemove":
-				fail = applyObjRemove(head, it, newDot);
+				fail = applyObjRemove(head, it, observedNewDot);
 				break;
 			case "ArrInsert":
-				fail = applyArrInsert(base, head, it, newDot, arrayIndexSession, bumpCounterAbove, options.strictParents ?? false);
+				fail = applyArrInsert(base, head, it, observedNewDot, arrayIndexSession, bumpCounterAbove, options.strictParents ?? true);
 				break;
 			case "ArrDelete":
-				fail = applyArrDelete(base, head, it, newDot, arrayIndexSession);
+				fail = applyArrDelete(base, head, it, observedNewDot, arrayIndexSession);
 				break;
 			case "ArrReplace":
-				fail = applyArrReplace(base, head, it, newDot, arrayIndexSession);
+				fail = applyArrReplace(base, head, it, observedNewDot, arrayIndexSession);
 				break;
 			default: assertNever(it, "Unhandled intent type");
 		}
-		if (fail) return fail;
+		if (fail) {
+			pendingObservedDots = [];
+			return fail;
+		}
+		for (const dot of pendingObservedDots) observeDocVersionVectorDot(head, dot);
 	}
 	return { ok: true };
 }
-function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = false) {
+function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = true) {
 	if (isJsonPatchToCrdtOptions(baseOrOptions)) return jsonPatchToCrdtInternal(baseOrOptions);
 	if (!head || !patch || !newDot) return {
 		ok: false,
@@ -2722,7 +2923,7 @@ function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "
 		strictParents
 	});
 }
-function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = false) {
+function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = true) {
 	try {
 		if (isJsonPatchToCrdtOptions(baseOrOptions)) return jsonPatchToCrdt(baseOrOptions);
 		if (!head || !patch || !newDot) return {
@@ -2991,7 +3192,7 @@ function diffNodeToPatch(path, baseNode, headNode, options, ops, depth) {
 * @returns An array of JSON Patch operations that transform base into head.
 */
 function crdtToJsonPatch(base, head, options) {
-	if ((options?.jsonValidation ?? "none") !== "none") return diffJsonPatch(materialize(base.root), materialize(head.root), options);
+	if ((options?.jsonValidation ?? "none") !== "none" || options?.resourceBudget !== void 0) return diffJsonPatch(materialize(base.root), materialize(head.root), options);
 	return crdtNodesToJsonPatch(base.root, head.root, options);
 }
 /** Internals-only helper for diffing CRDT nodes from an existing traversal depth. */
@@ -3013,11 +3214,21 @@ 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);
 		}
@@ -3402,6 +3613,9 @@ function assertNever(_value, message) {
 var PatchError = class extends Error {
 	code;
 	reason;
+	budget;
+	limit;
+	actual;
 	path;
 	opIndex;
 	constructor(errorOrMessage, code = 409, reason = "INVALID_PATCH") {
@@ -3414,6 +3628,11 @@ var PatchError = class extends Error {
 		}
 		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;
 	}
@@ -3478,26 +3697,27 @@ function applyPatchInPlace(state, patch, options = {}) {
 }
 /** Non-throwing immutable patch application variant. */
 function tryApplyPatch(state, patch, options = {}) {
-	const nextState = {
-		doc: cloneDoc(state.doc),
-		clock: cloneClock(state.clock)
-	};
 	try {
+		throwIfAborted(options.signal);
+		const nextState = {
+			doc: cloneDoc(state.doc),
+			clock: cloneClock(state.clock)
+		};
 		const result = applyPatchInternal(nextState, patch, options, "batch");
 		if (!result.ok) return {
 			ok: false,
 			error: result
 		};
+		return {
+			ok: true,
+			state: nextState
+		};
 	} catch (error) {
 		return {
 			ok: false,
 			error: toApplyError(error)
 		};
 	}
-	return {
-		ok: true,
-		state: nextState
-	};
 }
 /** Non-throwing in-place patch application variant. */
 function tryApplyPatchInPlace(state, patch, options = {}) {
@@ -3577,6 +3797,7 @@ 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)
@@ -3584,8 +3805,10 @@ function toApplyPatchOptionsForActor(options) {
 	};
 }
 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") {
 		const explicitBaseState = options.base ? {
@@ -3594,6 +3817,7 @@ function applyPatchInternal(state, patch, options, _execution) {
 		} : 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;
 		}
@@ -3932,9 +4156,9 @@ function validateArrayIndexBounds(index, op, arrLength, path, opIndex) {
 function bumpClockCounter(state, ctr) {
 	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
 }
-function compilePreparedIntents(baseJson, patch, semantics = "sequential", pointerCache, opIndexOffset = 0) {
+function compilePreparedIntents(baseJson, patch, semantics = "sequential", pointerCache, opIndexOffset = 0, budgetMeter) {
 	try {
-		const compileOptions = toCompilePatchOptions(semantics, pointerCache, opIndexOffset);
+		const compileOptions = toCompilePatchOptions(semantics, pointerCache, opIndexOffset, budgetMeter);
 		if (patch.length === 1) return {
 			ok: true,
 			intents: compileJsonPatchOpToIntent(baseJson, patch[0], compileOptions)
@@ -3947,11 +4171,13 @@ function compilePreparedIntents(baseJson, patch, semantics = "sequential", point
 		return toApplyError(error);
 	}
 }
-function toCompilePatchOptions(semantics, pointerCache, opIndexOffset = 0) {
+function toCompilePatchOptions(semantics, pointerCache, opIndexOffset = 0, budgetMeter) {
 	return {
 		semantics,
+		resourceBudget: void 0,
 		pointerCache,
-		opIndexOffset
+		opIndexOffset,
+		budgetMeter
 	};
 }
 function preparePatchPayloadsSafe(patch, mode) {
@@ -3999,6 +4225,8 @@ function mergePointerPaths(basePointer, nestedPointer) {
 	return `${basePointer}${nestedPointer}`;
 }
 function toApplyError(error) {
+	if (error instanceof OperationCancelledError) return toCancellationApplyError(error);
+	if (error instanceof ResourceBudgetError) return toBudgetApplyError(error);
 	if (error instanceof TraversalDepthError) return toDepthApplyError(error);
 	if (error instanceof PatchCompileError) return {
 		ok: false,
@@ -4033,6 +4261,68 @@ function toPointerParseApplyError(error, pointer, opIndex) {
 	};
 }
 
+//#endregion
+//#region src/safe.ts
+/** Create a state with strict runtime JSON validation enabled by default. */
+function createSafeState(initial, options) {
+	return createState(initial, {
+		...options,
+		jsonValidation: "strict"
+	});
+}
+/** Apply a patch with strict runtime JSON validation enabled by default. */
+function applySafePatch(state, patch, options = {}) {
+	return applyPatch(state, patch, {
+		...options,
+		jsonValidation: "strict"
+	});
+}
+/** Diff JSON values with strict runtime JSON validation enabled by default. */
+function diffSafeJsonPatch(base, next, options = {}) {
+	return diffJsonPatch(base, next, {
+		...options,
+		jsonValidation: "strict"
+	});
+}
+/** Create a state with normalizing runtime JSON validation enabled by default. */
+function createNormalizedState(initial, options) {
+	return createState(initial, {
+		...options,
+		jsonValidation: "normalize"
+	});
+}
+/** Apply a patch with normalizing runtime JSON validation enabled by default. */
+function applyNormalizedPatch(state, patch, options = {}) {
+	return applyPatch(state, patch, {
+		...options,
+		jsonValidation: "normalize"
+	});
+}
+/** Diff JSON values with normalizing runtime JSON validation enabled by default. */
+function diffNormalizedJsonPatch(base, next, options = {}) {
+	return diffJsonPatch(base, next, {
+		...options,
+		jsonValidation: "normalize"
+	});
+}
+
+//#endregion
+//#region src/options.ts
+/** Options that reject legacy missing-parent array auto-creation. */
+const strictRfc6902PatchOptions = { strictParents: true };
+function withStrictRfc6902Parents(options) {
+	return {
+		...options,
+		strictParents: true
+	};
+}
+function withLegacyMissingArrayParents(options) {
+	return {
+		...options,
+		strictParents: false
+	};
+}
+
 //#endregion
 //#region src/serialize.ts
 const HEAD_ELEM_ID = "HEAD";
@@ -4068,17 +4358,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);
@@ -4089,6 +4386,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 {
@@ -4106,26 +4417,33 @@ function serializeState(state) {
 * May throw `TraversalDepthError` when the payload exceeds the maximum
 * supported nesting depth.
 */
-function deserializeState(data) {
-	const raw = readSerializedStateEnvelope(data);
-	if (!("doc" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/doc", "serialized state is missing doc");
-	if (!("clock" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/clock", "serialized state is missing clock");
-	const clockRaw = asRecord(raw.clock, "/clock");
-	const actor = readActor(clockRaw.actor, "/clock/actor");
-	const ctr = readCounter(clockRaw.ctr, "/clock/ctr");
-	const doc = deserializeDoc(raw.doc);
-	const observedCtr = observedVersionVector(doc)[actor] ?? 0;
-	return {
-		doc,
-		clock: createClock(actor, Math.max(ctr, observedCtr))
-	};
+function deserializeState(data, options = {}) {
+	try {
+		const raw = readSerializedStateEnvelope(data);
+		const budgetMeter = createBudgetMeter(options.resourceBudget);
+		throwIfAborted(options.signal);
+		if (!("doc" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/doc", "serialized state is missing doc");
+		if (!("clock" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/clock", "serialized state is missing clock");
+		const clockRaw = asRecord(raw.clock, "/clock");
+		const actor = readActor(clockRaw.actor, "/clock/actor");
+		const ctr = readCounter(clockRaw.ctr, "/clock/ctr");
+		const doc = deserializeDocInternal(raw.doc, budgetMeter, options.signal);
+		const observedCtr = readCachedObservedVersionVector(doc)?.[actor] ?? 0;
+		return {
+			doc,
+			clock: createClock(actor, Math.max(ctr, observedCtr))
+		};
+	} catch (error) {
+		if (error instanceof OperationCancelledError) throw new DeserializeError("OPERATION_CANCELLED", "/", error.message);
+		throw error;
+	}
 }
 /** Non-throwing `deserializeState` variant with typed validation details. */
-function tryDeserializeState(data) {
+function tryDeserializeState(data, options = {}) {
 	try {
 		return {
 			ok: true,
-			state: deserializeState(data)
+			state: deserializeState(data, options)
 		};
 	} catch (error) {
 		const deserializeError = toDeserializeFailure(error);
@@ -4136,6 +4454,28 @@ function tryDeserializeState(data) {
 		throw error;
 	}
 }
+/** Validate a serialized CRDT state without throwing or returning runtime state. */
+function validateSerializedState(data, options = {}) {
+	try {
+		const raw = readSerializedStateEnvelope(data);
+		const budgetMeter = createBudgetMeter(options.resourceBudget);
+		throwIfAborted(options.signal);
+		if (!("doc" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/doc", "serialized state is missing doc");
+		if (!("clock" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/clock", "serialized state is missing clock");
+		const clockRaw = asRecord(raw.clock, "/clock");
+		readActor(clockRaw.actor, "/clock/actor");
+		readCounter(clockRaw.ctr, "/clock/ctr");
+		validateSerializedDocInternal(raw.doc, budgetMeter, options.signal);
+		return { ok: true };
+	} catch (error) {
+		const deserializeError = toDeserializeFailure(error);
+		if (deserializeError) return {
+			ok: false,
+			error: deserializeError
+		};
+		throw error;
+	}
+}
 function serializeNode(node) {
 	if (node.kind === "lww") return {
 		kind: "lww",
@@ -4198,33 +4538,55 @@ function readSerializedStateEnvelope(data) {
 	assertSerializedEnvelopeVersion(raw, "/version", SERIALIZED_STATE_VERSION, "state");
 	return raw;
 }
-function deserializeNode(node, path, depth) {
+function validateSerializedDocInternal(data, budgetMeter, signal) {
+	throwIfAborted(signal);
+	const raw = readSerializedDocEnvelope(data);
+	if (!("root" in raw)) fail("INVALID_SERIALIZED_SHAPE", "/root", "serialized doc is missing root");
+	validateSerializedNode(raw.root, "/root", 0, budgetMeter, signal);
+}
+function deserializeNode(node, path, depth, budgetMeter, observed, signal) {
+	throwIfAborted(signal);
 	assertTraversalDepth(depth);
+	budgetMeter?.count("visitedNodes", 1, path);
 	const raw = asRecord(node, path);
 	const kind = readString(raw.kind, `${path}/kind`);
 	if (kind === "lww") {
 		if (!("value" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/value`, "lww node is missing value");
 		if (!("dot" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/dot`, "lww node is missing dot");
+		const dot = readDot(raw.dot, `${path}/dot`);
+		if (observed) observeVersionVectorDot(observed, dot);
 		return {
 			kind: "lww",
-			value: structuredClone(readJsonValue(raw.value, `${path}/value`, depth + 1)),
-			dot: readDot(raw.dot, `${path}/dot`)
+			value: structuredClone(readJsonValue(raw.value, `${path}/value`, depth + 1, budgetMeter, signal)),
+			dot
 		};
 	}
 	if (kind === "obj") {
 		const entriesRaw = asRecord(raw.entries, `${path}/entries`);
 		const tombstoneRaw = asRecord(raw.tombstone, `${path}/tombstone`);
+		budgetMeter?.count("objectEntries", Object.keys(entriesRaw).length, `${path}/entries`);
+		budgetMeter?.count("serializedElements", Object.keys(entriesRaw).length, `${path}/entries`);
+		budgetMeter?.count("objectEntries", Object.keys(tombstoneRaw).length, `${path}/tombstone`);
+		budgetMeter?.count("serializedElements", Object.keys(tombstoneRaw).length, `${path}/tombstone`);
 		const entries = /* @__PURE__ */ new Map();
 		for (const [k, v] of Object.entries(entriesRaw)) {
+			throwIfAborted(signal);
 			const entryPath = `${path}/entries/${k}`;
 			const entryRaw = asRecord(v, entryPath);
+			const dot = readDot(entryRaw.dot, `${entryPath}/dot`);
+			if (observed) observeVersionVectorDot(observed, dot);
 			entries.set(k, {
-				node: deserializeNode(entryRaw.node, `${entryPath}/node`, depth + 1),
-				dot: readDot(entryRaw.dot, `${entryPath}/dot`)
+				node: deserializeNode(entryRaw.node, `${entryPath}/node`, depth + 1, budgetMeter, observed, signal),
+				dot
 			});
 		}
 		const tombstone = /* @__PURE__ */ new Map();
-		for (const [k, d] of Object.entries(tombstoneRaw)) tombstone.set(k, readDot(d, `${path}/tombstone/${k}`));
+		for (const [k, d] of Object.entries(tombstoneRaw)) {
+			throwIfAborted(signal);
+			const dot = readDot(d, `${path}/tombstone/${k}`);
+			if (observed) observeVersionVectorDot(observed, dot);
+			tombstone.set(k, dot);
+		}
 		return {
 			kind: "obj",
 			entries,
@@ -4233,17 +4595,24 @@ function deserializeNode(node, path, depth) {
 	}
 	if (kind !== "seq") fail("INVALID_SERIALIZED_SHAPE", `${path}/kind`, `unsupported node kind '${kind}'`);
 	const elemsRaw = asRecord(raw.elems, `${path}/elems`);
+	budgetMeter?.count("sequenceElements", Object.keys(elemsRaw).length, `${path}/elems`);
+	budgetMeter?.count("serializedElements", Object.keys(elemsRaw).length, `${path}/elems`);
 	const elems = /* @__PURE__ */ new Map();
 	for (const [id, rawElem] of Object.entries(elemsRaw)) {
+		throwIfAborted(signal);
 		const elemPath = `${path}/elems/${id}`;
 		const elem = asRecord(rawElem, elemPath);
 		const elemId = readString(elem.id, `${elemPath}/id`);
 		if (elemId !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/id`, `sequence element id '${elemId}' does not match key '${id}'`);
 		const prev = readString(elem.prev, `${elemPath}/prev`);
 		const tombstone = readBoolean(elem.tombstone, `${elemPath}/tombstone`);
-		const value = deserializeNode(elem.value, `${elemPath}/value`, depth + 1);
+		const value = deserializeNode(elem.value, `${elemPath}/value`, depth + 1, budgetMeter, observed, signal);
 		const insDot = readDot(elem.insDot, `${elemPath}/insDot`);
 		const delDot = "delDot" in elem && elem.delDot !== void 0 ? readDot(elem.delDot, `${elemPath}/delDot`) : void 0;
+		if (observed) {
+			observeVersionVectorDot(observed, insDot);
+			if (delDot) observeVersionVectorDot(observed, delDot);
+		}
 		if (dotToElemId(insDot) !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/insDot`, "sequence element id must match its insertion dot");
 		if (!tombstone && delDot) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/delDot`, "live sequence elements must not include delete metadata");
 		elems.set(id, {
@@ -4256,6 +4625,7 @@ function deserializeNode(node, path, depth) {
 		});
 	}
 	for (const elem of elems.values()) {
+		throwIfAborted(signal);
 		if (elem.prev === elem.id) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${elem.id}/prev`, "sequence element cannot reference itself as predecessor");
 		if (elem.prev !== HEAD_ELEM_ID && !elems.has(elem.prev)) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${elem.id}/prev`, `sequence predecessor '${elem.prev}' does not exist`);
 	}
@@ -4265,6 +4635,66 @@ function deserializeNode(node, path, depth) {
 		elems
 	};
 }
+function validateSerializedNode(node, path, depth, budgetMeter, signal) {
+	throwIfAborted(signal);
+	assertTraversalDepth(depth);
+	budgetMeter?.count("visitedNodes", 1, path);
+	const raw = asRecord(node, path);
+	const kind = readString(raw.kind, `${path}/kind`);
+	if (kind === "lww") {
+		if (!("value" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/value`, "lww node is missing value");
+		if (!("dot" in raw)) fail("INVALID_SERIALIZED_SHAPE", `${path}/dot`, "lww node is missing dot");
+		readDot(raw.dot, `${path}/dot`);
+		readJsonValue(raw.value, `${path}/value`, depth + 1, budgetMeter, signal);
+		return;
+	}
+	if (kind === "obj") {
+		const entriesRaw = asRecord(raw.entries, `${path}/entries`);
+		const tombstoneRaw = asRecord(raw.tombstone, `${path}/tombstone`);
+		budgetMeter?.count("objectEntries", Object.keys(entriesRaw).length, `${path}/entries`);
+		budgetMeter?.count("serializedElements", Object.keys(entriesRaw).length, `${path}/entries`);
+		budgetMeter?.count("objectEntries", Object.keys(tombstoneRaw).length, `${path}/tombstone`);
+		budgetMeter?.count("serializedElements", Object.keys(tombstoneRaw).length, `${path}/tombstone`);
+		for (const [k, v] of Object.entries(entriesRaw)) {
+			throwIfAborted(signal);
+			const entryPath = `${path}/entries/${k}`;
+			const entryRaw = asRecord(v, entryPath);
+			readDot(entryRaw.dot, `${entryPath}/dot`);
+			validateSerializedNode(entryRaw.node, `${entryPath}/node`, depth + 1, budgetMeter, signal);
+		}
+		for (const [k, d] of Object.entries(tombstoneRaw)) {
+			throwIfAborted(signal);
+			readDot(d, `${path}/tombstone/${k}`);
+		}
+		return;
+	}
+	if (kind !== "seq") fail("INVALID_SERIALIZED_SHAPE", `${path}/kind`, `unsupported node kind '${kind}'`);
+	const elemsRaw = asRecord(raw.elems, `${path}/elems`);
+	budgetMeter?.count("sequenceElements", Object.keys(elemsRaw).length, `${path}/elems`);
+	budgetMeter?.count("serializedElements", Object.keys(elemsRaw).length, `${path}/elems`);
+	const predecessors = /* @__PURE__ */ new Map();
+	for (const [id, rawElem] of Object.entries(elemsRaw)) {
+		throwIfAborted(signal);
+		const elemPath = `${path}/elems/${id}`;
+		const elem = asRecord(rawElem, elemPath);
+		const elemId = readString(elem.id, `${elemPath}/id`);
+		if (elemId !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/id`, `sequence element id '${elemId}' does not match key '${id}'`);
+		const prev = readString(elem.prev, `${elemPath}/prev`);
+		const tombstone = readBoolean(elem.tombstone, `${elemPath}/tombstone`);
+		validateSerializedNode(elem.value, `${elemPath}/value`, depth + 1, budgetMeter, signal);
+		const insDot = readDot(elem.insDot, `${elemPath}/insDot`);
+		const delDot = "delDot" in elem && elem.delDot !== void 0 ? readDot(elem.delDot, `${elemPath}/delDot`) : void 0;
+		if (dotToElemId(insDot) !== id) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/insDot`, "sequence element id must match its insertion dot");
+		if (!tombstone && delDot) fail("INVALID_SERIALIZED_INVARIANT", `${elemPath}/delDot`, "live sequence elements must not include delete metadata");
+		predecessors.set(id, prev);
+	}
+	for (const [id, prev] of predecessors) {
+		throwIfAborted(signal);
+		if (prev === id) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${id}/prev`, "sequence element cannot reference itself as predecessor");
+		if (prev !== HEAD_ELEM_ID && !predecessors.has(prev)) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${id}/prev`, `sequence predecessor '${prev}' does not exist`);
+	}
+	assertAcyclicSerializedRgaPredecessors(predecessors, path);
+}
 function assertAcyclicRgaPredecessors(elems, path) {
 	const visitState = /* @__PURE__ */ new Map();
 	for (const startId of elems.keys()) {
@@ -4285,6 +4715,26 @@ function assertAcyclicRgaPredecessors(elems, path) {
 		for (const id of trail) visitState.set(id, 2);
 	}
 }
+function assertAcyclicSerializedRgaPredecessors(predecessors, path) {
+	const visitState = /* @__PURE__ */ new Map();
+	for (const startId of predecessors.keys()) {
+		if (visitState.get(startId) === 2) continue;
+		const trail = [];
+		const trailSet = /* @__PURE__ */ new Set();
+		let currentId = startId;
+		while (currentId) {
+			if (trailSet.has(currentId)) fail("INVALID_SERIALIZED_INVARIANT", `${path}/elems/${currentId}/prev`, `sequence predecessor cycle detected at '${currentId}'`);
+			if (visitState.get(currentId) === 2) break;
+			trail.push(currentId);
+			trailSet.add(currentId);
+			visitState.set(currentId, 1);
+			const prev = predecessors.get(currentId);
+			if (!prev || prev === HEAD_ELEM_ID) break;
+			currentId = prev;
+		}
+		for (const id of trail) visitState.set(id, 2);
+	}
+}
 function asRecord(value, path) {
 	if (!isRecord(value)) fail("INVALID_SERIALIZED_SHAPE", path, "expected object");
 	return value;
@@ -4322,28 +4772,43 @@ function readBoolean(value, path) {
 	if (typeof value !== "boolean") fail("INVALID_SERIALIZED_SHAPE", path, "expected boolean");
 	return value;
 }
-function readJsonValue(value, path, depth) {
-	assertJsonValue(value, path, depth);
+function readJsonValue(value, path, depth, budgetMeter, signal) {
+	assertJsonValue(value, path, depth, budgetMeter, signal);
 	return value;
 }
-function assertJsonValue(value, path, depth) {
+function assertJsonValue(value, path, depth, budgetMeter, signal) {
+	throwIfAborted(signal);
 	assertTraversalDepth(depth);
+	budgetMeter?.count("visitedNodes", 1, path);
 	if (value === null || typeof value === "string" || typeof value === "boolean") return;
 	if (typeof value === "number") {
 		if (!Number.isFinite(value)) fail("INVALID_SERIALIZED_SHAPE", path, "json number must be finite");
 		return;
 	}
 	if (Array.isArray(value)) {
-		for (const [index, item] of value.entries()) assertJsonValue(item, `${path}/${index}`, depth + 1);
+		budgetMeter?.count("sequenceElements", value.length, path);
+		budgetMeter?.count("serializedElements", value.length, path);
+		for (const [index, item] of value.entries()) {
+			throwIfAborted(signal);
+			assertJsonValue(item, `${path}/${index}`, depth + 1, budgetMeter, signal);
+		}
 		return;
 	}
 	if (!isRecord(value)) fail("INVALID_SERIALIZED_SHAPE", path, "expected JSON value");
-	for (const [key, child] of Object.entries(value)) assertJsonValue(child, `${path}/${key}`, depth + 1);
+	const entries = Object.entries(value);
+	budgetMeter?.count("objectEntries", entries.length, path);
+	budgetMeter?.count("serializedElements", entries.length, path);
+	for (const [key, child] of entries) {
+		throwIfAborted(signal);
+		assertJsonValue(child, `${path}/${key}`, depth + 1, budgetMeter, signal);
+	}
 }
 function fail(reason, path, message) {
 	throw new DeserializeError(reason, path, message);
 }
 function toDeserializeFailure(error) {
+	if (error instanceof ResourceBudgetError) return toBudgetDeserializeFailure(error);
+	if (error instanceof OperationCancelledError) return toCancellationDeserializeFailure(error);
 	if (error instanceof DeserializeError || error instanceof TraversalDepthError) return error;
 	return null;
 }
@@ -4365,12 +4830,20 @@ var SharedElementMetadataMismatchError = class extends Error {
 var MergeError = class extends Error {
 	code;
 	reason;
+	budget;
+	limit;
+	actual;
 	path;
 	constructor(error) {
 		super(error.message);
 		this.name = "MergeError";
 		this.code = error.code;
 		this.reason = error.reason;
+		if (error.reason === "RESOURCE_BUDGET_EXCEEDED") {
+			this.budget = error.budget;
+			this.limit = error.limit;
+			this.actual = error.actual;
+		}
 		this.path = error.path;
 	}
 };
@@ -4395,9 +4868,13 @@ function mergeDoc(a, b, options = {}) {
 /** Non-throwing `mergeDoc` variant with structured conflict details. */
 function tryMergeDoc(a, b, options = {}) {
 	try {
-		const config = { unrelatedArrays: resolveUnrelatedArraysStrategy(options) };
+		const config = {
+			unrelatedArrays: resolveUnrelatedArraysStrategy(options),
+			budgetMeter: createBudgetMeter(options.resourceBudget),
+			signal: options.signal
+		};
 		if (config.unrelatedArrays === "reject") {
-			const mismatchPath = findSeqLineageMismatch(a.root, b.root, []);
+			const mismatchPath = findSeqLineageMismatch(a.root, b.root, [], config);
 			if (mismatchPath !== null) return {
 				ok: false,
 				error: {
@@ -4428,6 +4905,14 @@ function tryMergeDoc(a, b, options = {}) {
 			ok: false,
 			error: toDepthApplyError(error)
 		};
+		if (error instanceof ResourceBudgetError) return {
+			ok: false,
+			error: toBudgetApplyError(error)
+		};
+		if (error instanceof OperationCancelledError) return {
+			ok: false,
+			error: toCancellationApplyError(error)
+		};
 		throw error;
 	}
 }
@@ -4453,10 +4938,12 @@ function tryMergeState(a, b, options = {}) {
 		const actor = options.actor ?? a.clock.actor;
 		const config = {
 			actor,
-			unrelatedArrays: resolveUnrelatedArraysStrategy(options)
+			unrelatedArrays: resolveUnrelatedArraysStrategy(options),
+			budgetMeter: createBudgetMeter(options.resourceBudget),
+			signal: options.signal
 		};
 		if (config.unrelatedArrays === "reject") {
-			const mismatchPath = findSeqLineageMismatch(a.doc.root, b.doc.root, []);
+			const mismatchPath = findSeqLineageMismatch(a.doc.root, b.doc.root, [], config);
 			if (mismatchPath !== null) return {
 				ok: false,
 				error: {
@@ -4492,20 +4979,34 @@ function tryMergeState(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;
 	}
 }
-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) {
@@ -4514,22 +5015,28 @@ 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
 				});
 			}
 		}
@@ -4554,7 +5061,7 @@ function maxObservedCtrForActor(docObservedCtr, actor, a, b) {
 	if (b.clock.actor === actor && b.clock.ctr > best) best = b.clock.ctr;
 	return best;
 }
-function repDot(node) {
+function repDot(node, signal) {
 	let best = {
 		actor: "",
 		ctr: 0
@@ -4564,6 +5071,7 @@ function repDot(node) {
 		depth: 0
 	}];
 	while (stack.length > 0) {
+		throwIfAborted(signal);
 		const frame = stack.pop();
 		assertTraversalDepth(frame.depth);
 		switch (frame.node.kind) {
@@ -4595,12 +5103,14 @@ function repDot(node) {
 	return best;
 }
 function mergeNodeAtDepth(a, b, depth, path, config) {
+	throwIfAborted(config.signal);
 	assertTraversalDepth(depth);
+	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), repDot(b)) >= 0) return cloneNodeShallow(a, depth + 1, config.actor);
-	return cloneNodeShallow(b, depth + 1, config.actor);
+	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 {
@@ -4626,7 +5136,9 @@ function mergeObj(a, b, depth, path, config) {
 	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) {
@@ -4642,13 +5154,22 @@ function mergeObj(a, b, depth, path, config) {
 		}
 	}
 	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;
 		let mergedNodeMaxObservedCtr = 0;
 		if (ea && eb) {
-			const mergedNode = mergeNodeAtDepth(ea.node, eb.node, depth + 1, [...path, key], config);
+			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,
@@ -4656,14 +5177,14 @@ function mergeObj(a, b, depth, path, config) {
 			};
 			mergedNodeMaxObservedCtr = mergedNode.maxObservedCtr;
 		} else if (ea) {
-			const cloned = cloneNodeShallow(ea.node, depth + 1, config.actor);
+			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);
+			const cloned = cloneNodeShallow(eb.node, depth + 1, config.actor, config.signal);
 			merged = {
 				node: cloned.node,
 				dot: { ...eb.dot }
@@ -4686,24 +5207,40 @@ function mergeObj(a, b, depth, path, config) {
 }
 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()) if (b.elems.has(id)) {
-			shared = true;
-			break;
+		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);
 		}
-		if (!shared) return cloneNodeShallow(compareDot(repDot(a), repDot(b)) >= 0 ? a : b, depth, config.actor);
 	}
 	const elems = /* @__PURE__ */ new Map();
 	let maxObservedCtr = 0;
 	const allIds = new Set([...a.elems.keys(), ...b.elems.keys()]);
+	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], config);
+			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,
@@ -4715,11 +5252,11 @@ function mergeSeq(a, b, depth, path, config) {
 			});
 			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);
+			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);
+			const cloned = cloneElem(eb, depth + 1, config.actor, config.signal);
 			elems.set(id, cloned.elem);
 			maxObservedCtr = Math.max(maxObservedCtr, cloned.maxObservedCtr);
 		}
@@ -4735,9 +5272,10 @@ function mergeSeq(a, b, depth, path, config) {
 function sameDot(a, b) {
 	return a.actor === b.actor && a.ctr === b.ctr;
 }
-function cloneElem(e, depth, actor) {
+function cloneElem(e, depth, actor, signal) {
+	throwIfAborted(signal);
 	assertTraversalDepth(depth);
-	const value = cloneNodeShallow(e.value, depth + 1, actor);
+	const value = cloneNodeShallow(e.value, depth + 1, actor, signal);
 	return {
 		elem: {
 			id: e.id,
@@ -4755,7 +5293,8 @@ function mergeDeleteDot(a, b) {
 	if (a) return { ...a };
 	if (b) return { ...b };
 }
-function cloneNodeShallow(node, depth, actor) {
+function cloneNodeShallow(node, depth, actor, signal) {
+	throwIfAborted(signal);
 	assertTraversalDepth(depth);
 	switch (node.kind) {
 		case "lww": return {
@@ -4770,7 +5309,8 @@ function cloneNodeShallow(node, depth, actor) {
 			const entries = /* @__PURE__ */ new Map();
 			let maxObservedCtr = 0;
 			for (const [k, v] of node.entries) {
-				const cloned = cloneNodeShallow(v.node, depth + 1, actor);
+				throwIfAborted(signal);
+				const cloned = cloneNodeShallow(v.node, depth + 1, actor, signal);
 				entries.set(k, {
 					node: cloned.node,
 					dot: { ...v.dot }
@@ -4779,6 +5319,7 @@ function cloneNodeShallow(node, depth, actor) {
 			}
 			const tombstone = /* @__PURE__ */ new Map();
 			for (const [k, d] of node.tombstone) {
+				throwIfAborted(signal);
 				tombstone.set(k, { ...d });
 				maxObservedCtr = Math.max(maxObservedCtr, maxObservedCtrForDot(d, actor));
 			}
@@ -4795,7 +5336,8 @@ function cloneNodeShallow(node, depth, actor) {
 			const elems = /* @__PURE__ */ new Map();
 			let maxObservedCtr = 0;
 			for (const [id, e] of node.elems) {
-				const cloned = cloneElem(e, depth + 1, actor);
+				throwIfAborted(signal);
+				const cloned = cloneElem(e, depth + 1, actor, signal);
 				elems.set(id, cloned.elem);
 				maxObservedCtr = Math.max(maxObservedCtr, cloned.maxObservedCtr);
 			}
@@ -4894,4 +5436,4 @@ function compactStateTombstones(state, options) {
 }
 
 //#endregion
-export { materialize as $, crdtToJsonPatch as A, jsonEquals as B, tryApplyPatchAsActor as C, TraversalDepthError as Ct, cloneDoc as D, applyIntentsToCrdt as E, tryJsonPatchToCrdt as F, JsonValueValidationError as G, stableJsonValueKey as H, PatchCompileError as I, newReg as J, lwwSet as K, compileJsonPatchToIntent as L, docFromJsonWithDot as M, jsonPatchToCrdt as N, crdtNodesToJsonPatch as O, jsonPatchToCrdtSafe as P, objSet as Q, diffJsonPatch as R, tryApplyPatch as S, MAX_TRAVERSAL_DEPTH as St, validateJsonPatch as T, stringifyJsonPointer as U, parseJsonPointer as V, ROOT_KEY as W, objCompactTombstones as X, newSeq as Y, objRemove as Z, applyPatchAsActor as _, observeDot as _t, mergeState as a, rgaInsertAfterChecked as at, forkState as b, observedVersionVector as bt, DeserializeError as c, validateRgaSeq as ct, serializeDoc as d, vvHasDot as dt, HEAD as et, serializeState as f, vvMerge as ft, applyPatch as g, nextDotForActor as gt, PatchError as h, createClock as ht, mergeDoc as i, rgaInsertAfter as it, docFromJson as j, crdtToFullReplace as k, deserializeDoc as l, compareDot as lt, tryDeserializeState as m, cloneClock as mt, compactStateTombstones as n, rgaDelete as nt, tryMergeDoc as o, rgaLinearizeIds as ot, tryDeserializeDoc as p, ClockValidationError as pt, newObj as q, MergeError as r, rgaIdAtIndex as rt, tryMergeState as s, rgaPrevForInsertAtIndex as st, compactDocTombstones as t, rgaCompactTombstones as tt, deserializeState as u, dotToElemId as ut, applyPatchInPlace as v, intersectVersionVectors as vt, tryApplyPatchInPlace as w, toJson as x, versionVectorCovers as xt, createState as y, mergeVersionVectors as yt, getAtJson as z };
+export { stableJsonValueKey as $, createState as A, mergeVersionVectors as At, crdtToFullReplace as B, createSafeState as C, vvMerge as Ct, applyPatch as D, nextDotForActor as Dt, PatchError as E, createClock as Et, tryApplyPatchInPlace as F, OperationCancelledError as Ft, jsonPatchToCrdtSafe as G, docFromJson as H, validateJsonPatch as I, ResourceBudgetError as It, compileJsonPatchToIntent as J, tryJsonPatchToCrdt as K, applyIntentsToCrdt as L, toJson as M, versionVectorCovers as Mt, tryApplyPatch as N, MAX_TRAVERSAL_DEPTH as Nt, applyPatchAsActor as O, observeDot as Ot, tryApplyPatchAsActor as P, TraversalDepthError as Pt, parseJsonPointer as Q, cloneDoc as R, createNormalizedState as S, vvHasDot as St, diffSafeJsonPatch as T, cloneClock as Tt, docFromJsonWithDot as U, crdtToJsonPatch as V, jsonPatchToCrdt as W, getAtJson as X, diffJsonPatch as Y, jsonEquals as Z, strictRfc6902PatchOptions as _, rgaLinearizeIds as _t, mergeState as a, newReg as at, applyNormalizedPatch as b, compareDot as bt, DeserializeError as c, objRemove as ct, serializeDoc as d, HEAD as dt, stringifyJsonPointer as et, serializeState as f, rgaCompactTombstones as ft, validateSerializedState as g, rgaInsertAfterChecked as gt, validateSerializedDoc as h, rgaInsertAfter as ht, mergeDoc as i, newObj as it, forkState as j, observedVersionVector as jt, applyPatchInPlace as k, intersectVersionVectors as kt, deserializeDoc as l, objSet as lt, tryDeserializeState as m, rgaIdAtIndex as mt, compactStateTombstones as n, JsonValueValidationError as nt, tryMergeDoc as o, newSeq as ot, tryDeserializeDoc as p, rgaDelete as pt, PatchCompileError as q, MergeError as r, lwwSet as rt, tryMergeState as s, objCompactTombstones as st, compactDocTombstones as t, ROOT_KEY as tt, deserializeState as u, materialize as ut, withLegacyMissingArrayParents as v, rgaPrevForInsertAtIndex as vt, diffNormalizedJsonPatch as w, ClockValidationError as wt, applySafePatch as x, dotToElemId as xt, withStrictRfc6902Parents as y, validateRgaSeq as yt, crdtNodesToJsonPatch as z };