doxum 0.1.40 → 0.1.41

package/dist/advanced.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-8xXf0OKB.cjs");
+const require_transform = require("./transform-D6njdP3k.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });

package/dist/advanced.js

@@ -1,4 +1,4 @@
-import { D as defineProcessor, S as compileProjectionDependencies, _ as assertSynchronous, r as collectionChange, t as createKeyedTransform, w as collectionView } from "./transform--WCn6_v0.js";
+import { D as defineProcessor, S as compileProjectionDependencies, _ as assertSynchronous, r as collectionChange, t as createKeyedTransform, w as collectionView } from "./transform-CKJ1ivhz.js";
 import { n as isPlainObject } from "./record-B2yRhYsc.js";
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-8xXf0OKB.cjs");
+const require_transform = require("./transform-D6njdP3k.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 const require_driver = require("./driver-CN3dGxQI.cjs");
 //#region core/src/schema/model.ts
@@ -652,7 +652,7 @@ function remove$2(session, container, ids) {
 	for (const id of removed) session.writeMember(container, id, void 0, "remove");
 	table.ids = table.ids.filter((id) => !removed.has(id));
 }
-function replace$3(session, container, id, value) {
+function replace$4(session, container, id, value) {
 	const { at, node, value: tableValue } = container;
 	if (node.kind !== "table") return require_driver.fail(at, "invalid-collection", "Expected a table.");
 	const table = tableValue;
@@ -675,7 +675,7 @@ function insert$1(session, container, value, position) {
 	insert$2(items, index(keys$1, position), value);
 	session.invalidate();
 }
-function replace$2(session, container, id, value) {
+function replace$3(session, container, id, value) {
 	const { at, node, value: items } = container;
 	if (node.kind !== "list") return require_driver.fail(at, "invalid-list-key", "Expected a list.");
 	const index = indexedKeys(items, node.keyOf).index(id);
@@ -721,7 +721,7 @@ const insert = (session, container, id, value, position) => {
 	else tree.rootId = id;
 	session.invalidate();
 };
-const replace$1 = (session, container, id, value) => {
+const replace$2 = (session, container, id, value) => {
 	const { at, node: schema, value: tree } = container;
 	const entry = node$1(tree, id);
 	if (!entry) return require_driver.fail(at, "missing-tree-node", "Tree node does not exist.");
@@ -1180,7 +1180,7 @@ const createAccess = (context, initial = []) => {
 			const [valueOrId, value] = args;
 			if (args.length === 1) return replaceCollection(target, node, valueOrId);
 			const writable = writableCollection(target, node);
-			replace$3(context.session, writable, valueOrId, value);
+			replace$4(context.session, writable, valueOrId, value);
 		};
 		return orderedMethod(target, property, node);
 	};
@@ -1197,7 +1197,7 @@ const createAccess = (context, initial = []) => {
 			const [valueOrId, value] = args;
 			if (args.length === 1) return replaceCollection(target, node, valueOrId);
 			const writable = writableCollection(target, node);
-			replace$2(context.session, writable, valueOrId, value);
+			replace$3(context.session, writable, valueOrId, value);
 		};
 		return orderedMethod(target, property, node);
 	};
@@ -1219,7 +1219,7 @@ const createAccess = (context, initial = []) => {
 			const [valueOrId, value] = args;
 			if (args.length === 1) return replaceCollection(target, node, valueOrId);
 			const writable = writableTree(target, node);
-			replace$1(context.session, writable, valueOrId, value);
+			replace$2(context.session, writable, valueOrId, value);
 		};
 		const current = () => collectionValue(target, node);
 		if (property === "rootId") return () => {
@@ -3798,49 +3798,109 @@ const node = (key, value, left, right) => {
 		height: Math.max(height(left), height(right)) + 1
 	});
 };
-const rotateLeft = (current) => {
-	const right = current.right;
-	return node(right.key, right.value, node(current.key, current.value, current.left, right.left), right.right);
-};
-const rotateRight = (current) => {
-	const left = current.left;
-	return node(left.key, left.value, left.left, node(current.key, current.value, left.right, current.right));
-};
-const rebalance = (current) => {
-	const balance = height(current.left) - height(current.right);
-	if (balance > 1) {
-		if (height(current.left.left) < height(current.left.right)) return rotateRight(node(current.key, current.value, rotateLeft(current.left), current.right));
-		return rotateRight(current);
-	}
-	if (balance < -1) {
-		if (height(current.right.right) < height(current.right.left)) return rotateLeft(node(current.key, current.value, current.left, rotateRight(current.right)));
-		return rotateLeft(current);
-	}
-	return current;
-};
-const setNode = (current, key, value) => {
-	if (!current) return node(key, value);
-	if (key === current.key) return node(key, value, current.left, current.right);
-	if (key < current.key) return rebalance(node(current.key, current.value, setNode(current.left, key, value), current.right));
-	return rebalance(node(current.key, current.value, current.left, setNode(current.right, key, value)));
-};
-const minNode = (current) => current.left ? minNode(current.left) : current;
-const removeNode = (current, key) => {
-	if (!current) return void 0;
-	if (key < current.key) return rebalance(node(current.key, current.value, removeNode(current.left, key), current.right));
-	if (key > current.key) return rebalance(node(current.key, current.value, current.left, removeNode(current.right, key)));
+/** Local repair after a join descent or a single deletion (height difference at most two). */
+const balance = (key, value, left, right) => {
+	if (height(left) > height(right) + 1) {
+		const heavy = left;
+		if (height(heavy.left) >= height(heavy.right)) return node(heavy.key, heavy.value, heavy.left, node(key, value, heavy.right, right));
+		const middle = heavy.right;
+		return node(middle.key, middle.value, node(heavy.key, heavy.value, heavy.left, middle.left), node(key, value, middle.right, right));
+	}
+	if (height(right) > height(left) + 1) {
+		const heavy = right;
+		if (height(heavy.right) >= height(heavy.left)) return node(heavy.key, heavy.value, node(key, value, left, heavy.left), heavy.right);
+		const middle = heavy.left;
+		return node(middle.key, middle.value, node(key, value, left, middle.left), node(heavy.key, heavy.value, middle.right, heavy.right));
+	}
+	return node(key, value, left, right);
+};
+/** All left keys precede key, all right keys follow it; heights may differ arbitrarily. */
+const join = (key, value, left, right) => {
+	if (height(left) > height(right) + 1) {
+		require_transform.profile.collectionIndex.visit();
+		return balance(left.key, left.value, left.left, join(key, value, left.right, right));
+	}
+	if (height(right) > height(left) + 1) {
+		require_transform.profile.collectionIndex.visit();
+		return balance(right.key, right.value, join(key, value, left, right.left), right.right);
+	}
+	return node(key, value, left, right);
+};
+const removeMin = (current) => {
+	require_transform.profile.collectionIndex.visit();
 	if (!current.left) return current.right;
-	if (!current.right) return current.left;
-	const next = minNode(current.right);
-	return rebalance(node(next.key, next.value, current.left, removeNode(current.right, next.key)));
+	return balance(current.key, current.value, removeMin(current.left), current.right);
+};
+const concat = (left, right) => {
+	if (!left) return right;
+	if (!right) return left;
+	let first = right;
+	while (first.left) {
+		require_transform.profile.collectionIndex.visit();
+		first = first.left;
+	}
+	return join(first.key, first.value, left, removeMin(right));
+};
+const replace$1 = (current, entry, left, right) => {
+	if (entry && !entry.present) return concat(left, right);
+	const value = entry ? entry.value : current.value;
+	if (left === current.left && right === current.right && Object.is(value, current.value)) return current;
+	return join(current.key, value, left, right);
+};
+const edit = (current, key, entry) => {
+	if (!current) return entry.present ? node(key, entry.value) : void 0;
+	require_transform.profile.collectionIndex.visit();
+	if (key === current.key) return replace$1(current, entry, current.left, current.right);
+	if (key < current.key) {
+		const left = edit(current.left, key, entry);
+		return left === current.left ? current : balance(current.key, current.value, left, current.right);
+	}
+	const right = edit(current.right, key, entry);
+	return right === current.right ? current : balance(current.key, current.value, current.left, right);
+};
+/** Builds a new subtree in linear time, ignoring removals of absent keys. */
+const buildChanges = (keys, changes, start, end) => {
+	let count = 0;
+	for (let i = start; i < end; i++) if (changes.get(keys[i]).present) count++;
+	let cursor = start;
+	const build = (size) => {
+		if (!size) return void 0;
+		const leftSize = size >> 1;
+		const left = build(leftSize);
+		let key;
+		let entry;
+		do {
+			key = keys[cursor++];
+			entry = changes.get(key);
+		} while (!entry.present);
+		return node(key, entry.value, left, build(size - leftSize - 1));
+	};
+	return build(count);
+};
+const applyChanges = (current, keys, changes, start, end) => {
+	if (start === end) return current;
+	if (end - start === 1) return edit(current, keys[start], changes.get(keys[start]));
+	if (!current) return buildChanges(keys, changes, start, end);
+	require_transform.profile.collectionIndex.visit();
+	let low = start;
+	let high = end;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if (keys[middle] < current.key) low = middle + 1;
+		else high = middle;
+	}
+	const matched = low < end && keys[low] === current.key;
+	const left = applyChanges(current.left, keys, changes, start, low);
+	const right = applyChanges(current.right, keys, changes, matched ? low + 1 : low, end);
+	return replace$1(current, matched ? changes.get(current.key) : void 0, left, right);
 };
 const fromSorted = (entries, start = 0, end = entries.length) => {
 	if (start >= end) return void 0;
-	const middle = start + end >> 1;
+	const middle = start + end >>> 1;
 	const [key, value] = entries[middle];
 	return node(key, value, fromSorted(entries, start, middle), fromSorted(entries, middle + 1, end));
 };
-/** Immutable keyed lookup used to keep published collection snapshots durable across revisions. */
+/** Immutable keyed lookup used to keep collection snapshots durable across revisions. */
 var PersistentKeyedIndex = class PersistentKeyedIndex {
 	constructor(root) {
 		this.root = root;
@@ -3848,6 +3908,7 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 	static empty() {
 		return new PersistentKeyedIndex();
 	}
+	/** The input must contain unique keys. Formal collection order is owned separately. */
 	static from(entries) {
 		const sorted = [...entries].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
 		require_transform.profile.collectionIndex.build(sorted.length);
@@ -3868,11 +3929,19 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 		}
 		return false;
 	}
-	set(key, value) {
-		return new PersistentKeyedIndex(setNode(this.root, key, value));
-	}
-	remove(key) {
-		return new PersistentKeyedIndex(removeNode(this.root, key));
+	/** Applies accepted final entry intents together; never calls user equality or changes old roots. */
+	apply(changes) {
+		if (!changes.size) return this;
+		require_transform.profile.collectionIndex.batch(changes.size > 1 ? changes.size : 0);
+		let root;
+		if (changes.size === 1) {
+			const [key, entry] = changes.entries().next().value;
+			root = edit(this.root, key, entry);
+		} else {
+			const keys = [...changes.keys()].sort();
+			root = applyChanges(this.root, keys, changes, 0, keys.length);
+		}
+		return root === this.root ? this : new PersistentKeyedIndex(root);
 	}
 };
 //#endregion
@@ -3910,10 +3979,11 @@ const createCollectionState = (initial) => {
 				values.clear();
 				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
 				if (index) index = PersistentKeyedIndex.from(values);
-			} else for (const [key, entry] of staged) {
-				if (index) index = entry.present ? index.set(key, entry.value) : index.remove(key);
-				if (entry.present) values.set(key, entry.value);
+			} else {
+				const nextIndex = index?.apply(staged);
+				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
 				else values.delete(key);
+				index = nextIndex;
 			}
 			ids = nextIds;
 		},

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as ownProjections, C as snapshotProjectionValues, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform--WCn6_v0.js";
+import { A as ownProjections, C as snapshotProjectionValues, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform-CKJ1ivhz.js";
 import { n as isPlainObject, r as isRecord, t as installOwn } from "./record-B2yRhYsc.js";
 import { c as AddressIndex, d as invalidValue, f as children, g as validate, h as parent, i as contextOf, l as MutationRejected, m as is, o as decodeChanges, p as contains$1, r as bindContext, s as sealChanges, t as assertRuntimeWritable, u as fail } from "./driver-B7RR-VfX.js";
 //#region core/src/schema/model.ts
@@ -651,7 +651,7 @@ function remove$2(session, container, ids) {
 	for (const id of removed) session.writeMember(container, id, void 0, "remove");
 	table.ids = table.ids.filter((id) => !removed.has(id));
 }
-function replace$3(session, container, id, value) {
+function replace$4(session, container, id, value) {
 	const { at, node, value: tableValue } = container;
 	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
 	const table = tableValue;
@@ -674,7 +674,7 @@ function insert$1(session, container, value, position) {
 	insert$2(items, index(keys$1, position), value);
 	session.invalidate();
 }
-function replace$2(session, container, id, value) {
+function replace$3(session, container, id, value) {
 	const { at, node, value: items } = container;
 	if (node.kind !== "list") return fail(at, "invalid-list-key", "Expected a list.");
 	const index = indexedKeys(items, node.keyOf).index(id);
@@ -720,7 +720,7 @@ const insert = (session, container, id, value, position) => {
 	else tree.rootId = id;
 	session.invalidate();
 };
-const replace$1 = (session, container, id, value) => {
+const replace$2 = (session, container, id, value) => {
 	const { at, node: schema, value: tree } = container;
 	const entry = node$1(tree, id);
 	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
@@ -1179,7 +1179,7 @@ const createAccess = (context, initial = []) => {
 			const [valueOrId, value] = args;
 			if (args.length === 1) return replaceCollection(target, node, valueOrId);
 			const writable = writableCollection(target, node);
-			replace$3(context.session, writable, valueOrId, value);
+			replace$4(context.session, writable, valueOrId, value);
 		};
 		return orderedMethod(target, property, node);
 	};
@@ -1196,7 +1196,7 @@ const createAccess = (context, initial = []) => {
 			const [valueOrId, value] = args;
 			if (args.length === 1) return replaceCollection(target, node, valueOrId);
 			const writable = writableCollection(target, node);
-			replace$2(context.session, writable, valueOrId, value);
+			replace$3(context.session, writable, valueOrId, value);
 		};
 		return orderedMethod(target, property, node);
 	};
@@ -1218,7 +1218,7 @@ const createAccess = (context, initial = []) => {
 			const [valueOrId, value] = args;
 			if (args.length === 1) return replaceCollection(target, node, valueOrId);
 			const writable = writableTree(target, node);
-			replace$1(context.session, writable, valueOrId, value);
+			replace$2(context.session, writable, valueOrId, value);
 		};
 		const current = () => collectionValue(target, node);
 		if (property === "rootId") return () => {
@@ -3797,49 +3797,109 @@ const node = (key, value, left, right) => {
 		height: Math.max(height(left), height(right)) + 1
 	});
 };
-const rotateLeft = (current) => {
-	const right = current.right;
-	return node(right.key, right.value, node(current.key, current.value, current.left, right.left), right.right);
-};
-const rotateRight = (current) => {
-	const left = current.left;
-	return node(left.key, left.value, left.left, node(current.key, current.value, left.right, current.right));
-};
-const rebalance = (current) => {
-	const balance = height(current.left) - height(current.right);
-	if (balance > 1) {
-		if (height(current.left.left) < height(current.left.right)) return rotateRight(node(current.key, current.value, rotateLeft(current.left), current.right));
-		return rotateRight(current);
-	}
-	if (balance < -1) {
-		if (height(current.right.right) < height(current.right.left)) return rotateLeft(node(current.key, current.value, current.left, rotateRight(current.right)));
-		return rotateLeft(current);
-	}
-	return current;
-};
-const setNode = (current, key, value) => {
-	if (!current) return node(key, value);
-	if (key === current.key) return node(key, value, current.left, current.right);
-	if (key < current.key) return rebalance(node(current.key, current.value, setNode(current.left, key, value), current.right));
-	return rebalance(node(current.key, current.value, current.left, setNode(current.right, key, value)));
-};
-const minNode = (current) => current.left ? minNode(current.left) : current;
-const removeNode = (current, key) => {
-	if (!current) return void 0;
-	if (key < current.key) return rebalance(node(current.key, current.value, removeNode(current.left, key), current.right));
-	if (key > current.key) return rebalance(node(current.key, current.value, current.left, removeNode(current.right, key)));
+/** Local repair after a join descent or a single deletion (height difference at most two). */
+const balance = (key, value, left, right) => {
+	if (height(left) > height(right) + 1) {
+		const heavy = left;
+		if (height(heavy.left) >= height(heavy.right)) return node(heavy.key, heavy.value, heavy.left, node(key, value, heavy.right, right));
+		const middle = heavy.right;
+		return node(middle.key, middle.value, node(heavy.key, heavy.value, heavy.left, middle.left), node(key, value, middle.right, right));
+	}
+	if (height(right) > height(left) + 1) {
+		const heavy = right;
+		if (height(heavy.right) >= height(heavy.left)) return node(heavy.key, heavy.value, node(key, value, left, heavy.left), heavy.right);
+		const middle = heavy.left;
+		return node(middle.key, middle.value, node(key, value, left, middle.left), node(heavy.key, heavy.value, middle.right, heavy.right));
+	}
+	return node(key, value, left, right);
+};
+/** All left keys precede key, all right keys follow it; heights may differ arbitrarily. */
+const join = (key, value, left, right) => {
+	if (height(left) > height(right) + 1) {
+		profile.collectionIndex.visit();
+		return balance(left.key, left.value, left.left, join(key, value, left.right, right));
+	}
+	if (height(right) > height(left) + 1) {
+		profile.collectionIndex.visit();
+		return balance(right.key, right.value, join(key, value, left, right.left), right.right);
+	}
+	return node(key, value, left, right);
+};
+const removeMin = (current) => {
+	profile.collectionIndex.visit();
 	if (!current.left) return current.right;
-	if (!current.right) return current.left;
-	const next = minNode(current.right);
-	return rebalance(node(next.key, next.value, current.left, removeNode(current.right, next.key)));
+	return balance(current.key, current.value, removeMin(current.left), current.right);
+};
+const concat = (left, right) => {
+	if (!left) return right;
+	if (!right) return left;
+	let first = right;
+	while (first.left) {
+		profile.collectionIndex.visit();
+		first = first.left;
+	}
+	return join(first.key, first.value, left, removeMin(right));
+};
+const replace$1 = (current, entry, left, right) => {
+	if (entry && !entry.present) return concat(left, right);
+	const value = entry ? entry.value : current.value;
+	if (left === current.left && right === current.right && Object.is(value, current.value)) return current;
+	return join(current.key, value, left, right);
+};
+const edit = (current, key, entry) => {
+	if (!current) return entry.present ? node(key, entry.value) : void 0;
+	profile.collectionIndex.visit();
+	if (key === current.key) return replace$1(current, entry, current.left, current.right);
+	if (key < current.key) {
+		const left = edit(current.left, key, entry);
+		return left === current.left ? current : balance(current.key, current.value, left, current.right);
+	}
+	const right = edit(current.right, key, entry);
+	return right === current.right ? current : balance(current.key, current.value, current.left, right);
+};
+/** Builds a new subtree in linear time, ignoring removals of absent keys. */
+const buildChanges = (keys, changes, start, end) => {
+	let count = 0;
+	for (let i = start; i < end; i++) if (changes.get(keys[i]).present) count++;
+	let cursor = start;
+	const build = (size) => {
+		if (!size) return void 0;
+		const leftSize = size >> 1;
+		const left = build(leftSize);
+		let key;
+		let entry;
+		do {
+			key = keys[cursor++];
+			entry = changes.get(key);
+		} while (!entry.present);
+		return node(key, entry.value, left, build(size - leftSize - 1));
+	};
+	return build(count);
+};
+const applyChanges = (current, keys, changes, start, end) => {
+	if (start === end) return current;
+	if (end - start === 1) return edit(current, keys[start], changes.get(keys[start]));
+	if (!current) return buildChanges(keys, changes, start, end);
+	profile.collectionIndex.visit();
+	let low = start;
+	let high = end;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if (keys[middle] < current.key) low = middle + 1;
+		else high = middle;
+	}
+	const matched = low < end && keys[low] === current.key;
+	const left = applyChanges(current.left, keys, changes, start, low);
+	const right = applyChanges(current.right, keys, changes, matched ? low + 1 : low, end);
+	return replace$1(current, matched ? changes.get(current.key) : void 0, left, right);
 };
 const fromSorted = (entries, start = 0, end = entries.length) => {
 	if (start >= end) return void 0;
-	const middle = start + end >> 1;
+	const middle = start + end >>> 1;
 	const [key, value] = entries[middle];
 	return node(key, value, fromSorted(entries, start, middle), fromSorted(entries, middle + 1, end));
 };
-/** Immutable keyed lookup used to keep published collection snapshots durable across revisions. */
+/** Immutable keyed lookup used to keep collection snapshots durable across revisions. */
 var PersistentKeyedIndex = class PersistentKeyedIndex {
 	constructor(root) {
 		this.root = root;
@@ -3847,6 +3907,7 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 	static empty() {
 		return new PersistentKeyedIndex();
 	}
+	/** The input must contain unique keys. Formal collection order is owned separately. */
 	static from(entries) {
 		const sorted = [...entries].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
 		profile.collectionIndex.build(sorted.length);
@@ -3867,11 +3928,19 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 		}
 		return false;
 	}
-	set(key, value) {
-		return new PersistentKeyedIndex(setNode(this.root, key, value));
-	}
-	remove(key) {
-		return new PersistentKeyedIndex(removeNode(this.root, key));
+	/** Applies accepted final entry intents together; never calls user equality or changes old roots. */
+	apply(changes) {
+		if (!changes.size) return this;
+		profile.collectionIndex.batch(changes.size > 1 ? changes.size : 0);
+		let root;
+		if (changes.size === 1) {
+			const [key, entry] = changes.entries().next().value;
+			root = edit(this.root, key, entry);
+		} else {
+			const keys = [...changes.keys()].sort();
+			root = applyChanges(this.root, keys, changes, 0, keys.length);
+		}
+		return root === this.root ? this : new PersistentKeyedIndex(root);
 	}
 };
 //#endregion
@@ -3909,10 +3978,11 @@ const createCollectionState = (initial) => {
 				values.clear();
 				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
 				if (index) index = PersistentKeyedIndex.from(values);
-			} else for (const [key, entry] of staged) {
-				if (index) index = entry.present ? index.set(key, entry.value) : index.remove(key);
-				if (entry.present) values.set(key, entry.value);
+			} else {
+				const nextIndex = index?.apply(staged);
+				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
 				else values.delete(key);
+				index = nextIndex;
 			}
 			ids = nextIds;
 		},

package/dist/{transform--WCn6_v0.js → transform-CKJ1ivhz.js}

@@ -29,6 +29,8 @@ const profile = {
 		segmentCompared: () => {}
 	},
 	collectionIndex: {
+		batch: (sortedKeys) => {},
+		visit: () => {},
 		node: () => {},
 		build: (items) => {}
 	},

package/dist/{transform-8xXf0OKB.cjs → transform-D6njdP3k.cjs}

@@ -29,6 +29,8 @@ const profile = {
 		segmentCompared: () => {}
 	},
 	collectionIndex: {
+		batch: (sortedKeys) => {},
+		visit: () => {},
 		node: () => {},
 		build: (items) => {}
 	},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doxum",
-  "version": "0.1.40",
+  "version": "0.1.41",
   "private": false,
   "license": "MIT",
   "description": "Doxum is a typed runtime for complex mutable documents.",

package/skills/doxum-runtime/references/invariants.md

@@ -61,6 +61,16 @@ This file is maintainer-only. Application/library consumers should use [Public A
    initialization failure releases already-created projection resources and preserves the
    original error. Document dirty/pending state has one write owner; structural
    materialization only reads it.
+   Collection storage installs an accepted entry batch through one persistent index
+   application. The index owns AVL batch merge/balance; storage owns the current Map
+   and formal ids; output sealing owns equality and publication. Share untouched
+   subtrees and copy the affected path union once for pure value updates. Batch
+   structural changes require height-aware join/concat, not just single-edit repair.
+   Preserve lazy index creation, durable old snapshots, zero index work for pure
+   reorder, and per-install versions for demanded reads inside a Runtime batch.
+   Sorting changed keys is internal lookup work, never formal order. Count node
+   allocations and sorting separately from selector calls; this is not an O(delta)
+   guarantee for all collection maintenance.
 10. Local sync uses Web Lock leadership and contiguous durable sequence. Writes precede
     asynchronous persistence. Version 5 / format 3 rejects old databases without editing
     them. External replace and remote apply are prohibited while attached.