doxum 0.1.21 → 0.1.23

package/dist/index.js

@@ -1,12 +1,905 @@
-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 checkValue, B as insert$2, C as optional, D as ParseError, E as variant, F as parse, G as listSequence, H as installKeys, I as compiledLayout, J as toArray, K as matches, L as compiledShape, M as copyValue, N as equalTreeNode, O as checkKey, P as equalValue, R as equal, S as object, T as tree, U as installList, V as install, W as keys, Y as profile, _ as collectionEntryNode, a as observe, b as list, c as projectionRef, d as createScheduler, f as ProjectionDisposedError, g as snapshotCollectionView, h as mapRead, i as isProjection, j as copyTreeNode, k as checkTreePayload, l as assertScope, m as collectionView, n as derive, o as ownProjection, p as ProjectionError, q as remove$4, r as input, s as producerOf, t as incremental, u as assertSynchronous, v as compilePath, w as table, x as map, y as field, z as indexedKeys } from "./advanced-CRNHfJBu.js";
+import { a as is, c as validate, d as isRecord, i as contains$1, l as installOwn, n as contextOf, o as parent, r as children, t as bindContext } from "./context-DFEaDUv5.js";
+import { a as sealChanges, c as fail, i as decodeChanges, l as invalidValue, o as AddressIndex, s as MutationRejected, t as assertRuntimeWritable } from "./driver-yFfvDMX5.js";
+//#region core/src/address/resolve.ts
+const variantNode = (node, value) => {
+	const tag = isRecord(value) && typeof value[node.tag] === "string" ? value[node.tag] : void 0;
+	return node.variants[String(tag ?? Object.keys(node.variants)[0] ?? "")];
+};
+const step = (nodeInput, value, segment) => {
+	let node = nodeInput;
+	if (!node) return void 0;
+	if (node.kind === "variant") node = variantNode(node, value);
+	if (!node) return void 0;
+	if (node.kind === "object") return Object.hasOwn(node.shape, segment) ? node.shape[segment] : void 0;
+	if (node.kind === "table" || node.kind === "map") return node.value;
+	if (node.kind === "list") return node.value;
+};
+const nodeAt = (schema, address, document) => {
+	let node = schema;
+	let value = document;
+	for (const segment of address) {
+		const resolved = step(node, value, segment);
+		value = readSegment(value, segment, node);
+		node = resolved;
+		if (!node) return void 0;
+	}
+	return node;
+};
+const readSegment = (value, segment, node) => {
+	if (!isRecord(value) && !Array.isArray(value)) return void 0;
+	if (node?.kind === "list" && Array.isArray(value)) return value[indexedKeys(value, node.keyOf).index(segment)];
+	if (node?.kind === "table" && isRecord(value) && isRecord(value.byId)) return Object.hasOwn(value.byId, segment) ? value.byId[segment] : void 0;
+	return Object.prototype.hasOwnProperty.call(value, segment) ? value[segment] : void 0;
+};
+const resolveContainer = (owner, generation, at, node, value) => {
+	if (!node || !isRecord(value) && !Array.isArray(value)) return void 0;
+	const parent = node.kind === "table" && isRecord(value) ? value.byId : value;
+	if (!isRecord(parent) && !Array.isArray(parent)) return void 0;
+	if (node.kind === "tree") return void 0;
+	const layout = compiledLayout(node, value);
+	if (!layout) return void 0;
+	return {
+		owner,
+		generation,
+		at,
+		node,
+		parent,
+		value,
+		layout
+	};
+};
+const resolveTreeContainer = (owner, generation, at, node, value) => node?.kind === "tree" && is(value) ? {
+	owner,
+	generation,
+	at,
+	node,
+	value
+} : void 0;
+const memberKey = (container, key) => container.node.kind === "list" ? indexedKeys(container.parent, container.node.keyOf).index(key) : key;
+/** One recent path per transaction; structural writes invalidate all retained locations. */
+const createAddressResolver = (schema, root) => {
+	const prefix = [];
+	return {
+		container: (owner, generation, at) => {
+			if (!at.length) return resolveContainer(owner, generation, at, schema, root);
+			const location = resolveWithPrefix(schema, root, at, prefix);
+			if (!location || !Object.hasOwn(location.parent, location.key)) return void 0;
+			return resolveContainer(owner, generation, at, location.node, location.parent[location.key]);
+		},
+		invalidate: () => {
+			prefix.length = 0;
+		}
+	};
+};
+/** A subtree root is a value, not a fabricated member of an ObjectNode. */
+const resolveValue = (schema, root, address, prefix) => {
+	if (!address.length) return {
+		node: schema,
+		value: root
+	};
+	const location = resolveWithPrefix(schema, root, address, prefix);
+	return location && {
+		node: location.node,
+		value: Object.hasOwn(location.parent, location.key) ? location.parent[location.key] : void 0
+	};
+};
+/** Resolves schema and document location in one address traversal. */
+const resolveLocated = (schema, root, address) => resolveWithPrefix(schema, root, address);
+const resolveWithPrefix = (schema, root, address, prefix) => {
+	if (address.length === 0) return void 0;
+	let node = schema;
+	let current = root;
+	let start = 0;
+	if (prefix) {
+		while (start < prefix.length && start < address.length - 1 && prefix[start].segment === address[start]) start++;
+		prefix.length = start;
+		if (start) {
+			const retained = prefix[start - 1];
+			node = retained.node;
+			current = retained.value;
+		}
+	}
+	let cacheable = true;
+	for (let index = start; index < address.length - 1; index += 1) {
+		profile.address.schemaStep();
+		profile.address.documentStep();
+		const resolved = step(node, current, address[index]);
+		if (!resolved) return void 0;
+		if (node?.kind !== "object" && node?.kind !== "table" && node?.kind !== "map") cacheable = false;
+		current = readSegment(current, address[index], node);
+		node = resolved;
+		if (prefix && cacheable) prefix.push({
+			segment: address[index],
+			node: resolved,
+			value: current
+		});
+		if (!node) return void 0;
+	}
+	const last = address[address.length - 1];
+	return resolveChild(node, current, last);
+};
+/** Resolves one member from an already current schema/container pair. */
+const resolveChild = (node, current, last) => {
+	profile.address.schemaStep();
+	profile.address.documentStep();
+	const resolved = step(node, current, last);
+	if (!resolved || !isRecord(current) && !Array.isArray(current)) return void 0;
+	if (node?.kind === "table" && isRecord(current) && isRecord(current.byId)) return {
+		node: resolved,
+		parent: current.byId,
+		key: last
+	};
+	return {
+		node: resolved,
+		parent: current,
+		key: node?.kind === "list" && Array.isArray(current) ? indexedKeys(current, node.keyOf).index(last) : last
+	};
+};
+//#endregion
+//#region core/src/mutation/operations/map.ts
+function put(session, container, id, value) {
+	if (container.node.kind !== "map") return fail(container.at, "invalid-collection", "Expected a map.");
+	session.writeMember(container, id, value, "set");
+}
+function remove$3(session, container, id) {
+	if (container.node.kind !== "map") return fail(container.at, "invalid-collection", "Expected a map.");
+	session.writeMember(container, id, void 0, "remove");
+}
+//#endregion
+//#region core/src/order/anchor.ts
+const length = (keys) => keys.length;
+const keyIndex = (keys, key) => Array.isArray(keys) ? keys.indexOf(key) : keys.index(key);
+/** Plan one relative move against the order that remains after removing the selection. */
+const moveSelection = (current, selection, position) => {
+	if (!selection.length) return {
+		kind: "ok",
+		order: current
+	};
+	const selected = /* @__PURE__ */ new Set();
+	for (const key of selection) {
+		if (selected.has(key)) return { kind: "duplicate" };
+		selected.add(key);
+	}
+	const moved = [];
+	const remaining = [];
+	for (const key of current) (selected.has(key) ? moved : remaining).push(key);
+	if (moved.length !== selected.size) return { kind: "missing" };
+	if (!valid(remaining, position)) return { kind: "invalid-anchor" };
+	const insertion = index(remaining, position);
+	return {
+		kind: "ok",
+		order: [
+			...remaining.slice(0, insertion),
+			...moved,
+			...remaining.slice(insertion)
+		]
+	};
+};
+const index = (keys, anchor) => {
+	if (!anchor) return length(keys);
+	if ("at" in anchor) return anchor.at === "start" ? 0 : length(keys);
+	if ("before" in anchor) return keyIndex(keys, anchor.before);
+	return keyIndex(keys, anchor.after) + 1;
+};
+const valid = (keys, anchor) => {
+	if (!anchor) return true;
+	if (typeof anchor !== "object" || anchor === null) return false;
+	if (Number("at" in anchor) + Number("before" in anchor) + Number("after" in anchor) !== 1) return false;
+	if ("at" in anchor) return anchor.at === "start" || anchor.at === "end";
+	return keyIndex(keys, "before" in anchor ? anchor.before : anchor.after) >= 0;
+};
+//#endregion
+//#region core/src/mutation/operations/table.ts
+function create(session, container, entries, position) {
+	const { at, node, value } = container;
+	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
+	const table = value;
+	if (!valid(table.ids, position)) return fail(at, "invalid-anchor", "Unknown table anchor.");
+	const ids = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (Object.hasOwn(table.byId, entry.id) || ids.has(entry.id)) return fail(at, "duplicate-entity", "Table key already exists.");
+		ids.add(entry.id);
+	}
+	if (!entries.length) return;
+	const index$1 = index(table.ids, position);
+	for (const entry of entries) session.writeMember(container, entry.id, entry.value, "set");
+	const length = table.ids.length;
+	table.ids.length += entries.length;
+	table.ids.copyWithin(index$1 + entries.length, index$1, length);
+	for (let i = 0; i < entries.length; i++) table.ids[index$1 + i] = entries[i].id;
+}
+function remove$2(session, container, ids) {
+	const { at, node, value } = container;
+	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
+	const table = value;
+	for (const id of ids) if (!Object.hasOwn(table.byId, id)) return fail(at, "missing-entity", "Table key does not exist.");
+	if (!ids.length) return;
+	const removed = new Set(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) {
+	const { at, node, value: tableValue } = container;
+	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
+	const table = tableValue;
+	if (!Object.hasOwn(table.byId, id)) return fail(at.concat(id), "missing-entity", "Table key does not exist.");
+	session.writeMember(container, id, value, "set");
+}
+//#endregion
+//#region core/src/mutation/operations/list.ts
+function insert$1(session, container, value, position) {
+	const { at, node, value: current } = container;
+	if (node.kind !== "list") return fail(at, "invalid-list-key", "Expected a list.");
+	session.validate(node.value, value, at);
+	const id = node.keyOf(value);
+	if (typeof id !== "string") return fail(at, "invalid-list-key", "List key must be a string.");
+	const items = current, keys$1 = keys(items, node.keyOf);
+	if (keys$1.index(id) >= 0) return fail(at, "duplicate-list-item", "List key already exists.");
+	if (!valid(keys$1, position)) return fail(at, "invalid-anchor", "Unknown list anchor.");
+	session.recorder.order(container);
+	session.recorder.member(container, id, session.definition(container, id), -1);
+	insert$2(items, index(keys$1, position), value);
+	session.invalidate();
+}
+function replace$2(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);
+	if (index < 0) return fail(at, "missing-list-item", "List key does not exist.");
+	session.writeMember(container, id, value, "set", index);
+}
+function remove$1(session, container, id) {
+	const { at, node, value } = container;
+	if (node.kind !== "list") return fail(at, "missing-list-item", "List key does not exist.");
+	const index = keys(value, node.keyOf).index(id);
+	if (index < 0) return fail(at, "missing-list-item", "List key does not exist.");
+	session.writeMember(container, id, void 0, "remove", index);
+}
+//#endregion
+//#region core/src/mutation/operations/tree.ts
+const node$1 = (tree, id) => Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
+const positionIndex = (index, length, at) => {
+	if (index !== void 0 && (!Number.isInteger(index) || index < 0)) return fail(at, "invalid-tree-index", "Tree index must be nonnegative.");
+	return Math.min(index ?? length, length);
+};
+const insert = (session, container, id, value, position) => {
+	const { at, node: schema, value: tree } = container;
+	if (typeof id !== "string") return fail(at, "invalid-key", "Tree keys must be strings.");
+	if (contains$1(tree, id)) return fail(at, "duplicate-tree-node", "Tree node already exists.");
+	const parentId = position?.parentId;
+	const parent = parentId === void 0 ? void 0 : node$1(tree, parentId);
+	if (tree.rootId !== void 0 && !parent || tree.rootId === void 0 && parentId !== void 0) return fail(at, "missing-tree-parent", "A nonempty tree requires an existing parent.");
+	const index = positionIndex(position?.index, parent?.children.length ?? 0, at);
+	session.validate(schema.value, value, at.concat(id));
+	session.recorder.tree(container, id);
+	if (parentId !== void 0) session.recorder.tree(container, parentId);
+	Object.defineProperty(tree.nodes, id, {
+		value: {
+			...parentId === void 0 ? {} : { parentId },
+			children: [],
+			value
+		},
+		writable: true,
+		configurable: true,
+		enumerable: true
+	});
+	if (parent) parent.children.splice(index, 0, id);
+	else tree.rootId = id;
+	session.invalidate();
+};
+const replace$1 = (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.");
+	if (Object.is(entry.value, value) && Object.hasOwn(entry, "value")) return;
+	session.validate(schema.value, value, at.concat(id));
+	session.recorder.tree(container, id);
+	entry.value = value;
+};
+const remove = (session, container, id) => {
+	const { at, value: tree } = container;
+	const entry = node$1(tree, id);
+	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
+	const ids = [], stack = [id];
+	while (stack.length) {
+		const current = stack.pop();
+		ids.push(current);
+		for (const child of tree.nodes[current].children) stack.push(child);
+	}
+	for (const key of ids) session.recorder.tree(container, key);
+	if (entry.parentId !== void 0) session.recorder.tree(container, entry.parentId);
+	if (entry.parentId === void 0) delete tree.rootId;
+	else {
+		const children = tree.nodes[entry.parentId].children;
+		children.splice(children.indexOf(id), 1);
+	}
+	for (const key of ids) delete tree.nodes[key];
+	session.invalidate();
+};
+const move$1 = (session, container, id, position) => {
+	const { at, value: tree } = container;
+	const entry = node$1(tree, id), parentId = position?.parentId;
+	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
+	if (entry.parentId === void 0 || parentId === void 0 || !contains$1(tree, parentId)) return fail(at, "missing-tree-parent", "Moving requires a non-root node and an existing parent.");
+	for (let ancestor = parentId; ancestor !== void 0; ancestor = tree.nodes[ancestor].parentId) if (ancestor === id) return fail(at, "tree-cycle", "Cannot move a node under its descendant.");
+	const old = tree.nodes[entry.parentId], next = tree.nodes[parentId];
+	const index = positionIndex(position?.index, next.children.length - (old === next ? 1 : 0), at);
+	const previous = old.children.indexOf(id);
+	if (old === next && previous === index) return;
+	session.recorder.tree(container, id);
+	session.recorder.tree(container, entry.parentId);
+	session.recorder.tree(container, parentId);
+	old.children.splice(previous, 1);
+	next.children.splice(index, 0, id);
+	entry.parentId = parentId;
+	session.invalidate();
+};
+//#endregion
+//#region core/src/mutation/operations/order.ts
+const assertOrdered = (container) => {
+	const { at, node } = container;
+	if (node.kind !== "table" && node.kind !== "list") return fail(at, "invalid-collection", "Expected an ordered container.");
+	return node;
+};
+const plannedOrder = (at, current, selection, position) => {
+	const plan = moveSelection(current, selection, position);
+	switch (plan.kind) {
+		case "ok": return plan.order;
+		case "duplicate": return fail(at, "invalid-key", "Moved keys must be unique.");
+		case "missing": return fail(at, "missing-entity", "Ordered key does not exist.");
+		case "invalid-anchor": return fail(at, "invalid-anchor", "Unknown order anchor.");
+	}
+};
+function move(session, container, ids, position) {
+	const node = assertOrdered(container);
+	const selection = typeof ids === "string" ? [ids] : ids;
+	if (!selection.length) return;
+	if (node.kind === "table") {
+		const order = container.value.ids;
+		const next = plannedOrder(container.at, order, selection, position);
+		if (equal(order, next)) return;
+		session.recorder.order(container);
+		installKeys(order, next);
+	} else {
+		const items = container.value;
+		const current = listSequence(items, node.keyOf);
+		const next = plannedOrder(container.at, current.order, selection, position);
+		if (equal(current.order, next)) return;
+		session.recorder.order(container);
+		installList(items, node.keyOf, current, next);
+	}
+	session.invalidate();
+}
+function reorder(session, container, next) {
+	const node = assertOrdered(container);
+	if (node.kind === "table") {
+		const current = container.value.ids;
+		if (!matches(next, current)) return fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
+		if (equal(current, next)) return;
+		session.recorder.order(container);
+		installKeys(current, next);
+	} else {
+		const items = container.value;
+		const current = listSequence(items, node.keyOf);
+		if (!matches(next, current.order)) return fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
+		if (equal(current.order, next)) return;
+		session.recorder.order(container);
+		installList(items, node.keyOf, current, next);
+	}
+	session.invalidate();
+}
+//#endregion
+//#region core/src/impact/target.ts
+const treeRootSegment = "rootId";
+const treeNodesSegment = "nodes";
+const ordinaryNamespace = "\0value";
+const treeNamespace = "\0tree";
+const tree$1 = (at, selection) => ({
+	kind: "value",
+	at,
+	tree: selection
+});
+const address = (target) => "at" in target ? target.at : target.address;
+const id = (target) => target.kind === "collection" && "id" in target ? target.id : void 0;
+const belongs = (target, schema) => !("schema" in target) || target.schema === schema;
+const treeTarget = (target) => "tree" in target ? target.tree : void 0;
+const sameTreeTarget = (left, right) => {
+	if (!left || !right) return left === right;
+	if (left.kind !== right.kind) return false;
+	return left.kind !== "node" || right.kind === "node" && left.id === right.id;
+};
+const same = (left, right) => {
+	if ("schema" in left && "schema" in right && left.schema !== right.schema) return false;
+	if (!sameTreeTarget(treeTarget(left), treeTarget(right))) return false;
+	if (left.kind !== right.kind) return false;
+	const leftAddress = address(left);
+	const rightAddress = address(right);
+	if (leftAddress.length !== rightAddress.length) return false;
+	for (let index = 0; index < leftAddress.length; index += 1) if (leftAddress[index] !== rightAddress[index]) return false;
+	return left.kind !== "collection" || id(left) === id(right);
+};
+const indexedAddress = (target) => {
+	const tree = treeTarget(target);
+	if (tree?.kind === "root") return [
+		treeNamespace,
+		...address(target),
+		treeRootSegment
+	];
+	if (tree?.kind === "nodes") return [
+		treeNamespace,
+		...address(target),
+		treeNodesSegment
+	];
+	if (tree?.kind === "node") return [
+		treeNamespace,
+		...address(target),
+		treeNodesSegment,
+		tree.id
+	];
+	const key = id(target);
+	return key === void 0 ? [ordinaryNamespace, ...address(target)] : [
+		ordinaryNamespace,
+		...address(target),
+		key
+	];
+};
+const visitChangedLocations = (changes, value, order) => {
+	for (const change of changes.changes) {
+		if (change.kind === "reset") continue;
+		if (change.kind === "members") {
+			for (const member of change.members) {
+				value([
+					ordinaryNamespace,
+					...change.at,
+					member.key
+				]);
+				value([
+					treeNamespace,
+					...change.at,
+					member.key
+				]);
+			}
+			if (change.order) order([ordinaryNamespace, ...change.at]);
+			continue;
+		}
+		value([ordinaryNamespace, ...change.at]);
+		if (change.before !== change.after) value([
+			treeNamespace,
+			...change.at,
+			treeRootSegment
+		]);
+		for (const node of change.nodes) value([
+			treeNamespace,
+			...change.at,
+			treeNodesSegment,
+			node.id
+		]);
+	}
+};
+const affected = (target, values, orders) => {
+	const at = indexedAddress(target);
+	return id(target) !== void 0 ? values.hasAncestor(at) : values.overlaps(at) || orders.hasDescendant(at);
+};
+/** Targets are classified once; commit matching never builds a reverse impact index. */
+var SubscriptionIndex = class {
+	ordinary = new AddressIndex();
+	membership = new AddressIndex();
+	constructor(schema) {
+		this.schema = schema;
+	}
+	add(target, value) {
+		if (!belongs(target, this.schema)) return;
+		(id(target) === void 0 ? this.ordinary : this.membership).add(indexedAddress(target), value);
+	}
+	delete(target, value) {
+		if (!belongs(target, this.schema)) return;
+		(id(target) === void 0 ? this.ordinary : this.membership).delete(indexedAddress(target), value);
+	}
+	collect(changes, visit) {
+		const values = this.ordinary.query(visit);
+		const members = this.membership.query(visit, "descendants");
+		const orders = this.ordinary.query(visit, "ancestors");
+		if (changes.changes.some((change) => change.kind === "reset")) {
+			values([]);
+			members([]);
+			return;
+		}
+		visitChangedLocations(changes, (at) => {
+			values(at);
+			members(at);
+		}, orders);
+	}
+	clear() {
+		this.ordinary.clear();
+		this.membership.clear();
+	}
+};
+//#endregion
+//#region core/src/access/scope.ts
+const locations = /* @__PURE__ */ new WeakMap();
+const locationOf = (value) => locations.get(value);
+const addressOf = (target) => {
+	if (target.at) return target.at;
+	profile.access("addresses");
+	return target.at = addressOf(target.parent).concat(target.key);
+};
+const assertActive = (context) => {
+	if (context.active && !context.active()) throw new Error("Document access scope has expired.");
+};
+const collect = (context, at, kind = "value", id) => {
+	context.dependencies?.record(kind === "value" ? {
+		kind,
+		at
+	} : {
+		kind,
+		at,
+		...id === void 0 ? {} : { id }
+	});
+};
+const collectTree = (context, at, selection) => context.dependencies?.record(tree$1(at, selection));
+const snapshot = (value) => {
+	const location = value && typeof value === "object" ? locationOf(value) : void 0;
+	if (!location) return value;
+	const { context } = location;
+	const at = addressOf(location.target);
+	profile.access("snapshots");
+	collect(context, at);
+	const resolved = resolve(context, location.target);
+	if (!resolved.node) throw new Error("The selected schema address no longer exists.");
+	return copyValue(resolved.node, resolved.value);
+};
+const replace = (container, key, value) => {
+	if (!locationOf(container)) throw new TypeError("replace requires scoped document access.");
+	if (typeof key !== "string") throw new TypeError("Document keys must be strings.");
+	Reflect.set(container, key, value);
+};
+const resolve = (context, target) => {
+	assertActive(context);
+	const generation = context.session?.generation ?? 0;
+	if (target.generation !== generation) {
+		profile.access("resolutions");
+		if (!target.parent && !target.at.length) {
+			target.node = context.state.schema;
+			target.value = context.state.document;
+		} else {
+			const parent = target.parent && resolve(context, target.parent);
+			const location = parent ? resolveChild(parent.node, parent.value, target.key) : resolveLocated(context.state.schema, context.state.document, target.at);
+			target.node = location?.node ?? nodeAt(context.state.schema, addressOf(target), context.state.document);
+			target.value = location && Object.hasOwn(location.parent, location.key) ? location.parent[location.key] : void 0;
+		}
+		target.generation = generation;
+	}
+	return target;
+};
+const createAccess = (context, initial = []) => {
+	profile.access("scopes");
+	const mutable = () => {
+		assertActive(context);
+		if (!context.session) throw new TypeError("Cannot modify read-only document access.");
+		return context.session;
+	};
+	const writableContainer = (target, session) => {
+		if (target.container?.generation === session.generation && "layout" in target.container) return target.container;
+		return target.container = session.bind(addressOf(target), target.node, target.value);
+	};
+	const childAt = (target, key) => {
+		profile.access("addresses");
+		return addressOf(target).concat(key);
+	};
+	const access = (target) => {
+		if (target.proxy) return target.proxy;
+		const proxy = new Proxy(target, handler);
+		profile.access("proxies");
+		locations.set(proxy, {
+			context,
+			target
+		});
+		target.proxy = proxy;
+		return proxy;
+	};
+	const createTarget = (at, parent, key) => ({
+		at,
+		parent,
+		key,
+		node: void 0,
+		value: void 0,
+		generation: -1,
+		children: void 0,
+		proxy: void 0
+	});
+	const childAccess = (target, member, node, value) => {
+		const key = typeof member === "string" ? member : member.key;
+		if (node.kind === "field" || value === void 0) {
+			if (context.dependencies) collect(context, childAt(target, key));
+			return value;
+		}
+		let children = target.children;
+		let child;
+		if (typeof member !== "string") {
+			if (children?.kind !== "fixed" || children.schema !== target.node) children = {
+				kind: "fixed",
+				schema: target.node,
+				slots: new Array(compiledShape(target.node, target.value).members.size)
+			};
+			child = children.slots[member.slot] ??= createTarget(void 0, target, key);
+		} else {
+			if (children?.kind !== "dynamic") children = {
+				kind: "dynamic",
+				keys: /* @__PURE__ */ new Map()
+			};
+			const retained = children.keys.get(key);
+			child = retained ?? createTarget(void 0, target, key);
+			if (!retained) children.keys.set(key, child);
+		}
+		target.children = children;
+		if (child.generation === target.generation) return child.proxy;
+		child.node = node;
+		child.value = value;
+		child.generation = target.generation;
+		return access(child);
+	};
+	const collectionValue = (target, node) => {
+		const current = resolve(context, target);
+		if (current.node !== node || current.value === void 0) throw new TypeError("The collection method belongs to a replaced schema branch.");
+		return current.value;
+	};
+	const writableCollection = (target, node) => {
+		const session = mutable();
+		collectionValue(target, node);
+		return writableContainer(target, session);
+	};
+	const writableTree = (target, node) => {
+		const session = mutable();
+		collectionValue(target, node);
+		if (target.container?.generation === session.generation && !("layout" in target.container)) return target.container;
+		return target.container = session.bindTree(addressOf(target), target.node, target.value);
+	};
+	const replaceCollection = (target, node, value) => {
+		const session = mutable();
+		collectionValue(target, node);
+		session.replace(addressOf(target), value);
+	};
+	const mapMethod = (target, property, node) => {
+		if (property === "ids") return () => {
+			const current = collectionValue(target, node);
+			if (context.dependencies) collect(context, addressOf(target), "collection");
+			return Object.keys(current);
+		};
+		if (property === "has") return (id) => {
+			const current = collectionValue(target, node);
+			if (context.dependencies) collect(context, addressOf(target), "collection", id);
+			return Object.hasOwn(current, id);
+		};
+		if (property === "get") return (id) => {
+			const current = collectionValue(target, node);
+			if (context.dependencies) collect(context, addressOf(target), "collection", id);
+			if (!Object.hasOwn(current, id)) return void 0;
+			if (node.value.kind === "field") {
+				if (context.dependencies) collect(context, childAt(target, id));
+				return current[id];
+			}
+			return childAccess(target, id, node.value, current[id]);
+		};
+		if (property === "put") return (id, value) => {
+			const writable = writableCollection(target, node);
+			put(context.session, writable, id, value);
+		};
+		if (property === "remove") return (id) => {
+			const writable = writableCollection(target, node);
+			remove$3(context.session, writable, id);
+		};
+		if (property === "replace") return (value) => replaceCollection(target, node, value);
+	};
+	const orderedMethod = (target, property, node) => {
+		const at = addressOf(target);
+		if (property === "ids") return () => {
+			const current = collectionValue(target, node);
+			collect(context, at, "collection");
+			return node.kind === "table" ? [...current.ids] : current.map(node.keyOf);
+		};
+		if (property === "has") return (id) => {
+			const current = collectionValue(target, node);
+			collect(context, at, "collection", id);
+			return node.kind === "table" ? Object.hasOwn(current.byId, id) : indexedKeys(current, node.keyOf).index(id) >= 0;
+		};
+		if (property === "get") return (id) => {
+			const current = collectionValue(target, node);
+			collect(context, at, "collection", id);
+			const location = resolveChild(node, current, id);
+			if (!location || !Object.hasOwn(location.parent, location.key)) return void 0;
+			return childAccess(target, id, location.node, location.parent[location.key]);
+		};
+		if (property === "move") return (ids, position) => {
+			const writable = writableCollection(target, node);
+			move(context.session, writable, ids, position);
+		};
+		if (property === "reorder") return (ids) => {
+			const writable = writableCollection(target, node);
+			reorder(context.session, writable, ids);
+		};
+	};
+	const tableMethod = (target, property, node) => {
+		if (property === "create") return (input, valueOrPosition, position) => {
+			const writable = writableCollection(target, node);
+			create(context.session, writable, Array.isArray(input) ? input : [{
+				id: input,
+				value: valueOrPosition
+			}], Array.isArray(input) ? valueOrPosition : position);
+		};
+		if (property === "remove") return (ids) => {
+			const writable = writableCollection(target, node);
+			remove$2(context.session, writable, typeof ids === "string" ? [ids] : ids);
+		};
+		if (property === "replace") return (...args) => {
+			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);
+		};
+		return orderedMethod(target, property, node);
+	};
+	const listMethod = (target, property, node) => {
+		if (property === "insert") return (value, position) => {
+			const writable = writableCollection(target, node);
+			insert$1(context.session, writable, value, position);
+		};
+		if (property === "remove") return (id) => {
+			const writable = writableCollection(target, node);
+			remove$1(context.session, writable, id);
+		};
+		if (property === "replace") return (...args) => {
+			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);
+		};
+		return orderedMethod(target, property, node);
+	};
+	const treeMethod = (target, property, node) => {
+		const at = addressOf(target);
+		if (property === "insert") return (id, value, position) => {
+			const writable = writableTree(target, node);
+			insert(context.session, writable, id, value, position);
+		};
+		if (property === "remove") return (id) => {
+			const writable = writableTree(target, node);
+			remove(context.session, writable, id);
+		};
+		if (property === "move") return (id, position) => {
+			const writable = writableTree(target, node);
+			move$1(context.session, writable, id, position);
+		};
+		if (property === "replace") return (...args) => {
+			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);
+		};
+		const current = () => collectionValue(target, node);
+		if (property === "rootId") return () => {
+			collectTree(context, at, { kind: "root" });
+			return current().rootId;
+		};
+		if (property === "get") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
+			const value = current();
+			return contains$1(value, id) ? value.nodes[id].value : void 0;
+		};
+		if (property === "has") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
+			return contains$1(current(), id);
+		};
+		if (property === "parent") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
+			return parent(current(), id);
+		};
+		if (property === "children") return (id) => {
+			collectTree(context, at, {
+				kind: "node",
+				id
+			});
+			const children$1 = children(current(), id);
+			return children$1 ? [...children$1] : void 0;
+		};
+	};
+	const handler = {
+		get: (target, property) => {
+			const { node, value } = resolve(context, target);
+			if (!node || value === void 0) return void 0;
+			if (typeof property !== "string") return void 0;
+			if (node.kind === "map") return mapMethod(target, property, node);
+			if (node.kind === "table") return tableMethod(target, property, node);
+			if (node.kind === "list") return listMethod(target, property, node);
+			if (node.kind === "tree") return treeMethod(target, property, node);
+			if (node.kind === "variant" && property === node.tag) {
+				collect(context, childAt(target, property));
+				return value[property];
+			}
+			const member = compiledShape(node, value)?.members.get(property);
+			if (!member) return void 0;
+			if (member.field) {
+				if (context.dependencies) collect(context, childAt(target, property));
+				return value[property];
+			}
+			return childAccess(target, node.kind === "object" ? member : property, member.node, value[property]);
+		},
+		set: (target, property, value) => {
+			const session = mutable(), { node } = resolve(context, target);
+			if (typeof property !== "string" || !node || node.kind !== "object" && node.kind !== "variant") throw new TypeError("Invalid structural assignment.");
+			if (node.kind === "variant" && node.tag === property) throw new TypeError("Variant discriminants are read-only.");
+			session.assignMember(writableContainer(target, session), property, value);
+			return true;
+		},
+		deleteProperty: (target, property) => {
+			const session = mutable(), { node } = resolve(context, target);
+			if (typeof property !== "string" || node?.kind === "map" || node?.kind === "variant" && node.tag === property) throw new TypeError("Invalid structural deletion.");
+			session.removeMember(writableContainer(target, session), property);
+			return true;
+		},
+		has: (target, property) => {
+			const { node, value } = resolve(context, target);
+			if (typeof property !== "string") return false;
+			if (node?.kind === "map") return false;
+			collect(context, addressOf(target));
+			return value !== void 0 && Object.hasOwn(value, property);
+		},
+		ownKeys: (target) => {
+			const { node, value } = resolve(context, target);
+			if (node?.kind === "map") return [];
+			if (context.dependencies) collect(context, addressOf(target));
+			return value && typeof value === "object" ? Object.keys(value) : [];
+		},
+		getOwnPropertyDescriptor: (target, property) => {
+			const { node, value } = resolve(context, target);
+			if (node?.kind === "map") return void 0;
+			return value && Object.hasOwn(value, property) ? {
+				enumerable: true,
+				configurable: true
+			} : void 0;
+		},
+		defineProperty: () => {
+			assertActive(context);
+			throw new TypeError("Use schema assignments.");
+		},
+		setPrototypeOf: () => {
+			assertActive(context);
+			throw new TypeError("Document prototypes are immutable.");
+		},
+		preventExtensions: () => {
+			assertActive(context);
+			throw new TypeError("Document access cannot be frozen.");
+		}
+	};
+	const root = resolve(context, createTarget(initial, void 0, ""));
+	if (!root.node || root.node.kind === "field" || root.value === void 0) {
+		if (context.dependencies) collect(context, initial);
+		return root.value;
+	}
+	return access(root);
+};
+//#endregion
+//#region core/src/address/relation.ts
+const contains = (parent, child) => {
+	profile.address.prefixComparison();
+	if (parent.length > child.length) return false;
+	for (let index = 0; index < parent.length; index += 1) {
+		profile.address.segmentCompared();
+		if (parent[index] !== child[index]) return false;
+	}
+	return true;
+};
+//#endregion
 //#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,89 +909,117 @@ 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;
 	};
 	const cache = /* @__PURE__ */ new Map();
-	const implementation = {
-		affects(value) {
-			profile.impact.affects();
-			if (!belongs(value, schema)) return false;
-			if (reset) return true;
-			return affected(value, index(), orders);
-		},
-		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);
-			if (cached) return cached;
-			if (reset) {
-				const result = { kind: "reset" };
-				cache.set(key, result);
-				return result;
-			}
-			const at = selector.address;
-			const added = /* @__PURE__ */ new Set(), removed = /* @__PURE__ */ new Set(), updated = /* @__PURE__ */ new Set();
-			let orderChanged = false;
-			for (const change of changes.changes) {
-				if (change.kind === "reset") continue;
-				if (change.kind === "members") {
-					if (change.at.length < at.length && contains(change.at, at)) {
-						if (change.members.some((member) => member.key === at[change.at.length])) {
-							const result = { kind: "reset" };
-							cache.set(key, result);
-							return result;
-						}
-					} else if (contains(at, change.at)) if (change.at.length === at.length) {
-						if (change.order) {
-							const positions = new Map(change.order.after.map((id, i) => [id, i]));
-							let previous = -1;
-							for (const id of change.order.before) {
-								const position = positions.get(id);
-								if (position === void 0) continue;
-								if (position < previous) orderChanged = true;
-								previous = position;
-							}
+	const affects = (value) => {
+		profile.impact.affects();
+		if (!belongs(value, schema)) return false;
+		if (reset) return true;
+		return affected(value, index(), orders);
+	};
+	const collection = (selector) => {
+		if (selector.schema !== schema) throw new TypeError("Collection belongs to another root model.");
+		const key = JSON.stringify(indexedAddress(selector)), cached = cache.get(key);
+		if (cached) return cached;
+		if (reset) {
+			const result = { kind: "reset" };
+			cache.set(key, result);
+			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) {
+			if (change.kind === "reset") continue;
+			if (change.kind === "members") {
+				if (change.at.length < at.length && contains(change.at, at)) {
+					if (change.members.some((member) => member.key === at[change.at.length])) {
+						const result = { kind: "reset" };
+						cache.set(key, result);
+						return result;
+					}
+				} else if (contains(at, change.at)) if (change.at.length === at.length) {
+					if (change.order) {
+						const positions = new Map(change.order.after.map((id, i) => [id, i]));
+						let previous = -1;
+						for (const id of change.order.before) {
+							const position = positions.get(id);
+							if (position === void 0) continue;
+							if (position < previous) orderChanged = true;
+							previous = position;
 						}
-						for (const member of change.members) if (member.kind === "added") added.add(member.key);
-						else if (member.kind === "removed") removed.add(member.key);
-						else updated.add(member.key);
-					} else updated.add(change.at[at.length]);
+					}
+					for (const member of change.members) if (member.kind === "added") added.add(member.key);
+					else if (member.kind === "removed") removed.add(member.key);
+					else updated.add(member.key);
+				} else updated.add(change.at[at.length]);
+				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;
 				}
-				if (change.kind === "tree" && contains(change.at, at)) {
-					const result = { kind: "reset" };
-					cache.set(key, result);
-					return result;
-				}
-				if (!contains(at, change.at)) continue;
-				if (change.at.length === at.length) continue;
-				const id = change.at[at.length];
-				updated.add(id);
+				const result = { kind: "reset" };
+				cache.set(key, result);
+				return result;
 			}
-			added.forEach((id) => updated.delete(id));
-			removed.forEach((id) => updated.delete(id));
-			const result = {
-				kind: "incremental",
-				added,
-				removed,
-				updated,
-				orderChanged
-			};
-			cache.set(key, result);
-			return result;
+			if (!contains(at, change.at)) continue;
+			if (change.at.length === at.length) continue;
+			const id = change.at[at.length];
+			updated.add(id);
 		}
+		added.forEach((id) => updated.delete(id));
+		removed.forEach((id) => updated.delete(id));
+		const result = {
+			kind: "incremental",
+			added,
+			removed,
+			updated,
+			orderChanged
+		};
+		cache.set(key, result);
+		return result;
 	};
-	const impact = Object.freeze({
+	return Object.freeze({
 		kind: reset ? "reset" : "incremental",
-		affects: (pick) => implementation.affects(compilePath(schema, "value", pick)),
-		collection: (pick) => implementation.collection(compilePath(schema, "collection", pick))
+		affects: (pick) => affects(compilePath(schema, "value", pick)),
+		collection: (pick) => collection(compilePath(schema, "collection", pick))
 	});
-	queries.set(impact, implementation);
-	return impact;
+};
+//#endregion
+//#region core/src/runtime/contract.ts
+var DocumentReentrancyError = class extends Error {
+	constructor() {
+		super("Document writes cannot be re-entered during an update or notification.");
+		this.name = "DocumentReentrancyError";
+	}
+};
+var DocumentDisposedError = class extends Error {
+	constructor() {
+		super("Doxum runtime has been disposed.");
+		this.name = "DocumentDisposedError";
+	}
+};
+var TransactionRejected = class extends Error {
+	issues;
+	constructor(input) {
+		super("Document update rejected.");
+		this.name = "TransactionRejected";
+		const issues = Array.isArray(input) ? input : [input];
+		this.issues = Object.freeze(issues.map((issue) => Object.freeze({
+			code: issue.code,
+			message: issue.message,
+			source: "application",
+			...issue.address === void 0 ? {} : { address: Object.freeze([...issue.address]) }
+		})));
+	}
 };
 //#endregion
 //#region core/src/history.ts
@@ -271,17 +1192,10 @@ const createHistory = (input) => {
 const installMember = (parent, key, present, value) => {
 	if (Array.isArray(parent)) {
 		const index = Number(key);
-		if (present) if (index < 0) insert(parent, parent.length, value);
+		if (present) if (index < 0) insert$2(parent, parent.length, value);
 		else parent[index] = value;
-		else if (index >= 0) remove(parent, index);
-	} else if (!present) delete parent[key];
-	else if (Object.hasOwn(parent, key)) parent[key] = value;
-	else Object.defineProperty(parent, key, {
-		value,
-		writable: true,
-		configurable: true,
-		enumerable: true
-	});
+		else if (index >= 0) remove$4(parent, index);
+	} else installOwn(parent, key, present, value);
 };
 const orderOf = (node, value) => {
 	if (node.kind === "list") return toArray(indexedKeys(value, node.keyOf));
@@ -308,10 +1222,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 +1312,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;
 };
@@ -438,20 +1348,19 @@ const sealMembers = (fact, changes) => {
 	}
 	publishMembers(changes, fact.at, members, order);
 };
-const sealTree = (fact, state, changes) => {
-	const location = resolveValue(state.schema, state.document, fact.at);
+const sealTree = (fact, canonical, changes) => {
+	const location = resolveValue(canonical.schema, canonical.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 +1369,7 @@ const sealTree = (fact, state, changes) => {
 			id,
 			kind: "updated",
 			before,
-			after: copyNode(after)
+			after: copyTreeNode(after)
 		});
 	}
 	const after = tree.rootId ?? null;
@@ -642,7 +1551,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() {
@@ -695,8 +1604,8 @@ var MutationSession = class {
 		this.resolvedRoot = state.document;
 	}
 	validate(node, value, at) {
-		const issue = checkValue(node, value, at);
-		if (issue) invalidValue(issue);
+		const failure = checkValue(node, value, at);
+		if (failure) invalidValue(failure);
 	}
 	resolveContainer(at) {
 		return this.resolver.container(this.identity, this.generation, at) ?? fail(at, "invalid-address", "Container does not exist.");
@@ -759,13 +1668,13 @@ var MutationSession = class {
 		const previous = container.parent[physicalKey];
 		if (existed === present && (!present || Object.is(previous, value))) return false;
 		if (parentNode.kind === "map" || parentNode.kind === "table") {
-			const issue = checkKey(parentNode.key, key, []);
-			if (issue) return fail(container.at.concat(key, ...issue.address), "invalid-key", issue.message);
+			const failure = checkKey(parentNode.key, key, []);
+			if (failure) return fail(container.at.concat(key, ...failure.address), "invalid-key", failure.message);
 		}
 		if (present) {
 			if (node.kind === "field") {
-				const issue = checkValue(node, value, []);
-				if (issue) return invalidValue(issue, container.at.concat(key, ...issue.address));
+				const failure = checkValue(node, value, []);
+				if (failure) return invalidValue(failure, container.at.concat(key, ...failure.address));
 			} else this.validate(node, value, container.at.concat(key));
 			if (parentNode.kind === "list" && parentNode.keyOf(value) !== key) return fail(container.at.concat(key), "invalid-list-key", "Replacing an item must retain its addressed key.");
 		}
@@ -829,16 +1738,178 @@ 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 diagnostic = checkTreePayload(node.value, next, change.at.concat(item.id));
+				if (diagnostic) invalidValue(diagnostic);
+			}
+			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();
 	}
 }
 //#endregion
+//#region core/src/runtime/notification.ts
+const attachProjection = (notification, processor) => {
+	const entry = {
+		processor,
+		active: true
+	};
+	notification.processors.push(entry);
+	return () => {
+		if (!entry.active) return;
+		entry.active = false;
+		if (!notification.notifying) {
+			const index = notification.processors.indexOf(entry);
+			if (index >= 0) notification.processors.splice(index, 1);
+		}
+	};
+};
+const addRoot = (notification, listener) => {
+	const entry = {
+		listener,
+		active: true
+	};
+	notification.root.add(entry);
+	return () => {
+		entry.active = false;
+		if (!notification.notifying) notification.root.delete(entry);
+		else notification.cleanups.add(() => {
+			notification.root.delete(entry);
+		});
+	};
+};
+const addFiltered = (notification, targets, listener) => {
+	const entry = {
+		targets: Object.freeze(targets.slice()),
+		listener,
+		active: true
+	};
+	notification.filtered.add(entry);
+	entry.targets.forEach((value) => notification.index.add(value, entry));
+	const remove = () => {
+		notification.filtered.delete(entry);
+		entry.targets.forEach((value) => notification.index.delete(value, entry));
+	};
+	return () => {
+		if (!entry.active) return;
+		entry.active = false;
+		if (notification.notifying) notification.cleanups.add(remove);
+		else remove();
+	};
+};
+const publishState = (notification, commit, afterSettle) => {
+	notification.notifying = true;
+	const errors = [];
+	const call = (listener) => {
+		try {
+			listener(commit);
+		} catch (error) {
+			errors.push(Object.freeze({
+				phase: "listener",
+				error
+			}));
+		}
+	};
+	try {
+		const processorCount = notification.processors.length;
+		for (let index = 0; index < processorCount; index += 1) {
+			const entry = notification.processors[index];
+			if (!entry?.active) continue;
+			try {
+				entry.processor.capture(commit);
+			} catch (error) {
+				errors.push(Object.freeze({
+					phase: "processor",
+					error
+				}));
+			}
+		}
+		for (let index = 0; index < processorCount; index += 1) {
+			const entry = notification.processors[index];
+			if (!entry?.active) continue;
+			try {
+				entry.processor.settle();
+			} catch (error) {
+				errors.push(Object.freeze({
+					phase: "processor",
+					error
+				}));
+			}
+		}
+		for (let index = 0; index < processorCount; index += 1) {
+			const entry = notification.processors[index];
+			if (!entry?.active) continue;
+			try {
+				errors.push(...entry.processor.flush());
+			} catch (error) {
+				errors.push(Object.freeze({
+					phase: "flush",
+					error
+				}));
+			}
+		}
+		if (afterSettle) errors.push(...afterSettle());
+		const candidates = notification.candidates;
+		candidates.clear();
+		if (notification.filtered.size) notification.index.collect(commit.changes, (entry) => candidates.add(entry));
+		candidates.forEach((entry) => {
+			if (entry.active) call(entry.listener);
+		});
+		const rootSnapshot = notification.rootSnapshot;
+		rootSnapshot.length = 0;
+		notification.root.forEach((entry) => rootSnapshot.push(entry));
+		for (const entry of rootSnapshot) if (entry.active) call(entry.listener);
+	} finally {
+		notification.notifying = false;
+		let writeIndex = 0;
+		for (const entry of notification.processors) if (entry.active) notification.processors[writeIndex++] = entry;
+		notification.processors.length = writeIndex;
+		notification.cleanups.forEach((cleanup) => cleanup());
+		notification.cleanups.clear();
+	}
+	return Object.freeze(errors);
+};
+const disposeState = (notification) => {
+	const attachments = notification.processors.slice();
+	notification.root.clear();
+	notification.filtered.clear();
+	notification.index.clear();
+	notification.cleanups.clear();
+	notification.processors.length = 0;
+	notification.candidates.clear();
+	notification.rootSnapshot.length = 0;
+	const errors = [];
+	attachments.forEach((entry) => {
+		if (!entry.active) return;
+		try {
+			entry.processor.dispose();
+		} catch (error) {
+			errors.push(error);
+		}
+	});
+	if (errors.length) throw new AggregateError(errors, "Projection disposal notification failed.");
+};
+const createNotificationCenter = (schema) => {
+	const state = {
+		root: /* @__PURE__ */ new Set(),
+		filtered: /* @__PURE__ */ new Set(),
+		index: new SubscriptionIndex(schema),
+		cleanups: /* @__PURE__ */ new Set(),
+		processors: [],
+		candidates: /* @__PURE__ */ new Set(),
+		rootSnapshot: [],
+		notifying: false
+	};
+	return Object.freeze({
+		subscribe: (listener) => addRoot(state, listener),
+		subscribeTargets: (targets, listener) => addFiltered(state, targets, listener),
+		attachProjection: (processor) => attachProjection(state, processor),
+		publish: (commit, afterSettle) => publishState(state, commit, afterSettle),
+		dispose: () => disposeState(state)
+	});
+};
+//#endregion
 //#region core/src/runtime.ts
 const createDocument = (input) => {
 	if (input.schema.kind !== "object") throw new TypeError("Document schema must be a root object node.");
@@ -847,13 +1918,15 @@ const createDocument = (input) => {
 	const state = {
 		schema: input.schema,
 		document: copyValue(input.schema, input.initial),
-		disposed: false
+		disposed: false,
+		projectionLocks: 0
 	};
 	let revision = 0, busy = false;
-	let runtime, notification;
+	const notifications = createNotificationCenter(input.schema);
+	let runtime, context;
 	const idle = () => {
 		if (state.disposed) throw new DocumentDisposedError();
-		if (busy || accessOf(runtime).projectionLocks) throw new DocumentReentrancyError();
+		if (busy || state.projectionLocks) throw new DocumentReentrancyError();
 	};
 	const writable = (intent) => {
 		idle();
@@ -892,7 +1965,7 @@ const createDocument = (input) => {
 		return {
 			status: "committed",
 			commit,
-			observerErrors: notify(notification, commit, history.flush)
+			observerErrors: notifications.publish(commit, history.flush)
 		};
 	};
 	function mutate(intent, recordHistory, execute) {
@@ -929,93 +2002,567 @@ const createDocument = (input) => {
 	}
 	runtime = {
 		schema: input.schema,
-		address: {
-			resolve: (at) => resolveAddress(input.schema, at, state.document),
-			read: (at) => read$1(state.document, at, input.schema),
-			contains,
-			overlaps,
-			debugKey
+		revision: () => revision,
+		update: (run, options) => {
+			const source = options?.source ?? "local";
+			let value;
+			const result = mutate({
+				kind: "update",
+				source
+			}, options?.history ?? true, (session) => {
+				value = run(createAccess({
+					state,
+					session
+				}));
+				if (value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function") throw new TypeError("Document updates must be synchronous.");
+			});
+			return result.status === "rejected" ? result : {
+				...result,
+				value
+			};
+		},
+		apply: (inputChanges, options) => mutate({
+			kind: "apply",
+			source: options?.source ?? "local"
+		}, options?.history ?? true, (session) => {
+			if (!options || options.expectedRevision !== revision) fail([], "baseline-mismatch", "apply requires the current expectedRevision.");
+			apply(session, decodeChanges(inputChanges), "forward");
+		}),
+		replace: (value, options) => {
+			const source = options?.source ?? "system";
+			return mutate({
+				kind: "replace",
+				source
+			}, source !== "remote", (session) => session.replace([], value));
+		},
+		snapshot: () => {
+			if (state.disposed) throw new DocumentDisposedError();
+			return copyValue(input.schema, state.document);
+		},
+		subscribe: ((pick, listener) => {
+			if (state.disposed) throw new DocumentDisposedError();
+			if (!listener) return notifications.subscribe(pick);
+			const picks = Array.isArray(pick) ? pick : [pick];
+			if (!picks.length) throw new TypeError("Expected at least one subscription path.");
+			return notifications.subscribeTargets(picks.map((p) => compilePath(input.schema, "value", p)), listener);
+		}),
+		history: history.api,
+		dispose: () => {
+			if (state.disposed) return;
+			idle();
+			state.disposed = true;
+			try {
+				notifications.dispose();
+			} finally {
+				history.dispose();
+				context.driver = void 0;
+			}
+		}
+	};
+	context = {
+		state,
+		owner: runtime,
+		notifications,
+		driver: void 0,
+		bypassDepth: 0
+	};
+	bindContext(runtime, context);
+	bindContext(history.api, context);
+	return runtime;
+};
+//#endregion
+//#region core/src/runtime/readable.ts
+const asReadable = (runtime) => {
+	const readable = {
+		revision: runtime.revision,
+		subscribe: runtime.subscribe
+	};
+	bindContext(readable, contextOf(runtime));
+	return Object.freeze(readable);
+};
+//#endregion
+//#region core/src/access/dependency.ts
+const createDependencyTracker = () => {
+	const targets = [];
+	return {
+		record: (value) => {
+			if (!targets.some((entry) => same(entry, value))) targets.push(value);
+		},
+		snapshot: () => Object.freeze(targets.slice())
+	};
+};
+//#endregion
+//#region core/src/runtime/access.ts
+const readWith = (runtime, run, dependencies) => {
+	const state = contextOf(runtime).state;
+	if (state.disposed) throw new DocumentDisposedError();
+	state.projectionLocks += 1;
+	try {
+		return run(createAccess({
+			state,
+			dependencies
+		}));
+	} finally {
+		state.projectionLocks--;
+	}
+};
+//#endregion
+//#region core/src/runtime/select.ts
+const read = (document, selector) => readWith(document, selector);
+const sameDependencySet = (left, right) => {
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index += 1) if (!same(left[index], right[index])) return false;
+	return true;
+};
+const select = (document, selector, equality = Object.is) => {
+	const context = contextOf(document);
+	let initialized = false;
+	let value;
+	let selectedRevision = 0;
+	let documentRevision = -1;
+	let dependencies = Object.freeze([]);
+	let unsubscribeDocument;
+	const listeners = /* @__PURE__ */ new Set();
+	const evaluate = () => {
+		const tracker = createDependencyTracker();
+		const next = readWith(document, selector, tracker);
+		const nextDependencies = tracker.snapshot();
+		const changed = !initialized || !equality(value, next);
+		const rebound = !sameDependencySet(dependencies, nextDependencies);
+		if (changed) {
+			if (initialized) selectedRevision += 1;
+			value = next;
+		}
+		dependencies = nextDependencies;
+		initialized = true;
+		documentRevision = document.revision();
+		return {
+			changed,
+			rebound
+		};
+	};
+	const installSubscription = () => {
+		unsubscribeDocument?.();
+		unsubscribeDocument = dependencies.length > 0 ? context.notifications.subscribeTargets(dependencies, () => {
+			const result = evaluate();
+			if (result.rebound) installSubscription();
+			if (result.changed) for (const listener of [...listeners]) listener();
+		}) : void 0;
+	};
+	const ensureCurrent = () => {
+		if (context.state.disposed) throw new DocumentDisposedError();
+		if (!initialized || !unsubscribeDocument && documentRevision !== document.revision()) evaluate();
+		return value;
+	};
+	return Object.freeze({
+		current: ensureCurrent,
+		revision: () => {
+			ensureCurrent();
+			return selectedRevision;
 		},
+		subscribe: (listener) => {
+			ensureCurrent();
+			listeners.add(listener);
+			if (listeners.size === 1) installSubscription();
+			return () => {
+				listeners.delete(listener);
+				if (!listeners.size) {
+					unsubscribeDocument?.();
+					unsubscribeDocument = void 0;
+				}
+			};
+		}
+	});
+};
+//#endregion
+//#region core/src/projection/collection/change.ts
+const commonOrderChanged = (before, after, added, removed) => {
+	const beforeCommon = before.filter((key) => !removed.has(key));
+	const afterCommon = after.filter((key) => !added.has(key));
+	return beforeCommon.some((key, index) => afterCommon[index] !== key);
+};
+/** Builds the canonical incremental CollectionChange from already-known net transitions. */
+const createCollectionChange = (input) => {
+	const addedKeys = new Set(input.added.map((entry) => entry.key));
+	const removedKeys = new Set(input.removed.map((entry) => entry.key));
+	const orderChanged = input.beforeOrder !== input.afterOrder && commonOrderChanged(input.beforeOrder, input.afterOrder, addedKeys, removedKeys);
+	if (!input.added.length && !input.updated.length && !input.removed.length && !orderChanged) return void 0;
+	return Object.freeze({
+		kind: "incremental",
+		added: Object.freeze([...input.added]),
+		updated: Object.freeze([...input.updated]),
+		removed: Object.freeze([...input.removed]),
+		...orderChanged ? { order: Object.freeze({
+			before: Object.freeze([...input.beforeOrder]),
+			after: Object.freeze([...input.afterOrder])
+		}) } : {}
+	});
+};
+/** Exact fallback diff between two published map-like snapshots. */
+const diffCollection = (previous, current, isEqual = Object.is) => {
+	const added = [];
+	const updated = [];
+	const removed = [];
+	for (const [key, before] of previous) if (!current.has(key)) removed.push({
+		key,
+		before
+	});
+	else {
+		const after = current.get(key);
+		if (!isEqual(before, after)) updated.push({
+			key,
+			before,
+			after
+		});
+	}
+	for (const [key, after] of current) if (!previous.has(key)) added.push({
+		key,
+		after
+	});
+	return createCollectionChange({
+		added,
+		updated,
+		removed,
+		beforeOrder: [...previous.keys()],
+		afterOrder: [...current.keys()]
+	});
+};
+const collectionChangedKeys = (change) => change.kind === "reset" ? /* @__PURE__ */ new Set() : new Set([
+	...change.added.map((entry) => entry.key),
+	...change.updated.map((entry) => entry.key),
+	...change.removed.map((entry) => entry.key)
+]);
+const collectionHasStructuralChange = (change) => change.kind === "reset" || Boolean(change.added.length || change.removed.length || change.order);
+const collectionHasAnyChange = (change) => change.kind === "reset" || Boolean(change.added.length || change.updated.length || change.removed.length || change.order);
+//#endregion
+//#region core/src/projection/collection/index.ts
+const height = (node) => node?.height ?? 0;
+const node = (key, value, left, right) => {
+	profile.collectionIndex.node();
+	return Object.freeze({
+		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)));
+	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)));
+};
+const fromSorted = (entries, start = 0, end = entries.length) => {
+	if (start >= end) return void 0;
+	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. */
+var PersistentKeyedIndex = class PersistentKeyedIndex {
+	constructor(root) {
+		this.root = root;
+	}
+	static empty() {
+		return new PersistentKeyedIndex();
+	}
+	static from(entries) {
+		const sorted = [...entries].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+		profile.collectionIndex.build(sorted.length);
+		return new PersistentKeyedIndex(fromSorted(sorted));
+	}
+	get(key) {
+		let current = this.root;
+		while (current) {
+			if (key === current.key) return current.value;
+			current = key < current.key ? current.left : current.right;
+		}
+	}
+	has(key) {
+		let current = this.root;
+		while (current) {
+			if (key === current.key) return true;
+			current = key < current.key ? current.left : current.right;
+		}
+		return false;
+	}
+	set(key, value) {
+		return new PersistentKeyedIndex(setNode(this.root, key, value));
+	}
+	remove(key) {
+		return new PersistentKeyedIndex(removeNode(this.root, key));
+	}
+};
+//#endregion
+//#region core/src/projection/output/collection.ts
+const createPublishedCollection = () => {
+	const values = /* @__PURE__ */ new Map();
+	let ids = Object.freeze([]);
+	let index = PersistentKeyedIndex.empty();
+	return {
+		get: (key) => values.get(key),
+		has: (key) => values.has(key),
+		keys: () => values.keys(),
+		size: () => values.size,
+		ids: () => ids,
+		read: (check) => {
+			const snapshotIndex = index;
+			const snapshotIds = ids;
+			return Object.freeze({
+				get: (key) => {
+					check();
+					return snapshotIndex.get(key);
+				},
+				has: (key) => {
+					check();
+					return snapshotIndex.has(key);
+				},
+				ids: () => {
+					check();
+					return snapshotIds;
+				}
+			});
+		},
+		publish: (staged, nextIds, reset) => {
+			if (reset) {
+				const entries = [];
+				for (const [key, entry] of staged) if (entry.present) entries.push([key, entry.value]);
+				index = PersistentKeyedIndex.from(entries);
+				values.clear();
+			} else for (const [key, entry] of staged) index = entry.present ? index.set(key, entry.value) : index.remove(key);
+			for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
+			else values.delete(key);
+			ids = nextIds;
+		},
+		release: () => {
+			values.clear();
+			ids = Object.freeze([]);
+			index = PersistentKeyedIndex.empty();
+		}
+	};
+};
+/** Owns staged keyed intent, exact transitions and published collection state. */
+const createCollectionOutput = () => {
+	const published = createPublishedCollection();
+	let staged = /* @__PURE__ */ new Map();
+	let nextIds = published.ids();
+	let change;
+	let initialized = false;
+	let reset = false;
+	let revision = 0;
+	let explicitOrder;
+	let cleared = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const hasNext = (key) => staged.has(key) ? staged.get(key).present : !cleared && published.has(key);
+	const getNext = (key) => {
+		const entry = staged.get(key);
+		return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : published.get(key);
+	};
+	const deriveIds = () => {
+		const result = cleared ? [] : published.ids().filter(hasNext);
+		for (const [key, entry] of staged) if (entry.present && (cleared || !published.has(key))) result.push(key);
+		return result;
+	};
+	const begin = (active, initialize) => {
+		staged = /* @__PURE__ */ new Map();
+		nextIds = published.ids();
+		change = void 0;
+		explicitOrder = void 0;
+		cleared = initialize;
+		reset = initialize;
+		const read = (next) => ({
+			get: (key) => {
+				assertScope(active);
+				return next ? getNext(key) : published.get(key);
+			},
+			has: (key) => {
+				assertScope(active);
+				return next ? hasNext(key) : published.has(key);
+			},
+			ids: () => {
+				assertScope(active);
+				return next ? Object.freeze(explicitOrder ? [...explicitOrder] : [...deriveIds()]) : published.ids();
+			}
+		});
+		return {
+			previous: read(false),
+			next: read(true),
+			output: {
+				set: (key, value) => {
+					assertScope(active);
+					if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+					staged.set(key, {
+						present: true,
+						value
+					});
+				},
+				remove: (key) => {
+					assertScope(active);
+					staged.set(key, { present: false });
+				},
+				order: (order) => {
+					assertScope(active);
+					explicitOrder = Object.freeze([...order]);
+				}
+			}
+		};
+	};
+	const seal = (nextReset, isEqual) => {
+		if (cleared) {
+			for (const key of published.keys()) if (!staged.has(key)) staged.set(key, { present: false });
+		}
+		profile.projection("touchedKeys", staged.size);
+		const added = /* @__PURE__ */ new Set();
+		const removed = /* @__PURE__ */ new Set();
+		const updated = /* @__PURE__ */ new Set();
+		for (const [key, entry] of staged) {
+			const existed = published.has(key);
+			if (entry.present) {
+				if (!existed) added.add(key);
+				else if (!isEqual(published.get(key), entry.value)) updated.add(key);
+				else if (!nextReset) staged.delete(key);
+			} else if (existed) removed.add(key);
+			else staged.delete(key);
+		}
+		const ids = published.ids();
+		if (explicitOrder || added.size || removed.size) {
+			const order = explicitOrder ?? [...ids.filter((key) => !removed.has(key)), ...added];
+			if (new Set(order).size !== order.length || order.length !== published.size() + added.size - removed.size || order.some((key) => !hasNext(key))) throw new TypeError("Projection order must contain every key exactly once.");
+			nextIds = ids.length === order.length && ids.every((key, index) => key === order[index]) ? ids : Object.freeze([...order]);
+		} else nextIds = ids;
+		const changedKeys = new Set([
+			...added,
+			...removed,
+			...updated
+		]);
+		profile.projection("changedKeys", changedKeys.size);
+		const addedEntries = [];
+		const updatedEntries = [];
+		const removedEntries = [];
+		for (const key of changedKeys) {
+			const beforePresent = published.has(key);
+			const afterPresent = hasNext(key);
+			if (beforePresent === afterPresent) {
+				if (!beforePresent || isEqual(published.get(key), getNext(key))) continue;
+			}
+			if (!beforePresent) addedEntries.push({
+				key,
+				after: getNext(key)
+			});
+			else if (!afterPresent) removedEntries.push({
+				key,
+				before: published.get(key)
+			});
+			else updatedEntries.push({
+				key,
+				before: published.get(key),
+				after: getNext(key)
+			});
+		}
+		change = nextReset ? Object.freeze({ kind: "reset" }) : createCollectionChange({
+			added: addedEntries,
+			updated: updatedEntries,
+			removed: removedEntries,
+			beforeOrder: ids,
+			afterOrder: nextIds
+		});
+		reset = nextReset;
+		return change !== void 0;
+	};
+	const context = (active, cause) => Object.freeze({
+		kind: "collection",
+		read: {
+			get: (key) => {
+				assertScope(active);
+				return getNext(key);
+			},
+			has: (key) => {
+				assertScope(active);
+				return hasNext(key);
+			},
+			ids: () => {
+				assertScope(active);
+				return nextIds;
+			}
+		},
+		change,
+		revision,
+		reset,
+		cause
+	});
+	return {
+		begin,
+		seal,
+		context,
+		current: (check) => published.read(check),
 		revision: () => revision,
-		update: (run, options) => {
-			const source = options?.source ?? "local";
-			let value;
-			const result = mutate({
-				kind: "update",
-				source
-			}, options?.history ?? true, (session) => {
-				value = run(createAccess({
-					state,
-					session
-				}));
-				if (value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function") throw new TypeError("Document updates must be synchronous.");
-			});
-			return result.status === "rejected" ? result : {
-				...result,
-				value
-			};
+		reset: () => reset,
+		publish: () => {
+			if (change) published.publish(staged, nextIds, change.kind === "reset");
+			if (change && initialized) revision++;
+			initialized = true;
 		},
-		apply: (inputChanges, options) => mutate({
-			kind: "apply",
-			source: options?.source ?? "local"
-		}, options?.history ?? true, (session) => {
-			if (!options || options.expectedRevision !== revision) fail([], "baseline-mismatch", "apply requires the current expectedRevision.");
-			apply(session, decodeChanges(inputChanges), "forward");
-		}),
-		replace: (value, options) => {
-			const source = options?.source ?? "system";
-			return mutate({
-				kind: "replace",
-				source
-			}, source !== "remote", (session) => session.replace([], value));
+		emit: (call) => {
+			const resetEvent = Object.freeze({ kind: "reset" });
+			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
 		},
-		snapshot: () => {
-			if (state.disposed) throw new DocumentDisposedError();
-			return copyValue(input.schema, state.document);
+		clear: () => {
+			staged.clear();
+			nextIds = published.ids();
+			change = void 0;
+			reset = false;
+			explicitOrder = void 0;
+			cleared = false;
 		},
-		subscribe: ((pick, listener) => {
-			if (state.disposed) throw new DocumentDisposedError();
-			if (!listener) return subscribeRoot(notification, pick);
-			const picks = Array.isArray(pick) ? pick : [pick];
-			if (!picks.length) throw new TypeError("Expected at least one subscription path.");
-			return subscribeTargets(notification, picks.map((p) => compilePath(input.schema, "value", p)), listener);
-		}),
-		history: history.api,
-		dispose: () => {
-			if (state.disposed) return;
-			idle();
-			state.disposed = true;
-			try {
-				disposeNotification(notification);
-			} finally {
-				history.dispose();
-				disposeRuntimeDriver(runtime);
-			}
-		}
-	};
-	bindRuntimeAccess(runtime, state);
-	bindRuntimeDriver(runtime);
-	notification = createNotification(runtime);
-	bindDocumentReadable(history.api, runtime);
-	return runtime;
-};
-//#endregion
-//#region core/src/runtime/readable.ts
-const asReadable = (runtime) => {
-	const readable = {
-		address: runtime.address,
-		revision: runtime.revision,
-		subscribe: runtime.subscribe
+		release: () => {
+			published.release();
+			staged.clear();
+			listeners.clear();
+			nextIds = Object.freeze([]);
+			change = void 0;
+			initialized = false;
+			revision = 0;
+			reset = false;
+			explicitOrder = void 0;
+			cleared = false;
+		},
+		subscribe: (listener) => listeners.add(listener),
+		unsubscribe: (listener) => listeners.delete(listener)
 	};
-	bindRuntimeAccess(readable, accessOf(runtime));
-	shareNotification(runtime, readable);
-	return Object.freeze(readable);
 };
 //#endregion
-//#region core/src/projection/select.ts
-const read = (runtime, selector) => readWith(runtime, selector);
-//#endregion
-//#region core/src/projection/value-output.ts
+//#region core/src/projection/output/value.ts
 const unset = Symbol("projection-value-unset");
 /** Owns staged and published state for one scalar Projection output. */
 const createValueOutput = () => {
@@ -1107,7 +2654,7 @@ const createValueOutput = () => {
 	};
 };
 //#endregion
-//#region core/src/projection/processor.ts
+//#region core/src/projection/graph/processor.ts
 /** Materializes every derive/incremental/group definition through one processor lifecycle. */
 const createProcessor = (scheduler, definition, dependencies) => {
 	scheduler.assertIdle();
@@ -1269,7 +2816,7 @@ const createProcessor = (scheduler, definition, dependencies) => {
 	return processor;
 };
 //#endregion
-//#region core/src/projection/projection-readable.ts
+//#region core/src/projection/readable/selection.ts
 let activeTracker;
 const trackKey = (key) => {
 	activeTracker?.keys.add(key);
@@ -1320,9 +2867,10 @@ const trackedMap = (source) => {
 };
 const selectionAffects = (selection, change) => {
 	if (!change || change.kind === "reset") return true;
-	if (selection.all && (change.added.length || change.removed.length || change.updated.length || change.order)) return true;
-	if (selection.structure && (change.added.length || change.removed.length || change.order)) return true;
-	for (const key of selection.keys) if (change.added.some((entry) => entry.key === key) || change.removed.some((entry) => entry.key === key) || change.updated.some((entry) => entry.key === key)) return true;
+	if (selection.all && collectionHasAnyChange(change)) return true;
+	if (selection.structure && collectionHasStructuralChange(change)) return true;
+	const changedKeys = collectionChangedKeys(change);
+	for (const key of selection.keys) if (changedKeys.has(key)) return true;
 	return false;
 };
 const createDirectReadable = (source) => Object.freeze({
@@ -1390,7 +2938,7 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 		if (!change && previousCollection) {
 			const current = source.current();
 			if (isMapLike(current)) {
-				change = collectionChangeBetween(previousCollection, current);
+				change = diffCollection(previousCollection, current);
 				previousCollection = current;
 				if (!change) {
 					sourceRevision = source.revision();
@@ -1429,12 +2977,321 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 	});
 };
 //#endregion
-//#region core/src/projection/source.ts
+//#region core/src/projection/source/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);
+		installOwn(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);
+		installOwn(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);
+		installOwn(nextById, key, child.present, child.value);
+	}
+	if (nextById) {
+		result = cloneRecord(previous);
+		installOwn(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);
+			installOwn(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);
+			installOwn(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);
+		installOwn(nodes, id, afterPresent, after && copyTreeNode(after));
+	}
+	if (nodes) {
+		result ??= cloneRecord(previous);
+		installOwn(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/dirty.ts
+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));
+	}
+};
+//#endregion
+//#region core/src/projection/source/boundary.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 +3333,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 +3347,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 +3389,6 @@ const createValueBoundary = (scheduler, name, initial, equality) => {
 	return {
 		producer: boundary,
 		output,
-		setLatest: (value) => {
-			latest = value;
-		},
 		mark,
 		fail,
 		detach: (next) => {
@@ -1539,7 +3396,34 @@ const createValueBoundary = (scheduler, name, initial, equality) => {
 		}
 	};
 };
-const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
+/** Applies source hints to an output draft; exact net change semantics remain in the output. */
+const stageCollectionRead = (state, read, active, options) => {
+	const evaluation = state.begin(active, options.reset);
+	if (options.reset) {
+		const ids = read.ids();
+		profile.collectionView.idsScanned(ids.length);
+		for (const key of ids) {
+			profile.collectionView.mapped();
+			evaluation.output.set(key, read.get(key));
+		}
+		evaluation.output.order(ids);
+	} else {
+		const previous = state.current(() => void 0);
+		const keys = options.candidates ? [...new Set(options.candidates)] : [...new Set([...previous.ids(), ...read.ids()])];
+		if (!options.candidates) profile.collectionView.idsScanned(keys.length);
+		for (const key of keys) if (read.has(key)) {
+			profile.collectionView.mapped();
+			evaluation.output.set(key, read.get(key));
+		} else evaluation.output.remove(key);
+		if (options.orderMayChange || !options.candidates) {
+			const ids = read.ids();
+			if (options.candidates) profile.collectionView.idsScanned(ids.length);
+			evaluation.output.order(ids);
+		}
+	}
+	return state.seal(options.reset, options.isEqual ?? Object.is);
+};
+const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSource) => {
 	const state = createCollectionOutput();
 	let boundary;
 	let pendingReset = false;
@@ -1586,7 +3470,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 +3487,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 +3496,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
 			fullScan = false;
 			orderMayChange = false;
 			candidates.clear();
+			clearSource(failed);
 		},
 		release: () => {
 			cleanup?.();
@@ -1622,7 +3508,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,33 +3544,41 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
 		}
 	};
 };
-const createSourceRegistry = (scheduler) => {
+//#endregion
+//#region core/src/projection/source/document.ts
+const documentRootTarget = Object.freeze({
+	kind: "value",
+	at: Object.freeze([])
+});
+const createDocumentSourceRegistry = (scheduler) => {
 	const documents = /* @__PURE__ */ new Map();
-	const readables = /* @__PURE__ */ new Map();
-	const externalValues = /* @__PURE__ */ new WeakMap();
-	const externalCollections = /* @__PURE__ */ new WeakMap();
-	const documentConnection = (runtime) => {
-		const state = accessOf(runtime);
+	const connection = (runtime) => {
+		const context = contextOf(runtime);
+		const state = context.state;
 		const cached = documents.get(state);
 		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);
+			state.projectionLocks += locked ? 1 : -1;
 		};
 		scheduler.guards.add(guard);
 		let closed = false;
 		let detach = () => void 0;
-		const connection = {
+		const documentConnection = {
 			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);
-					if (!bindings.size) connection.close();
+					index.delete(binding.target, binding);
+					if (!bindings.size) documentConnection.close();
 				};
 			},
 			close() {
@@ -1692,13 +3586,17 @@ const createSourceRegistry = (scheduler) => {
 				closed = true;
 				detach();
 				bindings.clear();
+				candidates.clear();
+				index.clear();
 				scheduler.guards.delete(guard);
 				documents.delete(state);
 			}
 		};
-		detach = attachProjection(runtime, {
+		detach = context.notifications.attachProjection({
 			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,
@@ -1707,20 +3605,175 @@ const createSourceRegistry = (scheduler) => {
 				scheduler.run();
 			}
 		});
-		documents.set(state, connection);
-		return connection;
+		documents.set(state, documentConnection);
+		return documentConnection;
+	};
+	const materialize = (definition) => {
+		if (definition.source.kind !== "document") throw new Error("Invalid document source.");
+		const { document, selector } = definition.source;
+		const state = contextOf(document).state;
+		const current = () => resolveValue(state.schema, state.document, selector.address);
+		const disposed = () => {
+			if (state.disposed) throw new Error("Document has been disposed.");
+		};
+		if (selector.kind === "value") {
+			const dirty = createDocumentDirty();
+			const read = (previous) => {
+				disposed();
+				const resolved = current();
+				const node = resolved?.node;
+				const value = resolved?.value;
+				if (selector.tree?.kind === "root") return node?.kind === "tree" && isRecord(value) && typeof value.rootId === "string" ? value.rootId : void 0;
+				if (selector.tree?.kind === "node") {
+					if (node?.kind !== "tree" || !isRecord(value) || !isRecord(value.nodes)) return void 0;
+					const entry = Object.hasOwn(value.nodes, selector.tree.id) ? value.nodes[selector.tree.id] : void 0;
+					if (equalTreeNode(previous, entry)) return previous;
+					return entry ? copyTreeNode(entry) : void 0;
+				}
+				if (!node) return void 0;
+				return previous === void 0 ? copyValue(node, value) : materializeDocumentValue(node, previous, value, 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 = connection(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 resolved = current();
+			const node = resolved?.node;
+			const value = resolved?.value;
+			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)) 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,
+				ids
+			});
+		};
+		let boundary;
+		boundary = createCollectionBoundary(scheduler, "document collection source", read, Object.is, (failed) => {
+			if (failed) resetCollectionPending(pending);
+			else clearCollectionPending(pending);
+		});
+		const remove = connection(document).add({
+			target: selector,
+			capture: (commit) => {
+				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);
+				}
+			},
+			dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
+		});
+		boundary.detach(remove);
+		return boundary;
+	};
+	return {
+		materialize,
+		attachRoot(runtime, handlers) {
+			return connection(runtime).add({
+				target: documentRootTarget,
+				capture: handlers.capture,
+				dispose: handlers.dispose
+			});
+		},
+		dispose() {
+			documents.forEach((document) => document.close());
+			documents.clear();
+		}
 	};
+};
+//#endregion
+//#region core/src/projection/source/registry.ts
+const createSourceRegistry = (scheduler) => {
+	const documents = createDocumentSourceRegistry(scheduler);
+	const readables = /* @__PURE__ */ new Map();
+	const externalValues = /* @__PURE__ */ new WeakMap();
+	const externalCollections = /* @__PURE__ */ new WeakMap();
 	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 +3783,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,103 +3859,15 @@ const createSourceRegistry = (scheduler) => {
 			}
 		};
 	};
-	const documentValue = (definition) => {
-		if (definition.source.kind !== "document-value") throw new Error("Invalid document value 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 = () => {
-			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);
-				}
-			},
-			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);
-			const snapshots = /* @__PURE__ */ new Map();
-			return Object.freeze({
-				get: (key) => {
-					assertScope(active);
-					if (!snapshots.has(key)) snapshots.set(key, snapshot(raw.get(key)));
-					return snapshots.get(key);
-				},
-				has: (key) => {
-					assertScope(active);
-					return raw.has(key);
-				},
-				ids: () => {
-					assertScope(active);
-					return raw.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);
-		});
-		const remove = documentConnection(document).add({
-			matches: (commit) => affectsTarget(commit.impact, selector),
-			capture: (commit) => {
-				const impact = collectionImpact(commit.impact, selector);
-				if (impact.kind === "reset") {
-					boundary.mark({ reset: true });
-					return;
-				}
-				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."))
-		});
-		boundary.detach(remove);
-		return boundary;
-	};
 	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);
 			}
 		};
@@ -1932,9 +3897,8 @@ const createSourceRegistry = (scheduler) => {
 					readables.delete(readable);
 				}
 			};
-			const owner = documentReadableOwner(readable);
-			if (owner) detachDocument = documentConnection(owner).add({
-				matches: () => true,
+			const owner = contextOf(readable, false)?.owner;
+			if (owner) detachDocument = documents.attachRoot(owner, {
 				capture: () => receive(false),
 				dispose: () => {
 					members.forEach((next) => next.boundary.fail(/* @__PURE__ */ new Error("Document has been disposed.")));
@@ -1954,11 +3918,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 +3977,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,17 +4040,15 @@ 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 documents.materialize(definition);
 				case "readable": return readable(definition);
 				case "external-value": return externalValue(definition);
 				case "external-collection": return externalCollection(definition);
 			}
 		},
 		dispose() {
-			documents.forEach((connection) => connection.close());
+			documents.dispose();
 			readables.forEach((connection) => connection.close());
-			documents.clear();
 			readables.clear();
 		}
 	};
@@ -2329,6 +4292,6 @@ const createProjectionRuntime = (options) => {
 	});
 };
 //#endregion
-export { DocumentDisposedError, DocumentReentrancyError, ParseError, ProjectionDisposedError, ProjectionError, TransactionRejected, asReadable, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, snapshot, table, tree, variant };
+export { DocumentDisposedError, DocumentReentrancyError, ParseError, ProjectionDisposedError, ProjectionError, TransactionRejected, asReadable, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
 
 //# sourceMappingURL=index.js.map