doxum 0.1.21 → 0.1.22

package/dist/index.js

@@ -1,12 +1,10 @@
-import { A as install, B as profile, E as equal, F as matches, L as remove, O as indexedKeys, R as toArray, _ as resolveTreeContainer, a as compiledShape, c as debugKey, d as overlaps, f as read$1, g as resolveLocated, h as resolveContainer, i as AddressIndex, k as insert, l as memberKey, n as fail, o as contains, p as resolveAddress, r as invalidValue, s as createAddressResolver, t as MutationRejected, u as nodeAt, v as resolveValue } from "./issue-W0hT8u8D.js";
-import { a as DocumentReentrancyError, c as createAccess, d as ParseError, f as checkKey, g as parse, h as equalValue, i as DocumentDisposedError, l as replace, m as copyValue, n as bindRuntimeAccess, o as TransactionRejected, p as checkValue, r as readWith, s as collectionAccess, t as accessOf, u as snapshot } from "./access-BeSV5ve-.js";
-import { C as list, D as table, E as optional, O as tree, S as field, T as object, _ as createScheduler, a as observe, b as collectionEntryNode, c as projectionRef, d as createCollectionOutput, f as mapRead, g as assertSynchronous, h as assertScope, i as isProjection, k as variant, l as collectionChangeBetween, m as stageCollectionRead, n as derive, o as ownProjection, p as snapshotCollectionView, r as input, s as producerOf, t as incremental, u as collectionView, v as ProjectionDisposedError, w as map, x as compilePath, y as ProjectionError } from "./advanced-COFJtWMT.js";
-import { a as documentReadableOwner, d as affected, f as belongs, i as disposeNotification, l as subscribeRoot, n as bindDocumentReadable, o as notify, r as createNotification, s as shareNotification, t as attachProjection, u as subscribeTargets } from "./notification-Bkjau6B6.js";
-import { n as bindRuntimeDriver, o as decodeChanges, r as disposeRuntimeDriver, s as sealChanges, t as assertRuntimeWritable } from "./driver-CLYJOGDQ.js";
+import { A as install, B as profile, C as validate, E as equal, F as matches, L as remove, O as indexedKeys, P as listSequence, R as toArray, T as isRecord, _ as resolveTreeContainer, a as compiledShape, c as debugKey, d as overlaps, f as read$1, g as resolveLocated, h as resolveContainer, i as AddressIndex, k as insert, l as memberKey, n as fail, o as contains, p as resolveAddress, r as invalidValue, s as createAddressResolver, t as MutationRejected, u as nodeAt, v as resolveValue } from "./issue-9U6YLYz3.js";
+import { C as equalValue, S as equalTreeNode, _ as checkKey, a as DocumentReentrancyError, b as copyTreeNode, c as replace, d as affected, f as belongs, g as ParseError, h as visitChangedLocations, i as DocumentDisposedError, l as snapshot, n as bindRuntimeAccess, o as TransactionRejected, p as indexedAddress, r as readWith, s as createAccess, t as accessOf, u as SubscriptionIndex, v as checkTreePayload, w as parse, x as copyValue, y as checkValue } from "./access-CZXv_DIF.js";
+import { C as list, D as table, E as optional, O as tree, S as field, T as object, _ as createScheduler, a as observe, b as collectionEntryNode, c as projectionRef, d as createCollectionOutput, f as mapRead, g as assertSynchronous, h as assertScope, i as isProjection, k as variant, l as collectionChangeBetween, m as stageCollectionRead, n as derive, o as ownProjection, p as snapshotCollectionView, r as input, s as producerOf, t as incremental, u as collectionView, v as ProjectionDisposedError, w as map, x as compilePath, y as ProjectionError } from "./advanced-BTStm2cW.js";
+import { n as bindRuntimeDriver, o as decodeChanges, r as disposeRuntimeDriver, s as sealChanges, t as assertRuntimeWritable } from "./driver-BqRjwFmU.js";
+import { a as documentReadableOwner, i as disposeNotification, l as subscribeRoot, n as bindDocumentReadable, o as notify, r as createNotification, s as shareNotification, t as attachProjection, u as subscribeTargets } from "./notification-CrZHVx3a.js";
 //#region core/src/impact.ts
 const queries = /* @__PURE__ */ new WeakMap();
-const affectsTarget = (impact, value) => queries.get(impact).affects(value);
-const collectionImpact = (impact, selector) => queries.get(impact).collection(selector);
 const createImpact = (schema, changes) => {
 	const reset = changes.changes.some((change) => change.kind === "reset");
 	let values;
@@ -16,10 +14,7 @@ const createImpact = (schema, changes) => {
 			profile.impact.index();
 			values = new AddressIndex();
 			orders = new AddressIndex();
-			for (const change of changes.changes) if (change.kind === "members") {
-				for (const member of change.members) values.add(change.at, true, member.key);
-				if (change.order) orders.add(change.at, true);
-			} else if (change.kind === "tree") values.add(change.at, true);
+			visitChangedLocations(changes, (at) => values.add(at, true), (at) => orders.add(at, true));
 		}
 		return values;
 	};
@@ -33,7 +28,7 @@ const createImpact = (schema, changes) => {
 		},
 		collection(selector) {
 			if (selector.schema !== schema) throw new TypeError("Collection belongs to another root model.");
-			const key = JSON.stringify(selector.address), cached = cache.get(key);
+			const key = JSON.stringify(indexedAddress(selector)), cached = cache.get(key);
 			if (cached) return cached;
 			if (reset) {
 				const result = { kind: "reset" };
@@ -41,6 +36,7 @@ const createImpact = (schema, changes) => {
 				return result;
 			}
 			const at = selector.address;
+			const tree = selector.tree;
 			const added = /* @__PURE__ */ new Set(), removed = /* @__PURE__ */ new Set(), updated = /* @__PURE__ */ new Set();
 			let orderChanged = false;
 			for (const change of changes.changes) {
@@ -70,6 +66,12 @@ const createImpact = (schema, changes) => {
 					continue;
 				}
 				if (change.kind === "tree" && contains(change.at, at)) {
+					if (tree?.kind === "nodes" && change.at.length === at.length && contains(at, change.at)) {
+						for (const node of change.nodes) if (node.kind === "added") added.add(node.id);
+						else if (node.kind === "removed") removed.add(node.id);
+						else updated.add(node.id);
+						continue;
+					}
 					const result = { kind: "reset" };
 					cache.set(key, result);
 					return result;
@@ -308,10 +310,6 @@ const forgetMember = (group, key) => {
 	}
 };
 const emptyGroup = (group) => !group.order && (group.layout === "fixed" ? !group.members.some(Boolean) : !group.members?.size);
-const copyNode = (node) => ({
-	...node,
-	children: [...node.children]
-});
 const transition = (node, key, beforePresent, before, afterPresent, after) => {
 	if (beforePresent === afterPresent && (!beforePresent || Object.is(before, after))) return;
 	if (node.kind !== "field" && beforePresent === afterPresent && equalValue(node, before, after)) return;
@@ -402,7 +400,7 @@ const restore = (fact, schema, root, skip = 0) => {
 		const tree = location.value;
 		if (fact.before === null) delete tree.rootId;
 		else tree.rootId = fact.before;
-		for (const [id, node] of fact.nodes) installMember(tree.nodes, id, node !== void 0, node && copyNode(node));
+		for (const [id, node] of fact.nodes) installMember(tree.nodes, id, node !== void 0, node && copyTreeNode(node));
 	}
 	return root;
 };
@@ -441,17 +439,16 @@ const sealMembers = (fact, changes) => {
 const sealTree = (fact, state, changes) => {
 	const location = resolveValue(state.schema, state.document, fact.at);
 	const tree = location?.value;
-	const node = location?.node;
-	if (node?.kind !== "tree") throw new Error("Tree schema disappeared before sealing.");
+	if ((location?.node)?.kind !== "tree") throw new Error("Tree schema disappeared before sealing.");
 	const nodes = [];
 	for (const [id, before] of fact.nodes) {
 		const after = Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
 		if (!before && !after) continue;
-		if (before && after && before.parentId === after.parentId && equal(before.children, after.children) && Object.hasOwn(before, "value") === Object.hasOwn(after, "value") && equalValue(node.value, before.value, after.value)) continue;
+		if (before && after && equalTreeNode(before, after)) continue;
 		nodes.push(!before ? {
 			id,
 			kind: "added",
-			after: copyNode(after)
+			after: copyTreeNode(after)
 		} : !after ? {
 			id,
 			kind: "removed",
@@ -460,7 +457,7 @@ const sealTree = (fact, state, changes) => {
 			id,
 			kind: "updated",
 			before,
-			after: copyNode(after)
+			after: copyTreeNode(after)
 		});
 	}
 	const after = tree.rootId ?? null;
@@ -642,7 +639,7 @@ var ChangeRecorder = class {
 		}
 		if (id !== void 0 && !fact.nodes.has(id)) {
 			profile.recorder("treeNodes");
-			fact.nodes.set(id, Object.hasOwn(tree.nodes, id) ? copyNode(tree.nodes[id]) : void 0);
+			fact.nodes.set(id, Object.hasOwn(tree.nodes, id) ? copyTreeNode(tree.nodes[id]) : void 0);
 		}
 	}
 	rollback() {
@@ -829,12 +826,13 @@ function apply(session, changes, direction) {
 		else current.rootId = root;
 		for (const item of change.nodes) {
 			const next = side === "after" ? item.kind !== "removed" ? item.after : void 0 : item.kind !== "added" ? item.before : void 0;
-			installMember(current.nodes, item.id, next !== void 0, next && {
-				...next,
-				children: [...next.children]
-			});
+			if (next !== void 0) {
+				const issue = checkTreePayload(node.value, next, change.at.concat(item.id));
+				if (issue) invalidValue(issue);
+			}
+			installMember(current.nodes, item.id, next !== void 0, next && copyTreeNode(next));
 		}
-		session.validate(node, current, change.at);
+		if (!validate(current)) return fail(change.at, "invalid-tree", "Invalid tree structure.");
 		session.invalidate();
 	}
 }
@@ -1429,12 +1427,220 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 	});
 };
 //#endregion
+//#region core/src/projection/document-materialization.ts
+const createDocumentDirty = () => ({
+	replace: false,
+	order: false,
+	treeRoot: false,
+	treeNodes: /* @__PURE__ */ new Set(),
+	children: /* @__PURE__ */ new Map()
+});
+const clearDocumentDirty = (dirty) => {
+	dirty.replace = false;
+	dirty.order = false;
+	dirty.treeRoot = false;
+	dirty.treeNodes.clear();
+	dirty.children.clear();
+};
+const hasDocumentDirty = (dirty) => dirty.replace || dirty.order || dirty.treeRoot || dirty.treeNodes.size > 0 || dirty.children.size > 0;
+const locate = (dirty, path) => {
+	let current = dirty;
+	for (const key of path) {
+		if (current.replace) return void 0;
+		let child = current.children.get(key);
+		if (!child) {
+			child = createDocumentDirty();
+			current.children.set(key, child);
+		}
+		current = child;
+	}
+	return current;
+};
+const markDocumentReplace = (dirty, path) => {
+	const current = locate(dirty, path);
+	if (!current) return;
+	current.replace = true;
+	current.order = false;
+	current.treeRoot = false;
+	current.treeNodes.clear();
+	current.children.clear();
+};
+const markDocumentOrder = (dirty, path) => {
+	const current = locate(dirty, path);
+	if (current && !current.replace) current.order = true;
+};
+const markDocumentTree = (dirty, path, root, nodes) => {
+	const current = locate(dirty, path);
+	if (!current || current.replace) return;
+	current.treeRoot ||= root;
+	for (const id of nodes) current.treeNodes.add(id);
+};
+const equivalent = (node, left, right) => node.kind === "field" ? Object.is(left, right) : equalValue(node, left, right);
+const replaceValue = (node, previous, current) => equivalent(node, previous, current) ? previous : copyValue(node, current);
+const cloneRecord = (value) => {
+	profile.copy.shallowRecord(Object.getOwnPropertyNames(value).length);
+	return Object.create(Object.getPrototypeOf(value), Object.getOwnPropertyDescriptors(value));
+};
+const materializeRecordChild = (node, previous, current, key, dirty) => {
+	const before = Object.hasOwn(previous, key);
+	const after = Object.hasOwn(current, key);
+	if (!before && !after) return { changed: false };
+	if (!after) return {
+		changed: true,
+		present: false,
+		value: void 0
+	};
+	const next = before ? materializeDocumentValue(node, previous[key], current[key], dirty) : copyValue(node, current[key]);
+	if (before && next === previous[key]) return { changed: false };
+	return {
+		changed: true,
+		present: true,
+		value: next
+	};
+};
+const materializeObject = (node, previous, current, dirty) => {
+	if (node.kind === "variant" && previous[node.tag] !== current[node.tag]) return replaceValue(node, previous, current);
+	const layout = compiledShape(node, current);
+	if (!layout) return replaceValue(node, previous, current);
+	let result;
+	for (const [key, childDirty] of dirty.children) {
+		const member = layout.members.get(key);
+		if (!member) return replaceValue(node, previous, current);
+		const child = materializeRecordChild(member.node, previous, current, key, childDirty);
+		if (!child.changed) continue;
+		result ??= cloneRecord(previous);
+		installMember(result, key, child.present, child.value);
+	}
+	return result ?? previous;
+};
+const materializeMap = (node, previous, current, dirty) => {
+	let result;
+	for (const [key, childDirty] of dirty.children) {
+		const child = materializeRecordChild(node.value, previous, current, key, childDirty);
+		if (!child.changed) continue;
+		result ??= cloneRecord(previous);
+		installMember(result, key, child.present, child.value);
+	}
+	return result ?? previous;
+};
+const materializeTable = (node, previous, current, dirty) => {
+	if (!isRecord(previous.byId) || !isRecord(current.byId)) return replaceValue(node, previous, current);
+	const beforeById = previous.byId;
+	const afterById = current.byId;
+	let result;
+	let nextById;
+	for (const [key, childDirty] of dirty.children) {
+		const child = materializeRecordChild(node.value, beforeById, afterById, key, childDirty);
+		if (!child.changed) continue;
+		nextById ??= cloneRecord(beforeById);
+		installMember(nextById, key, child.present, child.value);
+	}
+	if (nextById) {
+		result = cloneRecord(previous);
+		installMember(result, "byId", true, nextById);
+	}
+	if (dirty.order) {
+		const beforeIds = previous.ids;
+		const afterIds = current.ids;
+		if (!Array.isArray(beforeIds) || !Array.isArray(afterIds)) return replaceValue(node, previous, current);
+		if (!equal(beforeIds, afterIds)) {
+			result ??= cloneRecord(previous);
+			installMember(result, "ids", true, [...afterIds]);
+		}
+	}
+	return result ?? previous;
+};
+const materializeList = (node, previous, current, dirty) => {
+	if (dirty.order) {
+		const before = listSequence(previous, node.keyOf);
+		const after = listSequence(current, node.keyOf);
+		let changed = !equal(before.order, after.order);
+		const result = new Array(after.order.length);
+		for (let index = 0; index < after.order.length; index++) {
+			const key = after.order[index];
+			const currentValue = after.values.get(key);
+			if (!before.values.has(key)) {
+				changed = true;
+				result[index] = currentValue;
+				continue;
+			}
+			const previousValue = before.values.get(key);
+			const childDirty = dirty.children.get(key);
+			const next = childDirty ? materializeDocumentValue(node.value, previousValue, currentValue, childDirty) : previousValue;
+			changed ||= next !== previousValue;
+			result[index] = next;
+		}
+		return changed ? result : previous;
+	}
+	let result;
+	const before = indexedKeys(previous, node.keyOf);
+	const after = indexedKeys(current, node.keyOf);
+	for (const [key, childDirty] of dirty.children) {
+		const previousIndex = before.index(key);
+		const currentIndex = after.index(key);
+		if (previousIndex < 0 || currentIndex < 0) return replaceValue(node, previous, current);
+		const next = materializeDocumentValue(node.value, previous[previousIndex], current[currentIndex], childDirty);
+		if (next === previous[previousIndex] && previousIndex === currentIndex) continue;
+		result ??= [...previous];
+		result[currentIndex] = next;
+	}
+	return result ?? previous;
+};
+const materializeTree = (node, previous, current, dirty) => {
+	if (!isRecord(previous.nodes) || !isRecord(current.nodes)) return replaceValue(node, previous, current);
+	let result;
+	if (dirty.treeRoot) {
+		const beforePresent = Object.hasOwn(previous, "rootId");
+		const afterPresent = Object.hasOwn(current, "rootId");
+		if (beforePresent !== afterPresent || !Object.is(previous.rootId, current.rootId)) {
+			result = cloneRecord(previous);
+			installMember(result, "rootId", afterPresent, current.rootId);
+		}
+	}
+	let nodes;
+	for (const id of dirty.treeNodes) {
+		const beforePresent = Object.hasOwn(previous.nodes, id);
+		const afterPresent = Object.hasOwn(current.nodes, id);
+		const before = beforePresent ? previous.nodes[id] : void 0;
+		const after = afterPresent ? current.nodes[id] : void 0;
+		if (beforePresent === afterPresent && equalTreeNode(before, after)) continue;
+		nodes ??= cloneRecord(previous.nodes);
+		installMember(nodes, id, afterPresent, after && copyTreeNode(after));
+	}
+	if (nodes) {
+		result ??= cloneRecord(previous);
+		installMember(result, "nodes", true, nodes);
+	}
+	return result ?? previous;
+};
+const materializeDocumentValue = (node, previous, current, dirty) => {
+	if (!hasDocumentDirty(dirty)) return previous;
+	if (dirty.replace || previous === void 0 || current === void 0 || node.kind === "field") return replaceValue(node, previous, current);
+	if (node.kind === "object" || node.kind === "variant") {
+		if (!isRecord(previous) || !isRecord(current)) return replaceValue(node, previous, current);
+		return materializeObject(node, previous, current, dirty);
+	}
+	if (node.kind === "map") {
+		if (!isRecord(previous) || !isRecord(current)) return replaceValue(node, previous, current);
+		return materializeMap(node, previous, current, dirty);
+	}
+	if (node.kind === "table") {
+		if (!isRecord(previous) || !isRecord(current)) return replaceValue(node, previous, current);
+		return materializeTable(node, previous, current, dirty);
+	}
+	if (node.kind === "list") {
+		if (!Array.isArray(previous) || !Array.isArray(current)) return replaceValue(node, previous, current);
+		return materializeList(node, previous, current, dirty);
+	}
+	if (!isRecord(previous) || !isRecord(current)) return replaceValue(node, previous, current);
+	return materializeTree(node, previous, current, dirty);
+};
+//#endregion
 //#region core/src/projection/source.ts
 const sourceError = (source, cause) => new ProjectionError("source", source.name, [source.outputs[0].revision()], cause);
-const createValueBoundary = (scheduler, name, initial, equality) => {
+const createValueBoundary = (scheduler, name, initial, equality, prepare, clearSource) => {
 	const state = createValueOutput();
 	let boundary;
-	let latest = initial;
 	let pendingReset = false;
 	let pendingCause;
 	let contextCause;
@@ -1476,7 +1682,8 @@ const createValueBoundary = (scheduler, name, initial, equality) => {
 			contextCause = cause;
 			let active = true;
 			try {
-				state.begin(() => active, pendingReset).output.set(latest);
+				const evaluation = state.begin(() => active, pendingReset);
+				evaluation.output.set(prepare(evaluation.previous));
 				const changed = state.seal(pendingReset, equality);
 				recovering = false;
 				return {
@@ -1489,11 +1696,13 @@ const createValueBoundary = (scheduler, name, initial, equality) => {
 		},
 		publish: state.publish,
 		clear: () => {
+			const failed = boundary.fault !== void 0;
 			state.clear();
 			pendingReset = false;
 			pendingCause = void 0;
 			contextCause = void 0;
 			recovering = false;
+			clearSource(failed);
 		},
 		release: () => {
 			cleanup?.();
@@ -1529,9 +1738,6 @@ const createValueBoundary = (scheduler, name, initial, equality) => {
 	return {
 		producer: boundary,
 		output,
-		setLatest: (value) => {
-			latest = value;
-		},
 		mark,
 		fail,
 		detach: (next) => {
@@ -1539,7 +1745,7 @@ const createValueBoundary = (scheduler, name, initial, equality) => {
 		}
 	};
 };
-const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
+const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSource) => {
 	const state = createCollectionOutput();
 	let boundary;
 	let pendingReset = false;
@@ -1586,7 +1792,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
 			contextCause = cause;
 			let active = true;
 			try {
-				const changed = stageCollectionRead(state, readLatest(() => active), () => active, {
+				const changed = stageCollectionRead(state, readLatest(() => active, state.current(() => void 0)), () => active, {
 					reset: pendingReset,
 					...fullScan ? {} : { candidates },
 					orderMayChange,
@@ -1603,6 +1809,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
 		},
 		publish: state.publish,
 		clear: () => {
+			const failed = boundary.fault !== void 0;
 			state.clear();
 			pendingReset = false;
 			pendingCause = void 0;
@@ -1611,6 +1818,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
 			fullScan = false;
 			orderMayChange = false;
 			candidates.clear();
+			clearSource(failed);
 		},
 		release: () => {
 			cleanup?.();
@@ -1622,7 +1830,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
 	scheduler.initialize(() => {
 		let active = true;
 		try {
-			stageCollectionRead(state, readLatest(() => active), () => active, {
+			stageCollectionRead(state, readLatest(() => active, state.current(() => void 0)), () => active, {
 				reset: true,
 				isEqual: equality
 			});
@@ -1658,6 +1866,109 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
 		}
 	};
 };
+const documentRootTarget = Object.freeze({
+	kind: "value",
+	at: Object.freeze([])
+});
+const createCollectionPending = () => ({
+	reset: false,
+	order: false,
+	entries: /* @__PURE__ */ new Map()
+});
+const resetCollectionPending = (pending) => {
+	pending.reset = true;
+	pending.order = false;
+	pending.entries.clear();
+};
+const clearCollectionPending = (pending) => {
+	pending.reset = false;
+	pending.order = false;
+	pending.entries.clear();
+};
+const dirtyEntry = (pending, key) => {
+	let dirty = pending.entries.get(key);
+	if (!dirty) {
+		dirty = createDocumentDirty();
+		pending.entries.set(key, dirty);
+	}
+	return dirty;
+};
+const mergeValueChanges = (selector, dirty, changes) => {
+	if (selector.tree) return;
+	const at = selector.address;
+	for (const change of changes.changes) {
+		if (change.kind === "reset") {
+			markDocumentReplace(dirty, []);
+			return;
+		}
+		if (change.kind === "members") {
+			for (const member of change.members) {
+				const changed = [...change.at, member.key];
+				if (contains(changed, at)) markDocumentReplace(dirty, []);
+				else if (contains(at, changed)) markDocumentReplace(dirty, changed.slice(at.length));
+			}
+			if (change.order && contains(at, change.at)) markDocumentOrder(dirty, change.at.slice(at.length));
+			continue;
+		}
+		if (contains(at, change.at)) markDocumentTree(dirty, change.at.slice(at.length), change.before !== change.after, change.nodes.map((node) => node.id));
+	}
+};
+const mergeCollectionChanges = (selector, pending, changes) => {
+	if (pending.reset) return;
+	const at = selector.address;
+	for (const change of changes.changes) {
+		if (change.kind === "reset") {
+			resetCollectionPending(pending);
+			return;
+		}
+		if (selector.tree?.kind === "nodes") {
+			if (change.kind === "members") {
+				for (const member of change.members) if (contains([...change.at, member.key], at)) {
+					resetCollectionPending(pending);
+					return;
+				}
+			} else if (change.at.length === at.length && contains(change.at, at)) for (const node of change.nodes) {
+				markDocumentReplace(dirtyEntry(pending, node.id), []);
+				pending.order ||= node.kind !== "updated";
+			}
+			else if (contains(change.at, at)) {
+				resetCollectionPending(pending);
+				return;
+			}
+			continue;
+		}
+		if (change.kind === "members") {
+			for (const member of change.members) {
+				const changed = [...change.at, member.key];
+				if (contains(changed, at)) {
+					resetCollectionPending(pending);
+					return;
+				}
+				if (!contains(at, changed)) continue;
+				const relative = changed.slice(at.length);
+				if (!relative.length) {
+					resetCollectionPending(pending);
+					return;
+				}
+				markDocumentReplace(dirtyEntry(pending, relative[0]), relative.slice(1));
+				if (relative.length === 1 && member.kind !== "updated") pending.order = true;
+			}
+			if (change.order && contains(at, change.at)) {
+				const relative = change.at.slice(at.length);
+				if (!relative.length) pending.order = true;
+				else markDocumentOrder(dirtyEntry(pending, relative[0]), relative.slice(1));
+			}
+			continue;
+		}
+		if (!contains(at, change.at)) continue;
+		const relative = change.at.slice(at.length);
+		if (!relative.length) {
+			resetCollectionPending(pending);
+			return;
+		}
+		markDocumentTree(dirtyEntry(pending, relative[0]), relative.slice(1), change.before !== change.after, change.nodes.map((node) => node.id));
+	}
+};
 const createSourceRegistry = (scheduler) => {
 	const documents = /* @__PURE__ */ new Map();
 	const readables = /* @__PURE__ */ new Map();
@@ -1669,6 +1980,8 @@ const createSourceRegistry = (scheduler) => {
 		if (cached) return cached;
 		if (state.disposed) throw new Error("Document has been disposed.");
 		const bindings = /* @__PURE__ */ new Set();
+		const index = new SubscriptionIndex(state.schema);
+		const candidates = /* @__PURE__ */ new Set();
 		const guard = (locked) => {
 			state.projectionLocks = (state.projectionLocks ?? 0) + (locked ? 1 : -1);
 		};
@@ -1679,11 +1992,13 @@ const createSourceRegistry = (scheduler) => {
 			add(binding) {
 				if (closed) throw new Error("Document projection connection is closed.");
 				bindings.add(binding);
+				index.add(binding.target, binding);
 				let active = true;
 				return () => {
 					if (!active) return;
 					active = false;
 					bindings.delete(binding);
+					index.delete(binding.target, binding);
 					if (!bindings.size) connection.close();
 				};
 			},
@@ -1692,13 +2007,17 @@ const createSourceRegistry = (scheduler) => {
 				closed = true;
 				detach();
 				bindings.clear();
+				candidates.clear();
+				index.clear();
 				scheduler.guards.delete(guard);
 				documents.delete(state);
 			}
 		};
 		detach = attachProjection(runtime, {
 			capture: (commit) => {
-				for (const binding of bindings) if (binding.matches(commit)) binding.capture(commit);
+				candidates.clear();
+				index.collect(commit.changes, (binding) => candidates.add(binding));
+				candidates.forEach((binding) => binding.capture(commit));
 			},
 			settle: scheduler.settle,
 			flush: scheduler.flush,
@@ -1713,14 +2032,15 @@ const createSourceRegistry = (scheduler) => {
 	const valueInput = (definition) => {
 		if (definition.source.kind !== "value-input") throw new Error("Invalid value input source.");
 		const source = definition.source;
-		const boundary = createValueBoundary(scheduler, "projection input", source.initial, source.equality);
+		let latest = source.initial;
+		const boundary = createValueBoundary(scheduler, "projection input", source.initial, source.equality, () => latest, () => void 0);
 		return {
 			...boundary,
 			write: {
 				kind: "value",
 				set(value) {
 					scheduler.assertIdle();
-					boundary.setLatest(value);
+					latest = value;
 					boundary.mark();
 					scheduler.run();
 				}
@@ -1730,7 +2050,7 @@ const createSourceRegistry = (scheduler) => {
 	const collectionInput = (definition) => {
 		if (definition.source.kind !== "collection-input") throw new Error("Invalid collection input source.");
 		const values = new Map(definition.source.initial);
-		const boundary = createCollectionBoundary(scheduler, "projection collection input", () => mapRead(values), definition.output.equality);
+		const boundary = createCollectionBoundary(scheduler, "projection collection input", () => mapRead(values), definition.output.equality, () => void 0);
 		return {
 			...boundary,
 			write: {
@@ -1806,87 +2126,131 @@ const createSourceRegistry = (scheduler) => {
 			}
 		};
 	};
-	const documentValue = (definition) => {
-		if (definition.source.kind !== "document-value") throw new Error("Invalid document value source.");
+	const documentSource = (definition) => {
+		if (definition.source.kind !== "document") throw new Error("Invalid document source.");
 		const { document, selector } = definition.source;
 		const state = accessOf(document);
-		const address = selector?.address ?? Object.freeze([]);
-		const schemaNode = () => nodeAt(state.schema, address, state.document);
-		const read = () => {
+		const schemaNode = () => nodeAt(state.schema, selector.address, state.document);
+		const currentValue = () => read$1(state.document, selector.address, state.schema);
+		const disposed = () => {
 			if (state.disposed) throw new Error("Document has been disposed.");
-			const node = schemaNode();
-			if (!node) return void 0;
-			return copyValue(node, selector ? read$1(state.document, address, state.schema) : state.document);
 		};
-		const boundary = createValueBoundary(scheduler, "document source", read(), (left, right) => {
-			const node = schemaNode();
-			return node ? equalValue(node, left, right) : Object.is(left, right);
-		});
-		const remove = documentConnection(document).add({
-			matches: (commit) => !selector || affectsTarget(commit.impact, selector),
-			capture: (commit) => {
-				try {
-					boundary.setLatest(read());
-					boundary.mark({ reset: commit.impact.kind === "reset" });
-				} catch (cause) {
-					boundary.fail(cause);
+		if (selector.kind === "value") {
+			const dirty = createDocumentDirty();
+			const read = (previous) => {
+				disposed();
+				const node = schemaNode();
+				const current = currentValue();
+				if (selector.tree?.kind === "root") return node?.kind === "tree" && isRecord(current) && typeof current.rootId === "string" ? current.rootId : void 0;
+				if (selector.tree?.kind === "node") {
+					if (node?.kind !== "tree" || !isRecord(current) || !isRecord(current.nodes)) return void 0;
+					const entry = Object.hasOwn(current.nodes, selector.tree.id) ? current.nodes[selector.tree.id] : void 0;
+					if (equalTreeNode(previous, entry)) return previous;
+					return entry ? copyTreeNode(entry) : void 0;
 				}
-			},
-			dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
-		});
-		boundary.detach(remove);
-		return boundary;
-	};
-	const documentCollection = (definition) => {
-		if (definition.source.kind !== "document-collection") throw new Error("Invalid document collection source.");
-		const { document, selector } = definition.source;
-		const state = accessOf(document);
-		const read = (active) => {
-			if (state.disposed) throw new Error("Document has been disposed.");
-			const raw = collectionAccess({
-				state,
-				active
-			}, selector.address);
+				if (!node) return void 0;
+				return previous === void 0 ? copyValue(node, current) : materializeDocumentValue(node, previous, current, dirty);
+			};
+			const initial = read();
+			let boundary;
+			boundary = createValueBoundary(scheduler, "document source", initial, Object.is, (previous) => read(previous), (failed) => {
+				if (failed) markDocumentReplace(dirty, []);
+				else clearDocumentDirty(dirty);
+			});
+			const remove = documentConnection(document).add({
+				target: selector,
+				capture: (commit) => {
+					try {
+						mergeValueChanges(selector, dirty, commit.changes);
+						boundary.mark({ reset: commit.changes.changes.some((change) => change.kind === "reset") });
+					} catch (cause) {
+						boundary.fail(cause);
+					}
+				},
+				dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
+			});
+			boundary.detach(remove);
+			return boundary;
+		}
+		const pending = createCollectionPending();
+		const read = (active, previous) => {
+			disposed();
+			const node = schemaNode();
+			const value = currentValue();
+			const treeNodes = selector.tree?.kind === "nodes";
+			const entryNode = !treeNodes && node ? collectionEntryNode(node) : void 0;
 			const snapshots = /* @__PURE__ */ new Map();
+			const replacement = createDocumentDirty();
+			if (pending.reset) markDocumentReplace(replacement, []);
+			const ids = () => {
+				assertScope(active);
+				if (treeNodes) return node?.kind === "tree" && isRecord(value) && isRecord(value.nodes) ? Object.freeze(Object.keys(value.nodes)) : Object.freeze([]);
+				if (node?.kind === "map" && isRecord(value)) return Object.freeze(Object.keys(value));
+				if (node?.kind === "table" && isRecord(value) && Array.isArray(value.ids)) return Object.freeze([...value.ids]);
+				if (node?.kind === "list" && Array.isArray(value)) return Object.freeze(toArray(indexedKeys(value, node.keyOf)));
+				return Object.freeze([]);
+			};
+			const has = (key) => {
+				assertScope(active);
+				if (treeNodes) return Boolean(node?.kind === "tree" && isRecord(value) && isRecord(value.nodes) && Object.hasOwn(value.nodes, key));
+				if (node?.kind === "map" && isRecord(value)) return Object.hasOwn(value, key);
+				if (node?.kind === "table" && isRecord(value) && isRecord(value.byId)) return Object.hasOwn(value.byId, key);
+				if (node?.kind === "list" && Array.isArray(value)) return indexedKeys(value, node.keyOf).index(key) >= 0;
+				return false;
+			};
+			const raw = (key) => {
+				if (treeNodes) {
+					if (node?.kind !== "tree" || !isRecord(value) || !isRecord(value.nodes)) return void 0;
+					return Object.hasOwn(value.nodes, key) ? value.nodes[key] : void 0;
+				}
+				if (node?.kind === "map" && isRecord(value)) return Object.hasOwn(value, key) ? value[key] : void 0;
+				if (node?.kind === "table" && isRecord(value) && isRecord(value.byId)) return Object.hasOwn(value.byId, key) ? value.byId[key] : void 0;
+				if (node?.kind === "list" && Array.isArray(value)) {
+					const index = indexedKeys(value, node.keyOf).index(key);
+					return index < 0 ? void 0 : value[index];
+				}
+			};
 			return Object.freeze({
 				get: (key) => {
 					assertScope(active);
-					if (!snapshots.has(key)) snapshots.set(key, snapshot(raw.get(key)));
+					if (!snapshots.has(key)) if (!has(key)) snapshots.set(key, void 0);
+					else {
+						const current = raw(key);
+						if (treeNodes) {
+							const entry = current;
+							const before = previous.has(key) ? previous.get(key) : void 0;
+							snapshots.set(key, equalTreeNode(before, entry) ? before : copyTreeNode(entry));
+						} else if (!entryNode) snapshots.set(key, current);
+						else if (!previous.has(key)) snapshots.set(key, copyValue(entryNode, current));
+						else {
+							const dirty = pending.entries.get(key) ?? (pending.reset ? replacement : void 0);
+							snapshots.set(key, dirty ? materializeDocumentValue(entryNode, previous.get(key), current, dirty) : previous.get(key));
+						}
+					}
 					return snapshots.get(key);
 				},
-				has: (key) => {
-					assertScope(active);
-					return raw.has(key);
-				},
-				ids: () => {
-					assertScope(active);
-					return raw.ids();
-				}
+				has,
+				ids
 			});
 		};
-		const collectionNode = () => nodeAt(state.schema, selector.address, state.document);
-		const boundary = createCollectionBoundary(scheduler, "document collection source", read, (left, right) => {
-			const node = collectionNode();
-			const entry = node && collectionEntryNode(node);
-			return entry ? equalValue(entry, left, right) : Object.is(left, right);
+		let boundary;
+		boundary = createCollectionBoundary(scheduler, "document collection source", read, Object.is, (failed) => {
+			if (failed) resetCollectionPending(pending);
+			else clearCollectionPending(pending);
 		});
 		const remove = documentConnection(document).add({
-			matches: (commit) => affectsTarget(commit.impact, selector),
+			target: selector,
 			capture: (commit) => {
-				const impact = collectionImpact(commit.impact, selector);
-				if (impact.kind === "reset") {
-					boundary.mark({ reset: true });
-					return;
+				try {
+					mergeCollectionChanges(selector, pending, commit.changes);
+					boundary.mark({
+						reset: pending.reset,
+						...pending.reset ? {} : { candidates: pending.entries.keys() },
+						orderMayChange: pending.order
+					});
+				} catch (cause) {
+					boundary.fail(cause);
 				}
-				const candidates = new Set([
-					...impact.added,
-					...impact.updated,
-					...impact.removed
-				]);
-				boundary.mark({
-					candidates,
-					orderMayChange: Boolean(impact.added.size || impact.removed.size || impact.orderChanged)
-				});
 			},
 			dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
 		});
@@ -1896,13 +2260,12 @@ const createSourceRegistry = (scheduler) => {
 	const readable = (definition) => {
 		if (definition.source.kind !== "readable") throw new Error("Invalid Readable source.");
 		const { readable, equality } = definition.source;
-		let initial = readable.current();
-		const boundary = createValueBoundary(scheduler, "external readable", initial, equality);
+		let latest = readable.current();
+		const boundary = createValueBoundary(scheduler, "external readable", latest, equality, () => latest, () => void 0);
 		const member = {
 			boundary,
 			receive(value, metadata) {
-				initial = value;
-				boundary.setLatest(value);
+				latest = value;
 				boundary.mark(metadata);
 			}
 		};
@@ -1934,7 +2297,7 @@ const createSourceRegistry = (scheduler) => {
 			};
 			const owner = documentReadableOwner(readable);
 			if (owner) detachDocument = documentConnection(owner).add({
-				matches: () => true,
+				target: documentRootTarget,
 				capture: () => receive(false),
 				dispose: () => {
 					members.forEach((next) => next.boundary.fail(/* @__PURE__ */ new Error("Document has been disposed.")));
@@ -1954,11 +2317,12 @@ const createSourceRegistry = (scheduler) => {
 	const externalValue = (definition) => {
 		if (definition.source.kind !== "external-value") throw new Error("Invalid external value source.");
 		const { source, equality } = definition.source;
-		const boundary = createValueBoundary(scheduler, "external source", source.current(), equality);
+		let latest = source.current();
+		const boundary = createValueBoundary(scheduler, "external source", latest, equality, () => latest, () => void 0);
 		const member = {
 			boundary,
 			receive(value, metadata) {
-				boundary.setLatest(value);
+				latest = value;
 				boundary.mark(metadata);
 			}
 		};
@@ -2012,7 +2376,7 @@ const createSourceRegistry = (scheduler) => {
 				has: (key) => current.has(key),
 				ids: () => current.ids()
 			});
-		}, definition.output.equality);
+		}, definition.output.equality, () => void 0);
 		let connection = externalCollections.get(source);
 		if (!connection) {
 			const members = /* @__PURE__ */ new Set();
@@ -2075,8 +2439,7 @@ const createSourceRegistry = (scheduler) => {
 			switch (definition.source.kind) {
 				case "value-input": return valueInput(definition);
 				case "collection-input": return collectionInput(definition);
-				case "document-value": return documentValue(definition);
-				case "document-collection": return documentCollection(definition);
+				case "document": return documentSource(definition);
 				case "readable": return readable(definition);
 				case "external-value": return externalValue(definition);
 				case "external-collection": return externalCollection(definition);