json-patch-to-crdt 0.1.2 → 0.2.0

package/dist/{compact-CkLd4Yh5.js → compact-DrmgKiVW.js}

@@ -1,11 +1,34 @@
 
 //#region src/clock.ts
+var ClockValidationError = class extends TypeError {
+	reason;
+	constructor(reason, message) {
+		super(message);
+		this.name = "ClockValidationError";
+		this.reason = reason;
+	}
+};
+function readVvCounter$1(vv, actor) {
+	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return 0;
+	const counter = vv[actor];
+	return typeof counter === "number" ? counter : 0;
+}
+function writeVvCounter$1(vv, actor, counter) {
+	Object.defineProperty(vv, actor, {
+		configurable: true,
+		enumerable: true,
+		value: counter,
+		writable: true
+	});
+}
 /**
 * Create a new clock for the given actor. Each call to `clock.next()` yields a fresh `Dot`.
 * @param actor - Unique identifier for this peer.
 * @param start - Initial counter value (defaults to 0).
 */
 function createClock(actor, start = 0) {
+	assertActorId(actor);
+	assertCounter(start);
 	const clock = {
 		actor,
 		ctr: start,
@@ -19,6 +42,12 @@ function createClock(actor, start = 0) {
 	};
 	return clock;
 }
+function assertActorId(actor) {
+	if (actor.length === 0) throw new ClockValidationError("INVALID_ACTOR", "actor must not be empty");
+}
+function assertCounter(counter) {
+	if (!Number.isSafeInteger(counter) || counter < 0) throw new ClockValidationError("INVALID_COUNTER", "counter must be a non-negative safe integer");
+}
 /** Create an independent copy of a clock at the same counter position. */
 function cloneClock(clock) {
 	return createClock(clock.actor, clock.ctr);
@@ -28,8 +57,8 @@ function cloneClock(clock) {
 * Useful when a server needs to mint dots for many actors.
 */
 function nextDotForActor(vv, actor) {
-	const ctr = (vv[actor] ?? 0) + 1;
-	vv[actor] = ctr;
+	const ctr = readVvCounter$1(vv, actor) + 1;
+	writeVvCounter$1(vv, actor, ctr);
 	return {
 		actor,
 		ctr
@@ -37,7 +66,7 @@ function nextDotForActor(vv, actor) {
 }
 /** Record an observed dot in a version vector. */
 function observeDot(vv, dot) {
-	if ((vv[dot.actor] ?? 0) < dot.ctr) vv[dot.actor] = dot.ctr;
+	if (readVvCounter$1(vv, dot.actor) < dot.ctr) writeVvCounter$1(vv, dot.actor, dot.ctr);
 }
 
 //#endregion
@@ -69,16 +98,30 @@ function toDepthApplyError(error) {
 
 //#endregion
 //#region src/dot.ts
+function readVvCounter(vv, actor) {
+	if (!Object.prototype.hasOwnProperty.call(vv, actor)) return;
+	const counter = vv[actor];
+	return typeof counter === "number" ? counter : void 0;
+}
+function writeVvCounter(vv, actor, counter) {
+	Object.defineProperty(vv, actor, {
+		configurable: true,
+		enumerable: true,
+		value: counter,
+		writable: true
+	});
+}
 function compareDot(a, b) {
 	if (a.ctr !== b.ctr) return a.ctr - b.ctr;
 	return a.actor < b.actor ? -1 : a.actor > b.actor ? 1 : 0;
 }
 function vvHasDot(vv, d) {
-	return (vv[d.actor] ?? 0) >= d.ctr;
+	return (readVvCounter(vv, d.actor) ?? 0) >= d.ctr;
 }
 function vvMerge(a, b) {
-	const out = { ...a };
-	for (const [actor, ctr] of Object.entries(b)) out[actor] = Math.max(out[actor] ?? 0, ctr);
+	const out = Object.create(null);
+	for (const [actor, ctr] of Object.entries(a)) writeVvCounter(out, actor, ctr);
+	for (const [actor, ctr] of Object.entries(b)) writeVvCounter(out, actor, Math.max(readVvCounter(out, actor) ?? 0, ctr));
 	return out;
 }
 function dotToElemId(d) {
@@ -106,37 +149,43 @@ function rgaChildrenIndex(seq) {
 	for (const arr of idx.values()) arr.sort((a, b) => compareDot(b.insDot, a.insDot));
 	return idx;
 }
-function rgaLinearizeIds(seq) {
-	const ver = getVersion(seq);
-	const cached = linearCache.get(seq);
-	if (cached && cached.version === ver) return cached.ids;
+function rgaCreateLinearCursor(seq) {
 	const idx = rgaChildrenIndex(seq);
-	const out = [];
 	const stack = [];
 	const rootChildren = idx.get(HEAD);
 	if (rootChildren) stack.push({
 		children: rootChildren,
 		index: 0
 	});
-	while (stack.length > 0) {
-		const frame = stack[stack.length - 1];
-		if (frame.index >= frame.children.length) {
-			stack.pop();
-			continue;
+	return { next() {
+		while (stack.length > 0) {
+			const frame = stack[stack.length - 1];
+			if (frame.index >= frame.children.length) {
+				stack.pop();
+				continue;
+			}
+			const child = frame.children[frame.index++];
+			const grandchildren = idx.get(child.id);
+			if (grandchildren) stack.push({
+				children: grandchildren,
+				index: 0
+			});
+			if (!child.tombstone) return child;
 		}
-		const child = frame.children[frame.index++];
-		if (!child.tombstone) out.push(child.id);
-		const grandchildren = idx.get(child.id);
-		if (grandchildren) stack.push({
-			children: grandchildren,
-			index: 0
-		});
-	}
+	} };
+}
+function rgaLinearizeIds(seq) {
+	const ver = getVersion(seq);
+	const cached = linearCache.get(seq);
+	if (cached && cached.version === ver) return [...cached.ids];
+	const out = [];
+	const cursor = rgaCreateLinearCursor(seq);
+	for (let child = cursor.next(); child; child = cursor.next()) out.push(child.id);
 	linearCache.set(seq, {
 		version: ver,
 		ids: out
 	});
-	return out;
+	return [...out];
 }
 function rgaInsertAfter(seq, prev, id, insDot, value) {
 	if (seq.elems.has(id)) return;
@@ -222,70 +271,77 @@ function rgaPrevForInsertAtIndex(seq, index) {
 
 //#endregion
 //#region src/materialize.ts
+function createMaterializedObject() {
+	return Object.create(null);
+}
+function setMaterializedProperty(out, key, value) {
+	Object.defineProperty(out, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
 /** Convert a CRDT node graph into a plain JSON value using an explicit stack. */
 function materialize(node) {
 	if (node.kind === "lww") return node.value;
-	const root = node.kind === "obj" ? {} : [];
+	const root = node.kind === "obj" ? createMaterializedObject() : [];
 	const stack = [];
 	if (node.kind === "obj") stack.push({
 		kind: "obj",
 		depth: 0,
-		entries: Array.from(node.entries.entries(), ([key, value]) => [key, value.node]),
-		index: 0,
+		entries: node.entries.entries(),
 		out: root
 	});
 	else stack.push({
 		kind: "seq",
 		depth: 0,
-		ids: rgaLinearizeIds(node),
-		index: 0,
-		seq: node,
+		cursor: rgaCreateLinearCursor(node),
 		out: root
 	});
 	while (stack.length > 0) {
 		const frame = stack[stack.length - 1];
 		if (frame.kind === "obj") {
-			if (frame.index >= frame.entries.length) {
+			const nextEntry = frame.entries.next();
+			if (nextEntry.done) {
 				stack.pop();
 				continue;
 			}
-			const [key, child] = frame.entries[frame.index++];
+			const [key, entry] = nextEntry.value;
+			const child = entry.node;
 			const childDepth = frame.depth + 1;
 			assertTraversalDepth(childDepth);
 			if (child.kind === "lww") {
-				frame.out[key] = child.value;
+				setMaterializedProperty(frame.out, key, child.value);
 				continue;
 			}
 			if (child.kind === "obj") {
-				const outObj = {};
-				frame.out[key] = outObj;
+				const outObj = createMaterializedObject();
+				setMaterializedProperty(frame.out, key, outObj);
 				stack.push({
 					kind: "obj",
 					depth: childDepth,
-					entries: Array.from(child.entries.entries(), ([childKey, value]) => [childKey, value.node]),
-					index: 0,
+					entries: child.entries.entries(),
 					out: outObj
 				});
 				continue;
 			}
 			const outArr = [];
-			frame.out[key] = outArr;
+			setMaterializedProperty(frame.out, key, outArr);
 			stack.push({
 				kind: "seq",
 				depth: childDepth,
-				ids: rgaLinearizeIds(child),
-				index: 0,
-				seq: child,
+				cursor: rgaCreateLinearCursor(child),
 				out: outArr
 			});
 			continue;
 		}
-		if (frame.index >= frame.ids.length) {
+		const elem = frame.cursor.next();
+		if (!elem) {
 			stack.pop();
 			continue;
 		}
-		const id = frame.ids[frame.index++];
-		const child = frame.seq.elems.get(id).value;
+		const child = elem.value;
 		const childDepth = frame.depth + 1;
 		assertTraversalDepth(childDepth);
 		if (child.kind === "lww") {
@@ -293,13 +349,12 @@ function materialize(node) {
 			continue;
 		}
 		if (child.kind === "obj") {
-			const outObj = {};
+			const outObj = createMaterializedObject();
 			frame.out.push(outObj);
 			stack.push({
 				kind: "obj",
 				depth: childDepth,
-				entries: Array.from(child.entries.entries(), ([key, value]) => [key, value.node]),
-				index: 0,
+				entries: child.entries.entries(),
 				out: outObj
 			});
 			continue;
@@ -309,9 +364,7 @@ function materialize(node) {
 		stack.push({
 			kind: "seq",
 			depth: childDepth,
-			ids: rgaLinearizeIds(child),
-			index: 0,
-			seq: child,
+			cursor: rgaCreateLinearCursor(child),
 			out: outArr
 		});
 	}
@@ -374,6 +427,155 @@ function objCompactTombstones(obj, isStable) {
 	return removed;
 }
 
+//#endregion
+//#region src/json-value.ts
+/**
+* Runtime validation error for values that are not JSON-compatible.
+* `path` is an RFC 6901 pointer relative to the validated root.
+*/
+var JsonValueValidationError = class extends TypeError {
+	path;
+	detail;
+	constructor(path, detail) {
+		super(`invalid JSON value at ${path === "" ? "<root>" : path}: ${detail}`);
+		this.name = "JsonValueValidationError";
+		this.path = path;
+		this.detail = detail;
+	}
+};
+/** Assert that a runtime value is JSON-compatible (including finite numbers only). */
+function assertRuntimeJsonValue(value) {
+	const stack = [{
+		value,
+		path: "",
+		depth: 0
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (isJsonPrimitive$1(frame.value)) continue;
+		if (Array.isArray(frame.value)) {
+			for (const [index, child] of frame.value.entries()) stack.push({
+				value: child,
+				path: appendPointerSegment(frame.path, String(index)),
+				depth: frame.depth + 1
+			});
+			continue;
+		}
+		if (isJsonObject(frame.value)) {
+			for (const [key, child] of Object.entries(frame.value)) stack.push({
+				value: child,
+				path: appendPointerSegment(frame.path, key),
+				depth: frame.depth + 1
+			});
+			continue;
+		}
+		throw new JsonValueValidationError(frame.path, describeInvalidValue(frame.value));
+	}
+}
+/**
+* Normalize a runtime value to JSON-compatible data.
+* - non-finite numbers -> null
+* - invalid object-property values -> key omitted
+* - invalid root / array values -> null
+*/
+function normalizeRuntimeJsonValue(value) {
+	const rootHolder = {};
+	const stack = [{
+		value,
+		path: "",
+		depth: 0,
+		slot: { kind: "root" }
+	}];
+	while (stack.length > 0) {
+		const frame = stack.pop();
+		assertTraversalDepth(frame.depth);
+		if (isJsonPrimitive$1(frame.value)) {
+			assignSlot(frame.slot, frame.value, rootHolder);
+			continue;
+		}
+		if (Array.isArray(frame.value)) {
+			const out = [];
+			assignSlot(frame.slot, out, rootHolder);
+			for (const [index, child] of frame.value.entries()) stack.push({
+				value: child,
+				path: appendPointerSegment(frame.path, String(index)),
+				depth: frame.depth + 1,
+				slot: {
+					kind: "array",
+					out,
+					index
+				}
+			});
+			continue;
+		}
+		if (isJsonObject(frame.value)) {
+			const out = Object.create(null);
+			assignSlot(frame.slot, out, rootHolder);
+			for (const [key, child] of Object.entries(frame.value)) stack.push({
+				value: child,
+				path: appendPointerSegment(frame.path, key),
+				depth: frame.depth + 1,
+				slot: {
+					kind: "object",
+					out,
+					key
+				}
+			});
+			continue;
+		}
+		if (isNonFiniteNumber(frame.value)) {
+			assignSlot(frame.slot, null, rootHolder);
+			continue;
+		}
+		if (frame.slot.kind !== "object") assignSlot(frame.slot, null, rootHolder);
+	}
+	return rootHolder.value ?? null;
+}
+/** Runtime JSON guardrail helper shared by create/apply/diff paths. */
+function coerceRuntimeJsonValue(value, mode) {
+	if (mode === "none") return value;
+	if (mode === "strict") {
+		assertRuntimeJsonValue(value);
+		return value;
+	}
+	return normalizeRuntimeJsonValue(value);
+}
+function assignSlot(slot, value, rootHolder) {
+	if (slot.kind === "root") {
+		rootHolder.value = value;
+		return;
+	}
+	if (slot.kind === "array") {
+		slot.out[slot.index] = value;
+		return;
+	}
+	slot.out[slot.key] = value;
+}
+function appendPointerSegment(path, segment) {
+	const escaped = segment.replaceAll("~", "~0").replaceAll("/", "~1");
+	if (path === "") return `/${escaped}`;
+	return `${path}/${escaped}`;
+}
+function isJsonPrimitive$1(value) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonFiniteNumber(value) {
+	return typeof value === "number" && !Number.isFinite(value);
+}
+function describeInvalidValue(value) {
+	if (typeof value === "number") return `non-finite number (${String(value)})`;
+	if (value === void 0) return "undefined is not valid JSON";
+	if (typeof value === "bigint") return "bigint is not valid JSON";
+	if (typeof value === "symbol") return "symbol is not valid JSON";
+	if (typeof value === "function") return "function is not valid JSON";
+	return `unsupported value type (${typeof value})`;
+}
+
 //#endregion
 //#region src/types.ts
 /**
@@ -460,8 +662,9 @@ function getAtJson(base, path) {
 		if (idx < 0 || idx >= cur.length) throw new JsonLookupError("INDEX_OUT_OF_BOUNDS", seg, `Index out of bounds at '${seg}'`);
 		cur = cur[idx];
 	} else if (cur && typeof cur === "object") {
-		if (!(seg in cur)) throw new JsonLookupError("MISSING_KEY", seg, `Missing key '${seg}'`);
-		cur = cur[seg];
+		const obj = cur;
+		if (!hasOwn(obj, seg)) throw new JsonLookupError("MISSING_KEY", seg, `Missing key '${seg}'`);
+		cur = obj[seg];
 	} else throw new JsonLookupError("NON_CONTAINER", seg, `Cannot traverse into non-container at '${seg}'`);
 	return cur;
 }
@@ -475,13 +678,14 @@ function getAtJson(base, path) {
 */
 function compileJsonPatchToIntent(baseJson, patch, options = {}) {
 	const semantics = options.semantics ?? "sequential";
-	let workingBase = semantics === "sequential" ? structuredClone(baseJson) : baseJson;
+	let workingBase = baseJson;
+	const pointerCache = /* @__PURE__ */ new Map();
 	const intents = [];
 	for (let opIndex = 0; opIndex < patch.length; opIndex++) {
 		const op = patch[opIndex];
 		const compileBase = semantics === "sequential" ? workingBase : baseJson;
-		intents.push(...compileSingleOp(compileBase, op, opIndex, semantics));
-		if (semantics === "sequential") workingBase = applyPatchOpToJson(workingBase, op, opIndex);
+		intents.push(...compileSingleOp(compileBase, op, opIndex, semantics, pointerCache));
+		if (semantics === "sequential") workingBase = applyPatchOpToJsonWithStructuralSharing(workingBase, op, opIndex, pointerCache);
 	}
 	return intents;
 }
@@ -495,23 +699,22 @@ function compileJsonPatchToIntent(baseJson, patch, options = {}) {
 * @returns An array of JSON Patch operations that transform `base` into `next`.
 */
 function diffJsonPatch(base, next, options = {}) {
+	const runtimeMode = options.jsonValidation ?? "none";
+	const runtimeBase = coerceRuntimeJsonValue(base, runtimeMode);
+	const runtimeNext = coerceRuntimeJsonValue(next, runtimeMode);
 	const ops = [];
-	diffValue([], base, next, ops, options);
+	diffValue([], runtimeBase, runtimeNext, ops, options);
 	return ops;
 }
 function diffValue(path, base, next, ops, options) {
 	if (jsonEquals(base, next)) return;
 	if (Array.isArray(base) || Array.isArray(next)) {
 		if ((options.arrayStrategy ?? "lcs") === "lcs" && Array.isArray(base) && Array.isArray(next)) {
-			if (!shouldUseLcsDiff(base.length, next.length, options.lcsMaxCells)) {
-				ops.push({
-					op: "replace",
-					path: stringifyJsonPointer(path),
-					value: next
-				});
-				return;
-			}
-			diffArray(path, base, next, ops);
+			if (!diffArray(path, base, next, ops, options.lcsMaxCells)) ops.push({
+				op: "replace",
+				path: stringifyJsonPointer(path),
+				value: next
+			});
 			return;
 		}
 		ops.push({
@@ -531,34 +734,114 @@ function diffValue(path, base, next, ops, options) {
 	}
 	const baseKeys = Object.keys(base).sort();
 	const nextKeys = Object.keys(next).sort();
-	const baseSet = new Set(baseKeys);
-	const nextSet = new Set(nextKeys);
-	for (const key of baseKeys) if (!nextSet.has(key)) ops.push({
-		op: "remove",
-		path: stringifyJsonPointer([...path, key])
-	});
-	for (const key of nextKeys) if (!baseSet.has(key)) {
-		const nextValue = next[key];
+	let baseIndex = 0;
+	let nextIndex = 0;
+	while (baseIndex < baseKeys.length && nextIndex < nextKeys.length) {
+		const baseKey = baseKeys[baseIndex];
+		const nextKey = nextKeys[nextIndex];
+		if (baseKey === nextKey) {
+			baseIndex += 1;
+			nextIndex += 1;
+			continue;
+		}
+		if (baseKey < nextKey) {
+			path.push(baseKey);
+			ops.push({
+				op: "remove",
+				path: stringifyJsonPointer(path)
+			});
+			path.pop();
+			baseIndex += 1;
+			continue;
+		}
+		nextIndex += 1;
+	}
+	while (baseIndex < baseKeys.length) {
+		const baseKey = baseKeys[baseIndex];
+		path.push(baseKey);
+		ops.push({
+			op: "remove",
+			path: stringifyJsonPointer(path)
+		});
+		path.pop();
+		baseIndex += 1;
+	}
+	baseIndex = 0;
+	nextIndex = 0;
+	while (baseIndex < baseKeys.length && nextIndex < nextKeys.length) {
+		const baseKey = baseKeys[baseIndex];
+		const nextKey = nextKeys[nextIndex];
+		if (baseKey === nextKey) {
+			baseIndex += 1;
+			nextIndex += 1;
+			continue;
+		}
+		if (baseKey < nextKey) {
+			baseIndex += 1;
+			continue;
+		}
+		path.push(nextKey);
 		ops.push({
 			op: "add",
-			path: stringifyJsonPointer([...path, key]),
-			value: nextValue
+			path: stringifyJsonPointer(path),
+			value: next[nextKey]
 		});
+		path.pop();
+		nextIndex += 1;
 	}
-	for (const key of baseKeys) if (nextSet.has(key)) diffValue([...path, key], base[key], next[key], ops, options);
-}
-function diffArray(path, base, next, ops) {
-	const n = base.length;
-	const m = next.length;
+	while (nextIndex < nextKeys.length) {
+		const nextKey = nextKeys[nextIndex];
+		path.push(nextKey);
+		ops.push({
+			op: "add",
+			path: stringifyJsonPointer(path),
+			value: next[nextKey]
+		});
+		path.pop();
+		nextIndex += 1;
+	}
+	baseIndex = 0;
+	nextIndex = 0;
+	while (baseIndex < baseKeys.length && nextIndex < nextKeys.length) {
+		const baseKey = baseKeys[baseIndex];
+		const nextKey = nextKeys[nextIndex];
+		if (baseKey === nextKey) {
+			path.push(baseKey);
+			diffValue(path, base[baseKey], next[nextKey], ops, options);
+			path.pop();
+			baseIndex += 1;
+			nextIndex += 1;
+			continue;
+		}
+		if (baseKey < nextKey) {
+			baseIndex += 1;
+			continue;
+		}
+		nextIndex += 1;
+	}
+}
+function diffArray(path, base, next, ops, lcsMaxCells) {
+	const baseLength = base.length;
+	const nextLength = next.length;
+	let prefix = 0;
+	while (prefix < baseLength && prefix < nextLength && jsonEquals(base[prefix], next[prefix])) prefix += 1;
+	let suffix = 0;
+	while (suffix < baseLength - prefix && suffix < nextLength - prefix && jsonEquals(base[baseLength - 1 - suffix], next[nextLength - 1 - suffix])) suffix += 1;
+	const baseStart = prefix;
+	const nextStart = prefix;
+	const n = baseLength - prefix - suffix;
+	const m = nextLength - prefix - suffix;
+	if (!shouldUseLcsDiff(n, m, lcsMaxCells)) return false;
+	if (n === 0 && m === 0) return true;
 	const lcs = Array.from({ length: n + 1 }, () => Array(m + 1).fill(0));
-	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) if (jsonEquals(base[i], next[j])) lcs[i][j] = 1 + lcs[i + 1][j + 1];
+	for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) if (jsonEquals(base[baseStart + i], next[nextStart + j])) lcs[i][j] = 1 + lcs[i + 1][j + 1];
 	else lcs[i][j] = Math.max(lcs[i + 1][j], lcs[i][j + 1]);
 	const localOps = [];
 	let i = 0;
 	let j = 0;
-	let index = 0;
+	let index = prefix;
 	while (i < n || j < m) {
-		if (i < n && j < m && jsonEquals(base[i], next[j])) {
+		if (i < n && j < m && jsonEquals(base[baseStart + i], next[nextStart + j])) {
 			i += 1;
 			j += 1;
 			index += 1;
@@ -567,25 +850,32 @@ function diffArray(path, base, next, ops) {
 		const lcsDown = i < n ? lcs[i + 1][j] : -1;
 		const lcsRight = j < m ? lcs[i][j + 1] : -1;
 		if (j < m && (i === n || lcsRight > lcsDown)) {
+			const indexSegment = String(index);
+			path.push(indexSegment);
 			localOps.push({
 				op: "add",
-				path: stringifyJsonPointer([...path, String(index)]),
-				value: next[j]
+				path: stringifyJsonPointer(path),
+				value: next[nextStart + j]
 			});
+			path.pop();
 			j += 1;
 			index += 1;
 			continue;
 		}
 		if (i < n) {
+			const indexSegment = String(index);
+			path.push(indexSegment);
 			localOps.push({
 				op: "remove",
-				path: stringifyJsonPointer([...path, String(index)])
+				path: stringifyJsonPointer(path)
 			});
+			path.pop();
 			i += 1;
 			continue;
 		}
 	}
 	ops.push(...compactArrayOps(localOps));
+	return true;
 }
 function shouldUseLcsDiff(baseLength, nextLength, lcsMaxCells) {
 	if (lcsMaxCells === Number.POSITIVE_INFINITY) return true;
@@ -629,7 +919,7 @@ function jsonEquals(a, b) {
 	const bKeys = Object.keys(b);
 	if (aKeys.length !== bKeys.length) return false;
 	for (const key of aKeys) {
-		if (!(key in b)) return false;
+		if (!hasOwn(b, key)) return false;
 		if (!jsonEquals(a[key], b[key])) return false;
 	}
 	return true;
@@ -641,6 +931,9 @@ const ARRAY_INDEX_TOKEN_PATTERN = /^(0|[1-9][0-9]*)$/;
 function hasOwn(value, key) {
 	return Object.prototype.hasOwnProperty.call(value, key);
 }
+function isUnsafeObjectKey(key) {
+	return key === "__proto__";
+}
 function pathValueAt(base, path) {
 	if (path.length === 0) return base;
 	return getAtJson(base, path);
@@ -648,17 +941,17 @@ function pathValueAt(base, path) {
 function assertNever$1(_value, message) {
 	throw new Error(message);
 }
-function compileSingleOp(baseJson, op, opIndex, semantics) {
+function compileSingleOp(baseJson, op, opIndex, semantics, pointerCache) {
 	if (op.op === "test") return [{
 		t: "Test",
-		path: parsePointerOrThrow(op.path, op.path, opIndex),
+		path: parsePointerOrThrow(op.path, op.path, opIndex, pointerCache),
 		value: op.value
 	}];
 	if (op.op === "copy" || op.op === "move") {
-		const fromPath = parsePointerOrThrow(op.from, op.from, opIndex);
-		const toPath = parsePointerOrThrow(op.path, op.path, opIndex);
+		const fromPath = parsePointerOrThrow(op.from, op.from, opIndex, pointerCache);
+		const toPath = parsePointerOrThrow(op.path, op.path, opIndex, pointerCache);
 		if (op.op === "move" && isStrictDescendantPath(fromPath, toPath)) throw compileError("INVALID_MOVE", `cannot move a value into one of its descendants at ${op.path}`, op.path, opIndex);
-		const val = lookupValueOrThrow(baseJson, fromPath, op.from, opIndex);
+		const val = structuredClone(lookupValueOrThrow(baseJson, fromPath, op.from, opIndex));
 		if (op.op === "move" && isSamePath(fromPath, toPath)) return [];
 		if (op.op === "move" && semantics === "sequential") {
 			const removeOp = {
@@ -670,21 +963,21 @@ function compileSingleOp(baseJson, op, opIndex, semantics) {
 				path: op.path,
 				value: val
 			};
-			const baseAfterRemove = applyPatchOpToJson(baseJson, removeOp, opIndex);
-			return [...compileSingleOp(baseJson, removeOp, opIndex, semantics), ...compileSingleOp(baseAfterRemove, addOp, opIndex, semantics)];
+			const baseAfterRemove = applyPatchOpToJson(baseJson, removeOp, opIndex, pointerCache);
+			return [...compileSingleOp(baseJson, removeOp, opIndex, semantics, pointerCache), ...compileSingleOp(baseAfterRemove, addOp, opIndex, semantics, pointerCache)];
 		}
 		const out = compileSingleOp(baseJson, {
 			op: "add",
 			path: op.path,
 			value: val
-		}, opIndex, semantics);
+		}, opIndex, semantics, pointerCache);
 		if (op.op === "move") out.push(...compileSingleOp(baseJson, {
 			op: "remove",
 			path: op.from
-		}, opIndex, semantics));
+		}, opIndex, semantics, pointerCache));
 		return out;
 	}
-	const path = parsePointerOrThrow(op.path, op.path, opIndex);
+	const path = parsePointerOrThrow(op.path, op.path, opIndex, pointerCache);
 	if (path.length === 0) {
 		if (op.op === "replace" || op.op === "add") return [{
 			t: "ObjSet",
@@ -720,6 +1013,7 @@ function compileSingleOp(baseJson, op, opIndex, semantics) {
 		return assertNever$1(op, "Unsupported op at array path");
 	}
 	if (!isPlainObject(parentValue)) throw compileError("INVALID_TARGET", `expected object or array parent at ${parentPath}`, parentPath, opIndex);
+	if (isUnsafeObjectKey(token)) throw compileError("INVALID_POINTER", `unsafe object key at ${op.path}`, op.path, opIndex);
 	if ((op.op === "replace" || op.op === "remove") && !hasOwn(parentValue, token)) throw compileError("MISSING_TARGET", `missing key ${token} at ${parentPath}`, op.path, opIndex);
 	if (op.op === "add") return [{
 		t: "ObjSet",
@@ -742,57 +1036,91 @@ function compileSingleOp(baseJson, op, opIndex, semantics) {
 	}];
 	return assertNever$1(op, "Unsupported op");
 }
-function applyPatchOpToJson(baseJson, op, opIndex) {
-	let doc = structuredClone(baseJson);
+function applyPatchOpToJson(baseJson, op, opIndex, pointerCache) {
+	return applyPatchOpToJsonWithStructuralSharing(baseJson, op, opIndex, pointerCache);
+}
+function applyPatchOpToJsonWithStructuralSharing(doc, op, opIndex, pointerCache) {
 	if (op.op === "test") return doc;
 	if (op.op === "copy" || op.op === "move") {
-		const fromPath = parsePointerOrThrow(op.from, op.from, opIndex);
+		const fromPath = parsePointerOrThrow(op.from, op.from, opIndex, pointerCache);
 		const value = structuredClone(lookupValueOrThrow(doc, fromPath, op.from, opIndex));
-		if (op.op === "move") doc = applyPatchOpToJson(doc, {
+		return applyPatchOpToJsonWithStructuralSharing(op.op === "move" ? applyPatchOpToJsonWithStructuralSharing(doc, {
 			op: "remove",
 			path: op.from
-		}, opIndex);
-		return applyPatchOpToJson(doc, {
+		}, opIndex, pointerCache) : doc, {
 			op: "add",
 			path: op.path,
 			value
-		}, opIndex);
+		}, opIndex, pointerCache);
 	}
-	const path = parsePointerOrThrow(op.path, op.path, opIndex);
+	const path = parsePointerOrThrow(op.path, op.path, opIndex, pointerCache);
 	if (path.length === 0) {
 		if (op.op === "add" || op.op === "replace") return structuredClone(op.value);
 		throw compileError("INVALID_TARGET", "remove at root path is not supported in RFC-compliant mode", op.path, opIndex);
 	}
 	const parentPath = path.slice(0, -1);
 	const token = path[path.length - 1];
-	let parent;
-	if (parentPath.length === 0) parent = doc;
-	else parent = lookupValueOrThrow(doc, parentPath, op.path, opIndex);
-	if (Array.isArray(parent)) {
-		const index = parseArrayIndexToken(token, op.op, parent.length, op.path, opIndex);
+	const parentValue = parentPath.length === 0 ? doc : lookupValueOrThrow(doc, parentPath, op.path, opIndex);
+	if (Array.isArray(parentValue)) {
+		const index = parseArrayIndexToken(token, op.op, parentValue.length, op.path, opIndex);
+		const { root, parent } = cloneJsonPathToParent(doc, parentPath);
+		const clonedParent = parent;
 		if (op.op === "add") {
-			const insertAt = index === Number.POSITIVE_INFINITY ? parent.length : index;
-			parent.splice(insertAt, 0, structuredClone(op.value));
-			return doc;
+			const insertAt = index === Number.POSITIVE_INFINITY ? clonedParent.length : index;
+			clonedParent.splice(insertAt, 0, structuredClone(op.value));
+			return root;
 		}
 		if (op.op === "replace") {
-			parent[index] = structuredClone(op.value);
-			return doc;
+			clonedParent[index] = structuredClone(op.value);
+			return root;
 		}
-		parent.splice(index, 1);
-		return doc;
+		clonedParent.splice(index, 1);
+		return root;
 	}
-	if (!isPlainObject(parent)) throw compileError("INVALID_TARGET", `expected object or array parent at ${stringifyJsonPointer(parentPath)}`, op.path, opIndex);
+	if (!isPlainObject(parentValue)) throw compileError("INVALID_TARGET", `expected object or array parent at ${stringifyJsonPointer(parentPath)}`, op.path, opIndex);
+	if (isUnsafeObjectKey(token)) throw compileError("INVALID_POINTER", `unsafe object key at ${op.path}`, op.path, opIndex);
+	const { root, parent } = cloneJsonPathToParent(doc, parentPath);
+	const clonedParent = parent;
 	if (op.op === "add" || op.op === "replace") {
-		parent[token] = structuredClone(op.value);
-		return doc;
+		clonedParent[token] = structuredClone(op.value);
+		return root;
 	}
-	delete parent[token];
-	return doc;
+	delete clonedParent[token];
+	return root;
 }
-function parsePointerOrThrow(ptr, path, opIndex) {
+function cloneJsonContainerShallow(value) {
+	if (Array.isArray(value)) return value.slice();
+	if (isPlainObject(value)) return { ...value };
+	throw new Error("Expected JSON container");
+}
+function cloneJsonPathToParent(doc, parentPath) {
+	const root = cloneJsonContainerShallow(doc);
+	if (parentPath.length === 0) return {
+		root,
+		parent: root
+	};
+	let sourceCur = doc;
+	let targetCur = root;
+	for (const segment of parentPath) {
+		const nextSource = Array.isArray(sourceCur) ? sourceCur[Number(segment)] : sourceCur[segment];
+		const nextTarget = cloneJsonContainerShallow(nextSource);
+		if (Array.isArray(targetCur)) targetCur[Number(segment)] = nextTarget;
+		else targetCur[segment] = nextTarget;
+		sourceCur = nextSource;
+		targetCur = nextTarget;
+	}
+	return {
+		root,
+		parent: targetCur
+	};
+}
+function parsePointerOrThrow(ptr, path, opIndex, pointerCache) {
+	const cached = pointerCache.get(ptr);
+	if (cached) return cached.slice();
 	try {
-		return parseJsonPointer(ptr);
+		const parsed = parseJsonPointer(ptr);
+		pointerCache.set(ptr, parsed);
+		return parsed.slice();
 	} catch (error) {
 		throw compileError("INVALID_POINTER", error instanceof Error ? error.message : "invalid pointer", path, opIndex);
 	}
@@ -971,6 +1299,38 @@ function ensureSeqAtPath(head, path, dotForCreate) {
 	if (head.root.kind !== "seq") head.root = newSeq();
 	return head.root;
 }
+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;
+	}
+	return cur;
+}
+function getHeadSeqForBaseArrayIntent(head, path) {
+	const pointer = `/${path.join("/")}`;
+	const headNode = getNodeAtPath(head, path);
+	if (!headNode) return {
+		ok: false,
+		code: 409,
+		reason: "MISSING_PARENT",
+		message: `head array missing at ${pointer}`,
+		path: pointer
+	};
+	if (headNode.kind !== "seq") return {
+		ok: false,
+		code: 409,
+		reason: "INVALID_TARGET",
+		message: `expected array at ${pointer}`,
+		path: pointer
+	};
+	return {
+		ok: true,
+		seq: headNode
+	};
+}
 function deepNodeFromJson(value, dot) {
 	return deepNodeFromJsonWithDepth(value, dot, 0);
 }
@@ -1151,11 +1511,32 @@ function cloneNodeAtDepth(node, depth) {
 function isJsonPrimitive(value) {
 	return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
 }
+function getJsonAtDocPathForTest(doc, path) {
+	let cur = doc.root;
+	for (let i = 0; i < path.length; i++) {
+		const seg = path[i];
+		assertTraversalDepth(i + 1);
+		if (cur.kind === "obj") {
+			const ent = cur.entries.get(seg);
+			if (!ent) throw new Error(`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}'`);
+			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) {
-	const snapshot = evalTestAgainst === "head" ? materialize(head.root) : materialize(base.root);
 	let got;
 	try {
-		got = getAtJson(snapshot, it.path);
+		got = getJsonAtDocPathForTest(evalTestAgainst === "head" ? head : base, it.path);
 	} catch {
 		return {
 			ok: false,
@@ -1220,10 +1601,17 @@ function applyObjRemove(head, it, newDot) {
 	objRemove(parentObj, it.key, d);
 	return null;
 }
-function applyArrInsert(base, head, it, newDot, bumpCounterAbove) {
+function applyArrInsert(base, head, it, newDot, bumpCounterAbove, strictParents = false) {
 	const pointer = `/${it.path.join("/")}`;
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) {
+		if (strictParents) return {
+			ok: false,
+			code: 409,
+			reason: "MISSING_PARENT",
+			message: `base array missing at /${it.path.join("/")}`,
+			path: pointer
+		};
 		if (it.index === 0 || it.index === Number.POSITIVE_INFINITY) {
 			const headSeq = ensureSeqAtPath(head, it.path, newDot());
 			const prev = it.index === 0 ? HEAD : rgaPrevForInsertAtIndex(headSeq, Number.MAX_SAFE_INTEGER);
@@ -1241,7 +1629,10 @@ function applyArrInsert(base, head, it, newDot, bumpCounterAbove) {
 			path: pointer
 		};
 	}
-	const headSeq = ensureSeqAtPath(head, it.path, newDot());
+	newDot();
+	const headSeqRes = getHeadSeqForBaseArrayIntent(head, it.path);
+	if (!headSeqRes.ok) return headSeqRes;
+	const headSeq = headSeqRes.seq;
 	const idx = it.index === Number.POSITIVE_INFINITY ? rgaLinearizeIds(baseSeq).length : it.index;
 	const baseLen = rgaLinearizeIds(baseSeq).length;
 	if (idx < 0 || idx > baseLen) return {
@@ -1286,7 +1677,7 @@ function nextInsertDotForPrev(seq, prev, newDot, path, bumpCounterAbove) {
 	};
 }
 function applyArrDelete(base, head, it, newDot) {
-	const d = newDot();
+	newDot();
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) return {
 		ok: false,
@@ -1295,7 +1686,9 @@ function applyArrDelete(base, head, it, newDot) {
 		message: `base array missing at /${it.path.join("/")}`,
 		path: `/${it.path.join("/")}`
 	};
-	const headSeq = ensureSeqAtPath(head, it.path, d);
+	const headSeqRes = getHeadSeqForBaseArrayIntent(head, it.path);
+	if (!headSeqRes.ok) return headSeqRes;
+	const headSeq = headSeqRes.seq;
 	const baseId = rgaIdAtIndex(baseSeq, it.index);
 	if (!baseId) return {
 		ok: false,
@@ -1304,11 +1697,18 @@ function applyArrDelete(base, head, it, newDot) {
 		message: `no base element at index ${it.index}`,
 		path: `/${it.path.join("/")}/${it.index}`
 	};
+	if (!headSeq.elems.get(baseId)) return {
+		ok: false,
+		code: 409,
+		reason: "MISSING_TARGET",
+		message: `element missing in head lineage at index ${it.index}`,
+		path: `/${it.path.join("/")}/${it.index}`
+	};
 	rgaDelete(headSeq, baseId);
 	return null;
 }
 function applyArrReplace(base, head, it, newDot) {
-	const d = newDot();
+	newDot();
 	const baseSeq = getSeqAtPath(base, it.path);
 	if (!baseSeq) return {
 		ok: false,
@@ -1317,7 +1717,9 @@ function applyArrReplace(base, head, it, newDot) {
 		message: `base array missing at /${it.path.join("/")}`,
 		path: `/${it.path.join("/")}`
 	};
-	const headSeq = ensureSeqAtPath(head, it.path, d);
+	const headSeqRes = getHeadSeqForBaseArrayIntent(head, it.path);
+	if (!headSeqRes.ok) return headSeqRes;
+	const headSeq = headSeqRes.seq;
 	const baseId = rgaIdAtIndex(baseSeq, it.index);
 	if (!baseId) return {
 		ok: false,
@@ -1346,9 +1748,11 @@ function applyArrReplace(base, head, it, newDot) {
 * @param newDot - A function that generates a unique `Dot` per mutation.
 * @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.
 * @returns `{ ok: true }` on success, or `{ ok: false, code: 409, message }` on conflict.
 */
-function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head", bumpCounterAbove) {
+function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head", bumpCounterAbove, options = {}) {
 	for (const it of intents) {
 		let fail = null;
 		switch (it.t) {
@@ -1362,7 +1766,7 @@ function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head
 				fail = applyObjRemove(head, it, newDot);
 				break;
 			case "ArrInsert":
-				fail = applyArrInsert(base, head, it, newDot, bumpCounterAbove);
+				fail = applyArrInsert(base, head, it, newDot, bumpCounterAbove, options.strictParents ?? false);
 				break;
 			case "ArrDelete":
 				fail = applyArrDelete(base, head, it, newDot);
@@ -1376,7 +1780,7 @@ function applyIntentsToCrdt(base, head, intents, newDot, evalTestAgainst = "head
 	}
 	return { ok: true };
 }
-function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove) {
+function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = false) {
 	if (isJsonPatchToCrdtOptions(baseOrOptions)) return jsonPatchToCrdtInternal(baseOrOptions);
 	if (!head || !patch || !newDot) return {
 		ok: false,
@@ -1390,10 +1794,11 @@ function jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst = "
 		patch,
 		newDot,
 		evalTestAgainst,
-		bumpCounterAbove
+		bumpCounterAbove,
+		strictParents
 	});
 }
-function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove) {
+function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst = "head", bumpCounterAbove, strictParents = false) {
 	try {
 		if (isJsonPatchToCrdtOptions(baseOrOptions)) return jsonPatchToCrdt(baseOrOptions);
 		if (!head || !patch || !newDot) return {
@@ -1402,7 +1807,7 @@ function jsonPatchToCrdtSafe(baseOrOptions, head, patch, newDot, evalTestAgainst
 			reason: "INVALID_PATCH",
 			message: "invalid jsonPatchToCrdtSafe call signature"
 		};
-		return jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst, bumpCounterAbove);
+		return jsonPatchToCrdt(baseOrOptions, head, patch, newDot, evalTestAgainst, bumpCounterAbove, strictParents);
 	} catch (error) {
 		return toApplyError$1(error);
 	}
@@ -1440,7 +1845,7 @@ function jsonPatchToCrdtInternal(options) {
 		} catch (error) {
 			return toApplyError$1(error);
 		}
-		return applyIntentsToCrdt(options.base, options.head, intents, options.newDot, evalTestAgainst, options.bumpCounterAbove);
+		return applyIntentsToCrdt(options.base, options.head, intents, options.newDot, evalTestAgainst, options.bumpCounterAbove, { strictParents: options.strictParents });
 	}
 	let shadowBase = cloneDoc(evalTestAgainst === "base" ? options.base : options.head);
 	let shadowCtr = 0;
@@ -1459,10 +1864,10 @@ function jsonPatchToCrdtInternal(options) {
 		} catch (error) {
 			return withOpIndex(toApplyError$1(error), opIndex);
 		}
-		const headStep = applyIntentsToCrdt(shadowBase, options.head, intents, options.newDot, evalTestAgainst, options.bumpCounterAbove);
+		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);
+			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 };
@@ -1566,7 +1971,7 @@ var PatchError = class extends Error {
 function createState(initial, options) {
 	const clock = createClock(options.actor, options.start ?? 0);
 	return {
-		doc: docFromJson(initial, clock.next),
+		doc: docFromJson(coerceRuntimeJsonValue(initial, options.jsonValidation ?? "none"), clock.next),
 		clock
 	};
 }
@@ -1622,7 +2027,7 @@ function tryApplyPatch(state, patch, options = {}) {
 		clock: cloneClock(state.clock)
 	};
 	try {
-		const result = applyPatchInternal(nextState, patch, options);
+		const result = applyPatchInternal(nextState, patch, options, "batch");
 		if (!result.ok) return {
 			ok: false,
 			error: result
@@ -1649,7 +2054,7 @@ function tryApplyPatchInPlace(state, patch, options = {}) {
 		return { ok: true };
 	}
 	try {
-		const result = applyPatchInternal(state, patch, applyOptions);
+		const result = applyPatchInternal(state, patch, applyOptions, "step");
 		if (!result.ok) return {
 			ok: false,
 			error: result
@@ -1667,7 +2072,10 @@ function tryApplyPatchInPlace(state, patch, options = {}) {
 * Does not mutate caller-provided values.
 */
 function validateJsonPatch(base, patch, options = {}) {
-	const result = tryApplyPatch(createState(base, { actor: "__validate__" }), patch, options);
+	const result = tryApplyPatch(createState(base, {
+		actor: "__validate__",
+		jsonValidation: options.jsonValidation
+	}), patch, options);
 	if (!result.ok) return {
 		ok: false,
 		error: result.error
@@ -1679,82 +2087,178 @@ function validateJsonPatch(base, patch, options = {}) {
 * Returns the updated state and a new version vector snapshot.
 */
 function applyPatchAsActor(doc, vv, actor, patch, options = {}) {
+	const result = tryApplyPatchAsActor(doc, vv, actor, patch, options);
+	if (!result.ok) throw new PatchError(result.error);
+	return {
+		state: result.state,
+		vv: result.vv
+	};
+}
+/** Non-throwing `applyPatchAsActor` variant for internals sync flows. */
+function tryApplyPatchAsActor(doc, vv, actor, patch, options = {}) {
 	const observedCtr = maxCtrInNodeForActor$1(doc.root, actor);
-	const state = applyPatch({
+	const applied = tryApplyPatch({
 		doc,
 		clock: createClock(actor, Math.max(vv[actor] ?? 0, observedCtr))
 	}, patch, toApplyPatchOptionsForActor(options));
+	if (!applied.ok) return applied;
+	const nextVv = {
+		...vv,
+		[actor]: Math.max(vv[actor] ?? 0, applied.state.clock.ctr)
+	};
 	return {
-		state,
-		vv: {
-			...vv,
-			[actor]: Math.max(vv[actor] ?? 0, state.clock.ctr)
-		}
+		ok: true,
+		state: applied.state,
+		vv: nextVv
 	};
 }
 function toApplyPatchOptionsForActor(options) {
 	return {
 		semantics: options.semantics,
 		testAgainst: options.testAgainst,
+		strictParents: options.strictParents,
+		jsonValidation: options.jsonValidation,
 		base: options.base ? {
 			doc: options.base,
 			clock: createClock("__base__", 0)
 		} : void 0
 	};
 }
-function applyPatchInternal(state, patch, options) {
+function applyPatchInternal(state, patch, options, execution) {
 	if ((options.semantics ?? "sequential") === "sequential") {
+		if (!options.base && execution === "batch") {
+			const compiled = compileIntents(materialize(state.doc.root), patch, "sequential", options.jsonValidation ?? "none");
+			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;
+		let sequentialHeadJson = materialize(state.doc.root);
+		let sequentialBaseJson = explicitBaseState ? materialize(explicitBaseState.doc.root) : sequentialHeadJson;
 		for (const [opIndex, op] of patch.entries()) {
-			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : state.doc, opIndex);
+			const step = applyPatchOpSequential(state, op, options, explicitBaseState ? explicitBaseState.doc : state.doc, sequentialBaseJson, sequentialHeadJson, explicitBaseState, opIndex);
 			if (!step.ok) return step;
-			if (explicitBaseState && op.op !== "test") {
-				const baseStep = applyPatchInternal(explicitBaseState, [op], {
-					semantics: "sequential",
-					testAgainst: "base"
-				});
-				if (!baseStep.ok) return baseStep;
-			}
+			sequentialBaseJson = step.baseJson;
+			sequentialHeadJson = step.headJson;
 		}
 		return { ok: true };
 	}
 	const baseDoc = options.base ? options.base.doc : cloneDoc(state.doc);
-	const compiled = compileIntents(materialize(baseDoc.root), patch, "base");
+	const compiled = compileIntents(materialize(baseDoc.root), patch, "base", options.jsonValidation ?? "none");
 	if (!compiled.ok) return compiled;
-	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr));
+	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr), { strictParents: options.strictParents });
 }
-function applyPatchOpSequential(state, op, options, baseDoc, opIndex) {
-	const baseJson = materialize(baseDoc.root);
+function applyPatchOpSequential(state, op, options, baseDoc, baseJson, headJson, explicitBaseState, opIndex) {
 	if (op.op === "move") {
 		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
 		if (!fromResolved.ok) return fromResolved;
-		const fromValue = fromResolved.value;
-		const removeRes = applySinglePatchOp(state, baseDoc, baseJson, {
+		const fromValue = structuredClone(fromResolved.value);
+		const removeRes = applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, {
 			op: "remove",
 			path: op.from
-		}, options);
+		}, options, explicitBaseState);
 		if (!removeRes.ok) return removeRes;
-		const addBase = state.doc;
-		return applySinglePatchOp(state, addBase, materialize(addBase.root), {
+		const addOp = {
 			op: "add",
 			path: op.path,
 			value: fromValue
-		}, options);
+		};
+		if (!explicitBaseState) return applySinglePatchOpSequentialStep(state, state.doc, removeRes.baseJson, removeRes.headJson, addOp, options, null);
+		const headAddRes = applySinglePatchOpSequentialStep(state, state.doc, removeRes.headJson, removeRes.headJson, addOp, options, null);
+		if (!headAddRes.ok) return headAddRes;
+		const shadowAddRes = applySinglePatchOpExplicitShadowStep(explicitBaseState, removeRes.baseJson, addOp, options);
+		if (!shadowAddRes.ok) return shadowAddRes;
+		return {
+			ok: true,
+			baseJson: shadowAddRes.baseJson,
+			headJson: headAddRes.headJson
+		};
 	}
 	if (op.op === "copy") {
 		const fromResolved = resolveValueAtPointer(baseJson, op.from, opIndex);
 		if (!fromResolved.ok) return fromResolved;
-		const fromValue = fromResolved.value;
-		return applySinglePatchOp(state, baseDoc, baseJson, {
+		return applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, {
 			op: "add",
 			path: op.path,
-			value: fromValue
-		}, options);
+			value: structuredClone(fromResolved.value)
+		}, options, explicitBaseState);
 	}
-	return applySinglePatchOp(state, baseDoc, baseJson, op, options);
+	return applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, op, options, explicitBaseState);
+}
+function applySinglePatchOpSequentialStep(state, baseDoc, baseJson, headJson, op, options, explicitBaseState) {
+	const compiled = compileIntents(baseJson, [op], "sequential", options.jsonValidation ?? "none");
+	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 (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 (op.op === "test") return {
+		ok: true,
+		baseJson,
+		headJson
+	};
+	const nextBaseJson = applyJsonPatchOpToShadow(baseJson, op);
+	return {
+		ok: true,
+		baseJson: nextBaseJson,
+		headJson: explicitBaseState ? applyJsonPatchOpToShadow(headJson, op) : nextBaseJson
+	};
+}
+function applySinglePatchOpExplicitShadowStep(explicitBaseState, baseJson, op, options) {
+	const compiled = compileIntents(baseJson, [op], "sequential", options.jsonValidation ?? "none");
+	if (!compiled.ok) return compiled;
+	const shadowStep = applyIntentsToCrdt(explicitBaseState.doc, explicitBaseState.doc, compiled.intents, () => explicitBaseState.clock.next(), "base", (ctr) => bumpClockCounter(explicitBaseState, ctr), { strictParents: options.strictParents });
+	if (!shadowStep.ok) return shadowStep;
+	if (op.op === "test") return {
+		ok: true,
+		baseJson
+	};
+	return {
+		ok: true,
+		baseJson: applyJsonPatchOpToShadow(baseJson, op)
+	};
+}
+function applyJsonPatchOpToShadow(baseJson, op) {
+	const path = parseJsonPointer(op.path);
+	if (path.length === 0) {
+		if (op.op === "test") return baseJson;
+		if (op.op === "remove") return null;
+		return structuredClone(op.value);
+	}
+	const parentPath = path.slice(0, -1);
+	const key = path[path.length - 1];
+	const parent = getAtJson(baseJson, parentPath);
+	if (Array.isArray(parent)) {
+		const idx = key === "-" ? parent.length : Number(key);
+		if (!Number.isInteger(idx)) throw new Error(`Invalid array index ${key}`);
+		if (op.op === "add") {
+			parent.splice(idx, 0, structuredClone(op.value));
+			return baseJson;
+		}
+		if (op.op === "remove") {
+			parent.splice(idx, 1);
+			return baseJson;
+		}
+		if (op.op === "replace") {
+			parent[idx] = structuredClone(op.value);
+			return baseJson;
+		}
+		return baseJson;
+	}
+	const obj = parent;
+	if (op.op === "add" || op.op === "replace") {
+		obj[key] = structuredClone(op.value);
+		return baseJson;
+	}
+	if (op.op === "remove") {
+		delete obj[key];
+		return baseJson;
+	}
+	return baseJson;
 }
 function resolveValueAtPointer(baseJson, pointer, opIndex) {
 	let path;
@@ -1772,24 +2276,53 @@ function resolveValueAtPointer(baseJson, pointer, opIndex) {
 		return toPointerLookupApplyError(error, pointer, opIndex);
 	}
 }
-function applySinglePatchOp(state, baseDoc, baseJson, op, options) {
-	const compiled = compileIntents(baseJson, [op], "sequential");
-	if (!compiled.ok) return compiled;
-	return applyIntentsToCrdt(baseDoc, state.doc, compiled.intents, () => state.clock.next(), options.testAgainst ?? "head", (ctr) => bumpClockCounter(state, ctr));
-}
 function bumpClockCounter(state, ctr) {
 	if (state.clock.ctr < ctr) state.clock.ctr = ctr;
 }
-function compileIntents(baseJson, patch, semantics = "sequential") {
+function compileIntents(baseJson, patch, semantics = "sequential", jsonValidation = "none") {
 	try {
 		return {
 			ok: true,
-			intents: compileJsonPatchToIntent(baseJson, patch, { semantics })
+			intents: compileJsonPatchToIntent(baseJson, preparePatchPayloads(patch, jsonValidation), { semantics })
 		};
 	} catch (error) {
 		return toApplyError(error);
 	}
 }
+function preparePatchPayloads(patch, mode) {
+	if (mode === "none") return patch;
+	const out = [];
+	for (const [opIndex, op] of patch.entries()) {
+		if (op.op === "move" || op.op === "copy" || op.op === "remove") {
+			out.push(op);
+			continue;
+		}
+		if (mode === "strict") {
+			try {
+				assertRuntimeJsonValue(op.value);
+			} catch (error) {
+				if (error instanceof JsonValueValidationError) throw patchPayloadCompileError(op, opIndex, error);
+				throw error;
+			}
+			out.push(op);
+			continue;
+		}
+		out.push({
+			...op,
+			value: coerceRuntimeJsonValue(op.value, mode)
+		});
+	}
+	return out;
+}
+function patchPayloadCompileError(op, opIndex, error) {
+	const path = mergePointerPaths(op.path, error.path);
+	return new PatchCompileError("INVALID_PATCH", `invalid JSON value for '${op.op}' at ${path === "" ? "<root>" : path}: ${error.detail}`, path, opIndex);
+}
+function mergePointerPaths(basePointer, nestedPointer) {
+	if (nestedPointer === "") return basePointer;
+	if (basePointer === "") return nestedPointer;
+	return `${basePointer}${nestedPointer}`;
+}
 function maxCtrInNodeForActor$1(node, actor) {
 	let best = 0;
 	const stack = [{
@@ -1866,6 +2399,17 @@ function toPointerLookupApplyError(error, pointer, opIndex) {
 //#endregion
 //#region src/serialize.ts
 const HEAD_ELEM_ID = "HEAD";
+function createSerializedRecord() {
+	return Object.create(null);
+}
+function setSerializedRecordValue(out, key, value) {
+	Object.defineProperty(out, key, {
+		configurable: true,
+		enumerable: true,
+		value,
+		writable: true
+	});
+}
 var DeserializeError = class extends Error {
 	code = 409;
 	reason;
@@ -1887,6 +2431,22 @@ function deserializeDoc(data) {
 	if (!("root" in data)) fail("INVALID_SERIALIZED_SHAPE", "/root", "serialized doc is missing root");
 	return { root: deserializeNode(data.root, "/root", 0) };
 }
+/** Non-throwing `deserializeDoc` variant with typed validation details. */
+function tryDeserializeDoc(data) {
+	try {
+		return {
+			ok: true,
+			doc: deserializeDoc(data)
+		};
+	} 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 {
@@ -1909,6 +2469,22 @@ function deserializeState(data) {
 		clock
 	};
 }
+/** Non-throwing `deserializeState` variant with typed validation details. */
+function tryDeserializeState(data) {
+	try {
+		return {
+			ok: true,
+			state: deserializeState(data)
+		};
+	} 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",
@@ -1919,27 +2495,27 @@ function serializeNode(node) {
 		}
 	};
 	if (node.kind === "obj") {
-		const entries = {};
-		for (const [k, v] of node.entries.entries()) entries[k] = {
+		const entries = createSerializedRecord();
+		for (const [k, v] of node.entries.entries()) setSerializedRecordValue(entries, k, {
 			node: serializeNode(v.node),
 			dot: {
 				actor: v.dot.actor,
 				ctr: v.dot.ctr
 			}
-		};
-		const tombstone = {};
-		for (const [k, d] of node.tombstone.entries()) tombstone[k] = {
+		});
+		const tombstone = createSerializedRecord();
+		for (const [k, d] of node.tombstone.entries()) setSerializedRecordValue(tombstone, k, {
 			actor: d.actor,
 			ctr: d.ctr
-		};
+		});
 		return {
 			kind: "obj",
 			entries,
 			tombstone
 		};
 	}
-	const elems = {};
-	for (const [id, e] of node.elems.entries()) elems[id] = {
+	const elems = createSerializedRecord();
+	for (const [id, e] of node.elems.entries()) setSerializedRecordValue(elems, id, {
 		id: e.id,
 		prev: e.prev,
 		tombstone: e.tombstone,
@@ -1948,7 +2524,7 @@ function serializeNode(node) {
 			actor: e.insDot.actor,
 			ctr: e.insDot.ctr
 		}
-	};
+	});
 	return {
 		kind: "seq",
 		elems
@@ -2012,11 +2588,32 @@ function deserializeNode(node, path, depth) {
 		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`);
 	}
+	assertAcyclicRgaPredecessors(elems, path);
 	return {
 		kind: "seq",
 		elems
 	};
 }
+function assertAcyclicRgaPredecessors(elems, path) {
+	const visitState = /* @__PURE__ */ new Map();
+	for (const startId of elems.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 elem = elems.get(currentId);
+			if (!elem || elem.prev === HEAD_ELEM_ID) break;
+			currentId = elem.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;
@@ -2066,6 +2663,10 @@ function assertJsonValue(value, path, depth) {
 function fail(reason, path, message) {
 	throw new DeserializeError(reason, path, message);
 }
+function toDeserializeFailure(error) {
+	if (error instanceof DeserializeError || error instanceof TraversalDepthError) return error;
+	return null;
+}
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -2498,6 +3099,12 @@ function compactStateTombstones(state, options) {
 }
 
 //#endregion
+Object.defineProperty(exports, 'ClockValidationError', {
+  enumerable: true,
+  get: function () {
+    return ClockValidationError;
+  }
+});
 Object.defineProperty(exports, 'DeserializeError', {
   enumerable: true,
   get: function () {
@@ -2510,6 +3117,12 @@ Object.defineProperty(exports, 'HEAD', {
     return HEAD;
   }
 });
+Object.defineProperty(exports, 'JsonValueValidationError', {
+  enumerable: true,
+  get: function () {
+    return JsonValueValidationError;
+  }
+});
 Object.defineProperty(exports, 'MAX_TRAVERSAL_DEPTH', {
   enumerable: true,
   get: function () {
@@ -2840,12 +3453,30 @@ Object.defineProperty(exports, 'tryApplyPatch', {
     return tryApplyPatch;
   }
 });
+Object.defineProperty(exports, 'tryApplyPatchAsActor', {
+  enumerable: true,
+  get: function () {
+    return tryApplyPatchAsActor;
+  }
+});
 Object.defineProperty(exports, 'tryApplyPatchInPlace', {
   enumerable: true,
   get: function () {
     return tryApplyPatchInPlace;
   }
 });
+Object.defineProperty(exports, 'tryDeserializeDoc', {
+  enumerable: true,
+  get: function () {
+    return tryDeserializeDoc;
+  }
+});
+Object.defineProperty(exports, 'tryDeserializeState', {
+  enumerable: true,
+  get: function () {
+    return tryDeserializeState;
+  }
+});
 Object.defineProperty(exports, 'tryJsonPatchToCrdt', {
   enumerable: true,
   get: function () {