doxum 0.1.5 → 0.1.7

package/dist/index.js

@@ -1,5 +1,5 @@
-import { A as optional, C as resolveLocated, D as list, E as field, F as tree, I as variant, M as schema, N as single, O as map, P as table, S as resolveAddress, T as dict, _ as debugKey, a as readWith, b as overlaps, c as DocumentReentrancyError, d as address$2, f as belongs, g as contains, h as impact_target_exports, i as documentOf, j as record, k as object, l as documentReader, m as id, n as accessOf, o as schemaOf, p as bucket, r as bindRuntimeAccess, s as DocumentDisposedError, t as createDependencyTracker, u as readerFor, v as locate, w as set$1, x as read, y as nodeAt$1 } from "./dependency-C5_R1tvQ.js";
-import { a as isStablePayload, c as snapshotPayload, i as isRecord, l as transferPayload, n as deepEqual, o as ownPayload, r as isPlainObject, s as sameStructuralValue, t as cloneValue, u as profile } from "./ownership-B-VAPcce.js";
+import { A as id, B as set$1, C as restore, D as DocumentReentrancyError, E as DocumentDisposedError, F as locate, G as object, H as field, I as overlaps, J as table, K as optional, L as read, N as contains$1, O as address$1, P as debugKey, R as resolveAddress, S as keys, T as validPositions, U as list, V as dict, W as map, X as variant, Y as tree, a as bindDocumentReadable, b as at$1, c as notify, d as subscribeTargets, f as accessOf, h as commandFootprint, i as ProjectionError, j as impact_target_exports, k as belongs, l as shareNotification, m as readWith, o as createNotification, p as bindRuntimeAccess, q as schema, r as ProjectionDisposedError, s as disposeNotification, t as createProjectionRuntime, u as subscribeRoot, v as documentReader, w as valid, x as index, y as afterRemove, z as resolveLocated } from "./runtime-DF1q9Gje.js";
+import { a as isStablePayload, c as snapshotPayload, i as isRecord, l as transferPayload, n as deepEqual, o as ownPayload, r as isPlainObject, s as sameStructuralValue, t as cloneValue, u as profile } from "./ownership-CduRygE7.js";
 import { n as bindRuntimeDriver, r as disposeRuntimeDriver, t as assertRuntimeWritable } from "./driver-CbzfW5MR.js";
 //#region core/src/impact.ts
 const emptyCollectionImpact = Object.freeze({
@@ -38,9 +38,9 @@ const createImpact = (input) => {
 			profile.impact.affects();
 			if (kind === "reset") return true;
 			if (!belongs(value, input.schema)) return false;
-			if (pathsAffect(address$2(value))) return true;
+			if (pathsAffect(address$1(value))) return true;
 			if (value.kind === "collection") {
-				const collection = findCollection(address$2(value));
+				const collection = findCollection(address$1(value));
 				if (!collection) return false;
 				const id$1 = id(value);
 				if (id$1 !== void 0) return collection.added.has(id$1) || collection.removed.has(id$1) || collection.updated.has(id$1);
@@ -54,7 +54,7 @@ const createImpact = (input) => {
 			const cached = collectionCache?.find((entry) => entry.address.length === selector.address.length && entry.address.every((segment, index) => segment === selector.address[index]))?.value;
 			if (cached) return cached;
 			const exact = findCollection(selector.address);
-			if (somePath(selector.address, (changed) => contains(changed, selector.address) && changed.length < selector.address.length)) {
+			if (somePath(selector.address, (changed) => contains$1(changed, selector.address) && changed.length < selector.address.length)) {
 				const reset = { kind: "reset" };
 				(collectionCache ??= []).push({
 					address: selector.address,
@@ -88,78 +88,170 @@ const createImpact = (input) => {
 //#endregion
 //#region core/src/history.ts
 const createHistory = (input) => {
-	const undos = [];
-	const redos = [];
+	let undos = [];
+	let redos = [];
 	const listeners = /* @__PURE__ */ new Set();
 	let state = Object.freeze({
 		undoDepth: 0,
 		redoDepth: 0
 	});
-	const current = () => {
-		if (state.undoDepth !== undos.length || state.redoDepth !== redos.length) state = Object.freeze({
+	let revision = 0;
+	let pending = false;
+	let disposed = false;
+	let group;
+	const unchanged = () => ({
+		status: "unchanged",
+		revision: input.revision()
+	});
+	const publish = () => {
+		if (state.undoDepth === undos.length && state.redoDepth === redos.length) return;
+		state = Object.freeze({
 			undoDepth: undos.length,
 			redoDepth: redos.length
 		});
-		return state;
-	};
-	const emit = () => {
-		if (listeners.size === 0) return;
-		current();
-		Array.from(listeners).forEach((listener) => listener());
+		revision++;
+		pending = true;
+	};
+	const flush = () => {
+		if (!pending) return [];
+		pending = false;
+		const errors = [];
+		for (const listener of [...listeners]) {
+			if (!listeners.has(listener)) continue;
+			try {
+				listener();
+			} catch (error) {
+				errors.push({
+					phase: "listener",
+					error
+				});
+			}
+		}
+		return errors;
 	};
 	const clear = () => {
-		if (undos.length || redos.length) {
-			undos.length = 0;
-			redos.length = 0;
-			emit();
+		group = void 0;
+		undos.length = redos.length = 0;
+		publish();
+	};
+	const travel = (direction) => {
+		input.assertIdle();
+		const from = direction === "redo" ? redos : undos;
+		const to = direction === "redo" ? undos : redos;
+		const previousUndos = undos;
+		const previousRedos = redos;
+		const entry = direction === "cancel" ? from.at(-1) : from.pop();
+		if (!entry) return unchanged();
+		if (direction === "cancel") {
+			if (!group || group.entry !== entry) throw new Error("History group no longer owns its entry.");
+			undos = group.undos;
+			redos = group.redos;
+		} else to.push(entry);
+		let committed = false;
+		try {
+			const operations = direction === "redo" ? entry.batches.flatMap((batch) => batch.operations) : entry.batches.slice().reverse().flatMap((batch) => batch.inverse);
+			const result = input.apply(operations);
+			committed = result.status !== "rejected";
+			if (committed && direction === "cancel") group = void 0;
+			if (result.status === "unchanged") {
+				publish();
+				const errors = input.notify(flush);
+				if (errors.length) throw new AggregateError(errors.map((entry) => entry.error), "History listeners failed.");
+			}
+			return result;
+		} finally {
+			if (!committed) if (direction === "cancel") {
+				undos = previousUndos;
+				redos = previousRedos;
+			} else {
+				to.pop();
+				from.push(entry);
+			}
 		}
 	};
 	return {
 		api: {
-			current,
+			current: () => state,
+			revision: () => revision,
 			subscribe: (listener) => {
+				if (disposed) throw new DocumentDisposedError();
 				listeners.add(listener);
-				return () => listeners.delete(listener);
+				return () => {
+					listeners.delete(listener);
+				};
 			},
 			undo: () => {
-				const entry = undos.pop();
-				if (!entry) return {
-					status: "unchanged",
-					revision: input.revision()
-				};
-				const result = input.apply(entry.inverse);
-				if (result.status === "committed") {
-					redos.push(entry);
-					emit();
-				} else undos.push(entry);
-				return result;
+				input.assertIdle();
+				group = void 0;
+				return travel("undo");
 			},
 			redo: () => {
-				const entry = redos.pop();
-				if (!entry) return {
-					status: "unchanged",
-					revision: input.revision()
-				};
-				const result = input.apply(entry.operations);
-				if (result.status === "committed") {
-					undos.push(entry);
-					emit();
-				} else redos.push(entry);
-				return result;
+				input.assertIdle();
+				group = void 0;
+				return travel("redo");
 			},
-			clear
+			clear: () => {
+				input.assertIdle();
+				clear();
+				const errors = input.notify(flush);
+				if (errors.length) throw new AggregateError(errors.map((entry) => entry.error), "History listeners failed.");
+			},
+			group: () => {
+				input.assertIdle();
+				if (group) throw new Error("A history group is already active.");
+				if (input.capacity <= 0) throw new Error("History is disabled.");
+				const scope = {
+					undos: undos.slice(),
+					redos: redos.slice()
+				};
+				group = scope;
+				return Object.freeze({
+					end: () => {
+						input.assertIdle();
+						if (group === scope) group = void 0;
+					},
+					cancel: () => {
+						input.assertIdle();
+						if (group !== scope) return unchanged();
+						if (!scope.entry) {
+							group = void 0;
+							return unchanged();
+						}
+						const result = travel("cancel");
+						if (result.status !== "rejected") group = void 0;
+						return result;
+					}
+				});
+			}
 		},
 		record: (operations, inverse) => {
 			if (input.capacity <= 0) return;
-			undos.push({
+			const batch = {
 				operations,
 				inverse
-			});
-			if (undos.length > input.capacity) undos.shift();
+			};
+			if (group?.entry) group.entry.batches.push(batch);
+			else {
+				const entry = { batches: [batch] };
+				undos.push(entry);
+				if (group) group.entry = entry;
+				if (undos.length > input.capacity) undos.shift();
+			}
 			redos.length = 0;
-			emit();
+			publish();
+		},
+		publish,
+		flush,
+		endGroup: () => {
+			group = void 0;
 		},
-		invalidate: clear
+		invalidate: clear,
+		dispose: () => {
+			disposed = true;
+			listeners.clear();
+			clear();
+			pending = false;
+		}
 	};
 };
 //#endregion
@@ -179,7 +271,7 @@ const writerFor = (node, inputAddress, sink) => {
 			at: address
 		}) : void 0
 	};
-	if (node.kind === "dict" || node.kind === "record") return {
+	if (node.kind === "dict") return {
 		set: (key, value) => emit(sink, {
 			type: "dict.set",
 			at: address,
@@ -232,20 +324,20 @@ const writerFor = (node, inputAddress, sink) => {
 		}) } : {}
 	};
 	if (node.kind === "tree") return {
-		insert: (treeNodeId, value, parentId, index) => emit(sink, {
+		insert: (treeNodeId, value, position) => emit(sink, {
 			type: "tree.insert",
 			at: address,
 			treeNodeId,
 			value,
-			parentId,
-			index
+			parentId: position?.parentId,
+			index: position?.index
 		}),
-		move: (treeNodeId, parentId, index) => emit(sink, {
+		move: (treeNodeId, position) => emit(sink, {
 			type: "tree.move",
 			at: address,
 			treeNodeId,
-			parentId,
-			index
+			parentId: position?.parentId,
+			index: position?.index
 		}),
 		remove: (treeNodeId) => emit(sink, {
 			type: "tree.remove",
@@ -329,7 +421,6 @@ const writerFor = (node, inputAddress, sink) => {
 			})
 		};
 	}
-	if (node.kind === "single") return writerFor(node.value, address, sink);
 	if (node.kind === "variant") return {
 		replace: (value) => emit(sink, {
 			type: "variant.replace",
@@ -355,69 +446,15 @@ const documentWriter = (schema, sink) => writerFor(schemaRoot(schema), [], sink)
 //#endregion
 //#region core/src/mutation/issue.ts
 const ownAddress$1 = (address) => Object.freeze(address.slice());
-const at$1 = (address, code, message, operation) => Object.freeze({
+const at = (address, code, message, operation) => Object.freeze({
 	source: "mutation",
 	code,
 	address: ownAddress$1(address),
 	message,
 	...operation === void 0 ? {} : { operation }
 });
-const from = (operation, code, message) => at$1(operation.at, code, message, operation.type);
-const input = (code, message) => at$1([], code, message);
-//#endregion
-//#region core/src/mutation/anchor.ts
-const length = (keys) => keys.length;
-const keyAt = (keys, index) => Array.isArray(keys) ? keys[index] : keys.at(index);
-const keyIndex = (keys, key) => Array.isArray(keys) ? keys.indexOf(key) : keys.index(key);
-const keys = (values, keyOf) => ({
-	length: values.length,
-	at: (index) => index >= 0 && index < values.length ? keyOf(values[index]) : void 0,
-	index: (key) => {
-		for (let index = 0; index < values.length; index += 1) if (keyOf(values[index]) === key) return index;
-		return -1;
-	}
-});
-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 at = (keys, position) => position <= 0 ? { at: "start" } : { after: keyAt(keys, position - 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;
-};
-const afterRemove = (keys, removedIndex, anchor) => {
-	const position = index(keys, anchor);
-	return position > removedIndex ? position - 1 : position;
-};
-const validPositions = (length, positions) => {
-	let previous = -1;
-	for (let index = 0; index < positions.length; index += 1) {
-		const position = positions[index];
-		if (!Number.isInteger(position) || position < 0 || position <= previous || position > length + index) return false;
-		previous = position;
-	}
-	return true;
-};
-const restore = (keys, inserted, positions) => {
-	const currentLength = keys.length;
-	if (inserted.length !== positions.length || !validPositions(currentLength, positions)) throw new Error("Ordered restore positions are invalid.");
-	let readIndex = currentLength - 1;
-	let insertedIndex = inserted.length - 1;
-	keys.length = currentLength + inserted.length;
-	for (let writeIndex = keys.length - 1; writeIndex >= 0; writeIndex -= 1) if (insertedIndex >= 0 && positions[insertedIndex] === writeIndex) {
-		keys[writeIndex] = inserted[insertedIndex];
-		insertedIndex -= 1;
-	} else {
-		keys[writeIndex] = keys[readIndex];
-		readIndex -= 1;
-	}
-};
+const from = (operation, code, message) => at(operation.at, code, message, operation.type);
+const input = (code, message) => at([], code, message);
 //#endregion
 //#region core/src/mutation/execute-entity.ts
 const resolveEntityCollection = (node, value) => {
@@ -542,7 +579,7 @@ const executeEntity = (target, operation, copyPayload) => {
 		type: "entity.move",
 		at: operation.at,
 		id: operation.id,
-		anchor: at(ids, position)
+		anchor: at$1(ids, position)
 	};
 	ids.splice(position, 1);
 	ids.splice(nextIndex, 0, operation.id);
@@ -617,7 +654,7 @@ const executeList = (target, operation, copyPayload) => {
 			at: operation.at,
 			key: operation.key,
 			value: cloneValue(list[position], "inverse"),
-			anchor: at(orderedKeys, position)
+			anchor: at$1(orderedKeys, position)
 		};
 		list.splice(position, 1);
 		return {
@@ -633,7 +670,7 @@ const executeList = (target, operation, copyPayload) => {
 		type: "list.move",
 		at: operation.at,
 		key: operation.key,
-		anchor: at(orderedKeys, position)
+		anchor: at$1(orderedKeys, position)
 	};
 	const [entry] = list.splice(position, 1);
 	list.splice(nextIndex, 0, entry);
@@ -816,7 +853,7 @@ const changeChanged = (change, value) => {
 	return false;
 };
 const is = (value) => isRecord(value) && isRecord(value.nodes);
-const contains$1 = (tree, id) => has$1(tree.nodes, id);
+const contains = (tree, id) => has$1(tree.nodes, id);
 const validate = (value) => {
 	if (!is(value)) return false;
 	const ids = Object.keys(value.nodes);
@@ -858,7 +895,6 @@ const documentTreeError = (node, value, address) => {
 		}
 		return;
 	}
-	if (node.kind === "single") return documentTreeError(node.value, value, address);
 	if (node.kind === "variant") {
 		if (!isRecord(value) || typeof value[node.tag] !== "string") return void 0;
 		const variant = node.variants[value[node.tag]];
@@ -897,7 +933,7 @@ const replace = (current, operation) => {
 	};
 };
 const insert = (tree, operation, value) => {
-	if (contains$1(tree, operation.treeNodeId)) return rejected$2("duplicate-tree-node", `Tree node '${operation.treeNodeId}' already exists.`);
+	if (contains(tree, operation.treeNodeId)) return rejected$2("duplicate-tree-node", `Tree node '${operation.treeNodeId}' already exists.`);
 	if (!validIndex(operation.index)) return rejected$2("invalid-tree-index", "Tree index is invalid.");
 	if (tree.rootId === void 0) {
 		if (operation.parentId !== void 0) return rejected$2("missing-tree-parent", `Tree parent '${operation.parentId}' does not exist.`);
@@ -1022,9 +1058,8 @@ const move = (tree, operation) => {
 	if (!currentParent || parentId === void 0) return rejected$2("invalid-tree", "Tree parent links are inconsistent.");
 	const originalIndex = childIndex(currentParent, operation.treeNodeId);
 	if (originalIndex < 0) return rejected$2("invalid-tree", "Tree parent links are inconsistent.");
-	let nextIndex = Math.min(operation.index ?? nextParent.children.length, nextParent.children.length);
 	currentParent.children.splice(originalIndex, 1);
-	if (parentId === operation.parentId && nextIndex > originalIndex) nextIndex -= 1;
+	const nextIndex = Math.min(operation.index ?? nextParent.children.length, nextParent.children.length);
 	if (parentId === operation.parentId && nextIndex === originalIndex) {
 		currentParent.children.splice(originalIndex, 0, operation.treeNodeId);
 		return { status: "unchanged" };
@@ -1128,6 +1163,16 @@ const executeValue = (target, operation, copyPayload) => {
 	}
 	if (operation.type === "variant.replace") {
 		if (sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
+		if (target.value === void 0 && target.node.optional) {
+			target.parent[target.key] = own(operation.value);
+			return {
+				status: "changed",
+				inverse: [{
+					type: "value.clear",
+					at: operation.at
+				}]
+			};
+		}
 		const inverse = {
 			type: "variant.replace",
 			at: operation.at,
@@ -1206,7 +1251,7 @@ const executeClear = (target, operation) => {
 		issue: from(operation, "required-field", "Only optional values can be cleared.")
 	};
 	if (!hasOwn$1(target.parent, target.key)) return { status: "unchanged" };
-	if (target.node.kind !== "field" && target.node.kind !== "variant" && target.node.kind !== "dict" && target.node.kind !== "record" && target.node.kind !== "list" && target.node.kind !== "tree") return {
+	if (target.node.kind !== "field" && target.node.kind !== "variant" && target.node.kind !== "dict" && target.node.kind !== "list" && target.node.kind !== "tree") return {
 		status: "rejected",
 		issue: from(operation, "invalid-operation", "This optional value has no clear operation.")
 	};
@@ -1222,8 +1267,7 @@ const executeClear = (target, operation) => {
 				at: operation.at,
 				value: cloneValue(target.value, "inverse")
 			};
-			case "dict":
-			case "record": return {
+			case "dict": return {
 				type: "dict.replace",
 				at: operation.at,
 				value: cloneValue(target.value, "inverse")
@@ -1262,7 +1306,7 @@ const execute = (root, operation, target, copyPayload) => {
 	if (operation.type === "value.clear") return !target ? invalidTarget(operation) : executeClear(target, operation);
 	if (operation.type === "field.set" || operation.type === "field.clear") return !target || target.node.kind !== "field" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
 	if (operation.type === "variant.replace") return !target || target.node.kind !== "variant" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
-	if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") return !target || target.node.kind !== "dict" && target.node.kind !== "record" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
+	if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") return !target || target.node.kind !== "dict" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
 	if (operation.type === "entity.create" || operation.type === "entity.remove" || operation.type === "entity.move") return !target || target.node.kind !== "table" && target.node.kind !== "map" ? invalidTarget(operation) : executeEntity(target, operation, copyPayload);
 	if (operation.type === "list.insert" || operation.type === "list.move" || operation.type === "list.remove" || operation.type === "list.replace") return !target || target.node.kind !== "list" ? invalidTarget(operation) : executeList(target, operation, copyPayload);
 	if (operation.type === "tree.insert" || operation.type === "tree.move" || operation.type === "tree.remove" || operation.type === "tree.set" || operation.type === "tree.replace") return !target || target.node.kind !== "tree" ? invalidTarget(operation) : executeTree(root, target, operation, copyPayload);
@@ -1275,7 +1319,7 @@ const execute = (root, operation, target, copyPayload) => {
 //#region core/src/mutation/journal.ts
 const indexNode = () => ({ children: /* @__PURE__ */ new Map() });
 const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-const sameAddress$1 = (left, right) => {
+const sameAddress = (left, right) => {
 	if (left.length !== right.length) return false;
 	for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false;
 	return true;
@@ -1374,7 +1418,7 @@ const restoreEntity = (value, subject) => {
 };
 const restoreRootSubject = (value, subject) => {
 	if (subject.kind === "value") return subject.before.status === "present" ? subject.before.value : void 0;
-	if (subject.kind === "variant") return subject.before;
+	if (subject.kind === "variant") return subject.before.status === "present" ? subject.before.value : void 0;
 	if (subject.kind === "dict") {
 		if (isRecord(value)) restoreDict(value, subject.state);
 		return value;
@@ -1390,14 +1434,14 @@ const restoreRootSubject = (value, subject) => {
 	return restoreChange(value, subject.state);
 };
 const restoreSubject = (value, prefix, subject) => {
-	if (sameAddress$1(prefix, subject.address)) return restoreRootSubject(value, subject);
+	if (sameAddress(prefix, subject.address)) return restoreRootSubject(value, subject);
 	const address = subject.address.slice(prefix.length);
 	if (subject.kind === "value") {
 		writePresence(value, address, subject.before);
 		return value;
 	}
 	if (subject.kind === "variant") {
-		writeContainer(value, address, subject.before);
+		writePresence(value, address, subject.before);
 		return value;
 	}
 	const current = read(value, address);
@@ -1498,7 +1542,11 @@ const analyzeEntity = (root, subject) => {
 };
 const subjectChanged = (root, subject) => {
 	if (subject.kind === "value") return valueChanged(root, subject);
-	if (subject.kind === "variant") return !sameStructuralValue(subject.before, read(root, subject.address));
+	if (subject.kind === "variant") {
+		const target = locate(root, subject.address);
+		const exists = !!target && hasOwn(target.parent, target.key);
+		return subject.before.status === "absent" ? exists : !exists || !sameStructuralValue(subject.before.value, target?.value);
+	}
 	if (subject.kind === "dict") return dictChanged(root, subject);
 	if (subject.kind === "list") return listChanged(root, subject);
 	return changeChanged(subject.state, read(root, subject.address));
@@ -1617,7 +1665,7 @@ const createChangeJournal = (root) => {
 		const candidates = buckets.get(addressHash) ?? [];
 		for (const subject of candidates) {
 			profile.journal.comparison();
-			if (subject.kind === kind && sameAddress$1(subject.address, address)) return subject;
+			if (subject.kind === kind && sameAddress(subject.address, address)) return subject;
 		}
 	}
 	const ownerOf = (address) => {
@@ -1660,11 +1708,11 @@ const createChangeJournal = (root) => {
 	const recordVariant = (resolved, operation, inverse) => {
 		if (find("variant", operation.at, resolved.addressHash)) return;
 		const first = inverse[0];
-		if (first?.type !== "variant.replace") return inverseMismatch(operation);
+		if (first?.type !== "variant.replace" && first?.type !== "value.clear") return inverseMismatch(operation);
 		add({
 			...base(resolved, operation),
 			kind: "variant",
-			before: absorb(first.value, operation.at)
+			before: first.type === "value.clear" ? absent : present(absorb(first.value, operation.at))
 		});
 	};
 	const recordDict = (resolved, operation, inverse) => {
@@ -1828,6 +1876,10 @@ const createChangeJournal = (root) => {
 		record: (resolved, operation, inverse) => {
 			profile.batch.journalRecord();
 			if (ownerOf(operation.at)) return;
+			if (operation.type === "value.clear" && resolved.node.kind === "variant") {
+				recordVariant(resolved, operation, inverse);
+				return;
+			}
 			if (operation.type === "field.set" || operation.type === "field.clear" || operation.type === "value.clear") {
 				recordValue(resolved, operation, inverse);
 				return;
@@ -1869,7 +1921,7 @@ const createChangeJournal = (root) => {
 			const changeAt = (address, addressHash) => {
 				const candidates = collectionBuckets.get(addressHash) ?? [];
 				collectionBuckets.set(addressHash, candidates);
-				let change = candidates.find((entry) => sameAddress$1(entry.address, address));
+				let change = candidates.find((entry) => sameAddress(entry.address, address));
 				if (!change) {
 					change = {
 						address,
@@ -1913,7 +1965,7 @@ const createChangeJournal = (root) => {
 const has = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
 const stringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
 const positions = (value) => Array.isArray(value) && value.every((entry) => Number.isInteger(entry) && entry >= 0);
-const address$1 = (value) => stringArray(value);
+const address = (value) => stringArray(value);
 const anchor = (value) => {
 	if (!isRecord(value)) return false;
 	if (Number(has(value, "at")) + Number(has(value, "before")) + Number(has(value, "after")) !== 1) return false;
@@ -1934,7 +1986,7 @@ const rejected = (code, message) => ({
 });
 const decode = (input) => {
 	if (!isRecord(input)) return rejected("invalid-operation", "Operation must be an object.");
-	if (!address$1(input.at)) return rejected("invalid-address", "Operation address is malformed.");
+	if (!address(input.at)) return rejected("invalid-address", "Operation address is malformed.");
 	if (typeof input.type !== "string") return rejected("invalid-operation", "Operation type must be a string.");
 	switch (input.type) {
 		case "field.set":
@@ -2110,352 +2162,6 @@ const mutateOperations = (root, schema, operations, options = {}) => {
 	return session.finish();
 };
 //#endregion
-//#region core/src/mutation/footprint.ts
-const sameAddress = (left, right) => left.length === right.length && left.every((segment, index) => segment === right[index]);
-const containsAddress = (parent, child) => parent.length <= child.length && parent.every((segment, index) => segment === child[index]);
-const address = (value) => Array.isArray(value) && value.every((segment) => typeof segment === "string") ? Object.freeze(value.slice()) : void 0;
-const targetKey = (target) => {
-	const at = target.at.join("\0");
-	if (target.kind === "dictionary-key" || target.kind === "list-item") return `${target.kind}:${at}:${target.key}`;
-	if (target.kind === "entity" || target.kind === "tree-node") return `${target.kind}:${at}:${target.id}`;
-	return `${target.kind}:${at}`;
-};
-const freezeTarget = (target) => Object.freeze({
-	...target,
-	at: Object.freeze(target.at.slice())
-});
-const add = (targets, target) => {
-	const stable = freezeTarget(target);
-	targets.set(targetKey(stable), stable);
-};
-const commandFootprint = (operations) => {
-	const targets = /* @__PURE__ */ new Map();
-	for (const operation of operations) switch (operation.type) {
-		case "field.set":
-		case "field.clear":
-		case "value.clear":
-		case "variant.replace":
-			add(targets, {
-				kind: "value",
-				at: operation.at
-			});
-			break;
-		case "dict.replace":
-			add(targets, {
-				kind: "dictionary",
-				at: operation.at
-			});
-			break;
-		case "dict.set":
-		case "dict.delete":
-			add(targets, {
-				kind: "dictionary-key",
-				at: operation.at,
-				key: operation.key
-			});
-			break;
-		case "entity.create":
-			add(targets, {
-				kind: "collection",
-				at: operation.at
-			});
-			for (const entry of operation.entries) add(targets, {
-				kind: "entity",
-				at: operation.at,
-				id: entry.id
-			});
-			break;
-		case "entity.remove":
-			add(targets, {
-				kind: "collection",
-				at: operation.at
-			});
-			for (const id of operation.ids) add(targets, {
-				kind: "entity",
-				at: operation.at,
-				id
-			});
-			break;
-		case "entity.move":
-			add(targets, {
-				kind: "collection",
-				at: operation.at
-			});
-			add(targets, {
-				kind: "entity",
-				at: operation.at,
-				id: operation.id
-			});
-			break;
-		case "list.insert":
-		case "list.move":
-		case "list.remove":
-			add(targets, {
-				kind: "list",
-				at: operation.at
-			});
-			add(targets, {
-				kind: "list-item",
-				at: operation.at,
-				key: operation.key
-			});
-			break;
-		case "list.replace":
-			add(targets, {
-				kind: "list",
-				at: operation.at
-			});
-			for (const key of operation.keys) add(targets, {
-				kind: "list-item",
-				at: operation.at,
-				key
-			});
-			break;
-		case "tree.insert":
-		case "tree.move":
-		case "tree.remove":
-		case "tree.set":
-			add(targets, {
-				kind: "tree",
-				at: operation.at
-			});
-			add(targets, {
-				kind: "tree-node",
-				at: operation.at,
-				id: operation.treeNodeId
-			});
-			break;
-		case "tree.replace":
-			add(targets, {
-				kind: "tree",
-				at: operation.at
-			});
-			break;
-	}
-	return Object.freeze(Array.from(targets.values()));
-};
-const overlapsValueAndEntity = (value, entity) => containsAddress([...entity.at, entity.id], value.at) || containsAddress(value.at, [...entity.at, entity.id]);
-const targetsOverlap = (left, right) => {
-	if (left.kind === "value" && right.kind === "value") return containsAddress(left.at, right.at) || containsAddress(right.at, left.at);
-	if (left.kind === "value" && right.kind === "entity") return overlapsValueAndEntity(left, right);
-	if (left.kind === "entity" && right.kind === "value") return overlapsValueAndEntity(right, left);
-	if (left.kind === "dictionary" && right.kind === "dictionary") return sameAddress(left.at, right.at);
-	if (left.kind === "dictionary" && right.kind === "dictionary-key") return sameAddress(left.at, right.at);
-	if (left.kind === "dictionary-key" && right.kind === "dictionary") return sameAddress(left.at, right.at);
-	if (left.kind === "dictionary-key" && right.kind === "dictionary-key") return sameAddress(left.at, right.at) && left.key === right.key;
-	if (left.kind === "collection" && right.kind === "collection") return sameAddress(left.at, right.at);
-	if (left.kind === "collection" && right.kind === "entity") return sameAddress(left.at, right.at);
-	if (left.kind === "entity" && right.kind === "collection") return sameAddress(left.at, right.at);
-	if (left.kind === "entity" && right.kind === "entity") return sameAddress(left.at, right.at) && left.id === right.id;
-	if (left.kind === "list" && (right.kind === "list" || right.kind === "list-item")) return sameAddress(left.at, right.at);
-	if (right.kind === "list" && left.kind === "list-item") return sameAddress(left.at, right.at);
-	if (left.kind === "list-item" && right.kind === "list-item") return sameAddress(left.at, right.at) && left.key === right.key;
-	if (left.kind === "tree" && (right.kind === "tree" || right.kind === "tree-node")) return sameAddress(left.at, right.at);
-	if (right.kind === "tree" && left.kind === "tree-node") return sameAddress(left.at, right.at);
-	if (left.kind === "tree-node" && right.kind === "tree-node") return sameAddress(left.at, right.at) && left.id === right.id;
-	return false;
-};
-const footprintsOverlap = (left, right) => left.some((leftTarget) => right.some((rightTarget) => targetsOverlap(leftTarget, rightTarget)));
-const decodedTarget = (value) => {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-	const record = value;
-	const at = address(record.at);
-	if (!at || typeof record.kind !== "string") return void 0;
-	switch (record.kind) {
-		case "value":
-		case "dictionary":
-		case "collection":
-		case "list":
-		case "tree": return freezeTarget({
-			kind: record.kind,
-			at
-		});
-		case "dictionary-key":
-		case "list-item": return typeof record.key === "string" ? freezeTarget({
-			kind: record.kind,
-			at,
-			key: record.key
-		}) : void 0;
-		case "entity":
-		case "tree-node": return typeof record.id === "string" ? freezeTarget({
-			kind: record.kind,
-			at,
-			id: record.id
-		}) : void 0;
-		default: return;
-	}
-};
-const decodeCommandFootprint = (value) => {
-	if (!Array.isArray(value)) return void 0;
-	const targets = /* @__PURE__ */ new Map();
-	for (const entry of value) {
-		const target = decodedTarget(entry);
-		if (!target) return void 0;
-		targets.set(targetKey(target), target);
-	}
-	return Object.freeze(Array.from(targets.values()));
-};
-//#endregion
-//#region core/src/runtime/notification.ts
-const ROOT_BUCKET = Symbol("document-root");
-const notifications = /* @__PURE__ */ new WeakMap();
-const key = (value) => bucket(value) ?? ROOT_BUCKET;
-const createNotification = (runtime) => {
-	const notification = {
-		root: /* @__PURE__ */ new Set(),
-		filtered: /* @__PURE__ */ new Set(),
-		buckets: /* @__PURE__ */ new Map(),
-		processors: [],
-		candidates: /* @__PURE__ */ new Set(),
-		rootSnapshot: [],
-		notifying: false
-	};
-	notifications.set(runtime, notification);
-	return notification;
-};
-const notificationOf = (runtime) => {
-	const value = notifications.get(runtime);
-	if (!value) throw new Error("Unknown Doxum runtime.");
-	return value;
-};
-const shareNotification = (source, target) => {
-	notifications.set(target, notificationOf(source));
-};
-const registerProcessor = (runtime, processor) => {
-	const notification = notificationOf(runtime);
-	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 subscribeRoot = (notification, listener) => {
-	const entry = {
-		listener,
-		active: true
-	};
-	notification.root.add(entry);
-	return () => {
-		entry.active = false;
-		if (!notification.notifying) notification.root.delete(entry);
-	};
-};
-const subscribeTargets = (notification, targets, listener) => {
-	const entry = {
-		targets: Object.freeze(targets.slice()),
-		listener,
-		active: true
-	};
-	notification.filtered.add(entry);
-	const keys = new Set(targets.map(key));
-	keys.forEach((key) => {
-		const bucket = notification.buckets.get(key) ?? /* @__PURE__ */ new Set();
-		bucket.add(entry);
-		notification.buckets.set(key, bucket);
-	});
-	return () => {
-		if (!entry.active) return;
-		entry.active = false;
-		if (notification.notifying) return;
-		notification.filtered.delete(entry);
-		keys.forEach((key) => {
-			const bucket = notification.buckets.get(key);
-			bucket?.delete(entry);
-			if (bucket?.size === 0) notification.buckets.delete(key);
-		});
-	};
-};
-const notify = (notification, commit) => {
-	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.process(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.flush();
-			} catch (error) {
-				errors.push(Object.freeze({
-					phase: "flush",
-					error
-				}));
-			}
-		}
-		const candidates = notification.candidates;
-		candidates.clear();
-		if (commit.impact.kind === "reset") notification.filtered.forEach((entry) => candidates.add(entry));
-		else for (const operation of commit.operations) {
-			const key = operation.at[0] ?? ROOT_BUCKET;
-			notification.buckets.get(key)?.forEach((entry) => candidates.add(entry));
-			notification.buckets.get(ROOT_BUCKET)?.forEach((entry) => candidates.add(entry));
-		}
-		candidates.forEach((entry) => {
-			if (entry.active && entry.targets.some(commit.impact.affects)) 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.root.forEach((entry) => {
-			if (!entry.active) notification.root.delete(entry);
-		});
-		notification.filtered.forEach((entry) => {
-			if (!entry.active) notification.filtered.delete(entry);
-		});
-		notification.buckets.forEach((bucket, key) => {
-			bucket.forEach((entry) => {
-				if (!entry.active) bucket.delete(entry);
-			});
-			if (bucket.size === 0) notification.buckets.delete(key);
-		});
-	}
-	return Object.freeze(errors);
-};
-const disposeNotification = (notification) => {
-	notification.root.clear();
-	notification.filtered.clear();
-	notification.buckets.clear();
-	notification.processors.length = 0;
-	notification.candidates.clear();
-	notification.rootSnapshot.length = 0;
-};
-//#endregion
 //#region core/src/runtime.ts
 var RejectedUpdate = class extends Error {
 	issues;
@@ -2467,6 +2173,7 @@ var RejectedUpdate = class extends Error {
 const EMPTY = Object.freeze([]);
 const publishDiagnostic = (value) => Object.freeze({
 	...value,
+	source: "application",
 	...value.address === void 0 ? {} : { address: Object.freeze(value.address.slice()) }
 });
 const createDocument = (input) => {
@@ -2485,6 +2192,7 @@ const createDocument = (input) => {
 	const assertWritable = (intent) => {
 		if (state.disposed) throw new DocumentDisposedError();
 		if (busy) throw new DocumentReentrancyError();
+		if (accessOf(runtime).projectionLocks) throw new DocumentReentrancyError();
 		assertRuntimeWritable(runtime, intent);
 	};
 	const runTransaction = (session, run) => {
@@ -2526,7 +2234,19 @@ const createDocument = (input) => {
 	const history = createHistory({
 		capacity: input.history === false ? 0 : Math.max(0, input.history?.capacity ?? 100),
 		revision: () => revision,
-		apply: (operations) => applyBatch(operations, "history", false)
+		apply: (operations) => applyBatch(operations, "history", false),
+		assertIdle: () => {
+			if (state.disposed) throw new DocumentDisposedError();
+			if (busy || accessOf(runtime).projectionLocks) throw new DocumentReentrancyError();
+		},
+		notify: (run) => {
+			busy = true;
+			try {
+				return run();
+			} finally {
+				busy = false;
+			}
+		}
 	});
 	const publish = (batch, source, kind, recordHistory) => {
 		revision += 1;
@@ -2540,10 +2260,12 @@ const createDocument = (input) => {
 		});
 		if (kind === "replace" || source === "remote") history.invalidate();
 		else if (recordHistory && (source === "local" || source === "system")) history.record(batch.operations, batch.inverse);
+		else if (source === "history") history.publish();
+		else history.endGroup();
 		busy = true;
 		let observerErrors;
 		try {
-			observerErrors = notify(notification, commit);
+			observerErrors = notify(notification, commit, history.flush);
 		} finally {
 			busy = false;
 		}
@@ -2575,7 +2297,7 @@ const createDocument = (input) => {
 		address: {
 			resolve: (address) => resolveAddress(input.schema, address, state.document),
 			read: (address) => read(state.document, address),
-			contains,
+			contains: contains$1,
 			overlaps,
 			debugKey
 		},
@@ -2686,7 +2408,7 @@ const createDocument = (input) => {
 			const invalidTree = invalidDocument(input.schema, document);
 			if (invalidTree) return {
 				status: "rejected",
-				issues: [at$1(invalidTree, "invalid-tree", "Document replacement contains an invalid tree.")],
+				issues: [at(invalidTree, "invalid-tree", "Document replacement contains an invalid tree.")],
 				revision
 			};
 			if (deepEqual(state.document, document)) return {
@@ -2716,15 +2438,20 @@ const createDocument = (input) => {
 		history: history.api,
 		dispose: () => {
 			if (state.disposed) return;
+			if (busy || accessOf(runtime).projectionLocks) throw new DocumentReentrancyError();
 			state.disposed = true;
-			disposeNotification(notification);
-			history.api.clear();
-			disposeRuntimeDriver(runtime);
+			try {
+				disposeNotification(notification);
+			} finally {
+				history.dispose();
+				disposeRuntimeDriver(runtime);
+			}
 		}
 	};
 	bindRuntimeAccess(runtime, state);
 	bindRuntimeDriver(runtime);
 	notification = createNotification(runtime);
+	bindDocumentReadable(history.api, runtime);
 	return runtime;
 };
 //#endregion
@@ -2743,387 +2470,6 @@ const asReadable = (runtime) => {
 //#region core/src/projection/select.ts
 const select = (runtime, selector) => readWith(runtime, selector);
 //#endregion
-//#region core/src/projection/collection-view.ts
-const createCollectionView = (input) => {
-	if (schemaOf(input.runtime) !== input.source.schema) throw new Error("Collection selector belongs to another schema.");
-	const idsListeners = /* @__PURE__ */ new Set();
-	const allListeners = /* @__PURE__ */ new Set();
-	const itemListeners = /* @__PURE__ */ new Map();
-	const itemReadables = /* @__PURE__ */ new Map();
-	let disposed = false;
-	const sourceNode = nodeAt$1(input.source.schema, input.source.address);
-	const entryNode = sourceNode?.kind === "table" || sourceNode?.kind === "map" ? sourceNode.value : {
-		kind: "object",
-		shape: {}
-	};
-	const mapEntry = (document, id) => {
-		profile.collectionView.mapped();
-		const address = [...input.source.address, String(id)];
-		let active = true;
-		try {
-			return input.map(id, readerFor(entryNode, {
-				root: () => document,
-				active: () => active
-			}, address));
-		} finally {
-			active = false;
-		}
-	};
-	const build = (previous, changed) => {
-		const document = documentOf(input.runtime);
-		const collection = read(document, input.source.address);
-		const ids = collection && typeof collection === "object" && "ids" in collection && Array.isArray(collection.ids) ? [...collection.ids] : Object.keys(collection ?? {});
-		profile.collectionView.idsScanned(ids.length);
-		const values = previous && changed ? previous.values : /* @__PURE__ */ new Map();
-		if (previous && changed) {
-			const nextIds = new Set(ids);
-			for (const id of previous.ids) if (!nextIds.has(id)) values.delete(id);
-		}
-		for (const id of ids) {
-			if (previous && changed && previous.values.has(id) && !changed.has(id)) continue;
-			const next = mapEntry(document, id);
-			if (previous && changed && previous.values.has(id)) {
-				const before = previous.values.get(id);
-				if (input.isEqual ? input.isEqual(before, next) : Object.is(before, next)) {
-					changed.delete(id);
-					continue;
-				}
-			}
-			values.set(id, next);
-		}
-		return {
-			ids: Object.freeze(ids),
-			values,
-			all: void 0,
-			allDirty: true
-		};
-	};
-	let state = build();
-	const ensureAll = () => {
-		if (!state.allDirty && state.all) return state.all;
-		profile.collectionView.arrayCopied();
-		const all = new Array(state.ids.length);
-		for (let index = 0; index < state.ids.length; index += 1) all[index] = state.values.get(state.ids[index]);
-		const stable = Object.freeze(all);
-		state.all = stable;
-		state.allDirty = false;
-		return stable;
-	};
-	const emit = (listeners) => {
-		Array.from(listeners).forEach((listener) => listener());
-	};
-	const unsubscribe = input.runtime.subscribe(input.source, (commit) => {
-		if (disposed) return;
-		const impact = commit.impact.collection(input.source);
-		if (impact.kind === "incremental" && impact.added.size === 0 && impact.removed.size === 0 && !impact.orderChanged) {
-			const previous = state;
-			const changes = [];
-			const document = documentOf(input.runtime);
-			impact.updated.forEach((id) => {
-				if (!previous.values.has(id)) return;
-				const before = previous.values.get(id);
-				const after = mapEntry(document, id);
-				if (input.isEqual ? input.isEqual(before, after) : Object.is(before, after)) return;
-				changes.push([id, after]);
-			});
-			if (changes.length === 0) return;
-			for (const [id, value] of changes) previous.values.set(id, value);
-			previous.all = void 0;
-			previous.allDirty = true;
-			emit(allListeners);
-			for (const [id] of changes) {
-				const listeners = itemListeners.get(id);
-				if (listeners) emit(listeners);
-			}
-			return;
-		}
-		const changed = impact.kind === "reset" ? void 0 : new Set([...impact.added, ...impact.updated]);
-		const previous = state;
-		const next = build(previous, changed);
-		const changedIds = /* @__PURE__ */ new Set();
-		if (changed) {
-			changed.forEach((id) => changedIds.add(id));
-			previous.ids.forEach((id) => {
-				if (!next.values.has(id)) changedIds.add(id);
-			});
-			next.ids.forEach((id) => {
-				if (!previous.values.has(id)) changedIds.add(id);
-			});
-		} else {
-			previous.ids.forEach((id) => {
-				if (!next.values.has(id)) changedIds.add(id);
-				else if (!(input.isEqual ? input.isEqual(previous.values.get(id), next.values.get(id)) : Object.is(previous.values.get(id), next.values.get(id)))) changedIds.add(id);
-			});
-			next.ids.forEach((id) => {
-				if (!previous.values.has(id)) changedIds.add(id);
-			});
-		}
-		const idsChanged = impact.kind === "incremental" ? impact.added.size > 0 || impact.removed.size > 0 || impact.orderChanged : previous.ids.length !== next.ids.length || previous.ids.some((id, index) => next.ids[index] !== id);
-		state = idsChanged || changedIds.size ? next : previous;
-		if (idsChanged) emit(idsListeners);
-		if (idsChanged || changedIds.size) emit(allListeners);
-		changedIds.forEach((id) => {
-			const listeners = itemListeners.get(id);
-			if (listeners) emit(listeners);
-		});
-	});
-	return {
-		ids: {
-			current: () => state.ids,
-			revision: () => input.runtime.revision(),
-			subscribe: (listener) => {
-				if (disposed) return () => void 0;
-				idsListeners.add(listener);
-				return () => idsListeners.delete(listener);
-			}
-		},
-		all: {
-			current: ensureAll,
-			revision: () => input.runtime.revision(),
-			subscribe: (listener) => {
-				if (disposed) return () => void 0;
-				allListeners.add(listener);
-				return () => allListeners.delete(listener);
-			}
-		},
-		item: (id) => {
-			const cached = itemReadables.get(id);
-			if (cached) return cached;
-			const readable = {
-				current: () => state.values.get(id),
-				revision: () => input.runtime.revision(),
-				subscribe: (listener) => {
-					if (disposed) return () => void 0;
-					const listeners = itemListeners.get(id) ?? /* @__PURE__ */ new Set();
-					itemListeners.set(id, listeners);
-					listeners.add(listener);
-					return () => {
-						listeners.delete(listener);
-						if (listeners.size === 0) itemListeners.delete(id);
-					};
-				}
-			};
-			itemReadables.set(id, readable);
-			return readable;
-		},
-		revision: () => input.runtime.revision(),
-		dispose: () => {
-			if (disposed) return;
-			disposed = true;
-			unsubscribe();
-			idsListeners.clear();
-			allListeners.clear();
-			itemListeners.clear();
-			itemReadables.clear();
-			state.values.clear();
-			state = {
-				ids: Object.freeze([]),
-				values: /* @__PURE__ */ new Map(),
-				all: Object.freeze([]),
-				allDirty: false
-			};
-		}
-	};
-};
-//#endregion
-//#region core/src/projection/materialized-view.ts
-const materializedMeta = /* @__PURE__ */ new WeakMap();
-const createMaterializedView = (runtime, spec) => {
-	const listeners = /* @__PURE__ */ new Set();
-	let disposed = false;
-	let fault;
-	let revision = runtime.revision();
-	let instance;
-	let currentValue;
-	let pendingEmit = false;
-	const dependencies = createDependencyTracker();
-	const sources = spec.sources ?? {};
-	const sourceEntries = Object.keys(sources).map((key) => [key, sources[key]]);
-	sourceEntries.forEach(([, source]) => {
-		const meta = materializedMeta.get(source);
-		if (!meta || meta.runtime !== runtime) throw new Error("Materialized sources must belong to the same runtime and be created first.");
-	});
-	const sourceValuesRecord = {};
-	let sourceChanged = false;
-	for (const [key] of sourceEntries) sourceValuesRecord[key] = {
-		value: void 0,
-		change: void 0
-	};
-	const sourceValues = (commitRevision) => {
-		sourceChanged = false;
-		for (const [key, source] of sourceEntries) {
-			const meta = materializedMeta.get(source);
-			const entry = sourceValuesRecord[key];
-			entry.value = meta?.value ?? source.current();
-			entry.change = meta?.change;
-			if (commitRevision !== void 0 && meta?.changedRevision === commitRevision) {
-				sourceChanged = true;
-				profile.materialized.sourceChanged();
-			}
-		}
-		return sourceValuesRecord;
-	};
-	let activeImpact;
-	const assertImpact = () => {
-		if (!activeImpact) throw new Error("Materialized impact is no longer active.");
-		return activeImpact;
-	};
-	const trackedImpact = {
-		get kind() {
-			return assertImpact().kind;
-		},
-		affects: (target) => {
-			dependencies.record(target);
-			return assertImpact().affects(target);
-		},
-		collection: (selector) => {
-			dependencies.record(selector);
-			return assertImpact().collection(selector);
-		},
-		get operations() {
-			dependencies.record({
-				kind: "value",
-				at: []
-			});
-			return assertImpact().operations;
-		}
-	};
-	let view;
-	const writeMeta = (change, value, nextRevision, changed) => {
-		const meta = materializedMeta.get(view);
-		if (meta) {
-			meta.value = value;
-			meta.change = change;
-			meta.revision = nextRevision;
-			if (changed) meta.changedRevision = nextRevision;
-		} else materializedMeta.set(view, {
-			runtime,
-			value,
-			change,
-			revision: nextRevision,
-			changedRevision: changed ? nextRevision : -1
-		});
-	};
-	const build = () => {
-		profile.materialized.rebuilt();
-		dependencies.clear();
-		let active = true;
-		try {
-			instance = spec.build({
-				read: documentReader(schemaOf(runtime), () => documentOf(runtime), () => active),
-				sources: sourceValues()
-			});
-			currentValue = instance.value;
-			fault = void 0;
-			revision = runtime.revision();
-		} finally {
-			active = false;
-		}
-	};
-	build();
-	const emit = () => {
-		profile.materialized.notification();
-		Array.from(listeners).forEach((listener) => listener());
-	};
-	const process = (commit) => {
-		if (disposed) return;
-		try {
-			if (commit.kind === "replace" || fault) {
-				build();
-				writeMeta(void 0, currentValue, commit.revision, true);
-				pendingEmit = true;
-				return;
-			}
-			const sourceSnapshot = sourceValues(commit.revision);
-			if (!sourceChanged && dependencies.size() > 0 && !dependencies.some(commit.impact.affects)) {
-				profile.materialized.skipped();
-				revision = commit.revision;
-				writeMeta(void 0, currentValue, commit.revision, false);
-				return;
-			}
-			dependencies.clear();
-			profile.materialized.updated();
-			let active = true;
-			let result;
-			try {
-				activeImpact = commit.impact;
-				result = instance.update({
-					read: documentReader(schemaOf(runtime), () => documentOf(runtime), () => active),
-					revision: commit.revision,
-					source: commit.source,
-					impact: trackedImpact,
-					sources: sourceSnapshot
-				});
-			} finally {
-				activeImpact = void 0;
-				active = false;
-			}
-			if (result.kind === "rebuild") {
-				build();
-				writeMeta(void 0, currentValue, commit.revision, true);
-				pendingEmit = true;
-			} else if (result.kind === "changed") {
-				currentValue = result.value;
-				revision = commit.revision;
-				writeMeta(result.change, currentValue, commit.revision, true);
-				pendingEmit = true;
-			} else {
-				revision = commit.revision;
-				writeMeta(void 0, currentValue, commit.revision, false);
-			}
-		} catch (error) {
-			try {
-				build();
-				writeMeta(void 0, currentValue, commit.revision, true);
-				pendingEmit = true;
-			} catch (rebuildError) {
-				fault = rebuildError;
-				throw rebuildError;
-			}
-			throw error;
-		}
-	};
-	view = {
-		current: () => {
-			if (fault) throw fault;
-			return currentValue;
-		},
-		revision: () => revision,
-		subscribe: (listener) => {
-			listeners.add(listener);
-			return () => listeners.delete(listener);
-		},
-		rebuild: () => {
-			build();
-			writeMeta(void 0, currentValue, runtime.revision(), true);
-			emit();
-		},
-		dispose: () => {
-			if (disposed) return;
-			disposed = true;
-			unregister();
-			listeners.clear();
-			materializedMeta.delete(view);
-		}
-	};
-	materializedMeta.set(view, {
-		runtime,
-		value: currentValue,
-		change: void 0,
-		revision,
-		changedRevision: -1
-	});
-	const unregister = registerProcessor(runtime, {
-		process,
-		flush: () => {
-			if (!pendingEmit) return;
-			pendingEmit = false;
-			emit();
-		}
-	});
-	return view;
-};
-//#endregion
-export { DocumentDisposedError, DocumentReentrancyError, asReadable, commandFootprint, contains, createCollectionView, createDocument, createMaterializedView, debugKey, decodeCommandFootprint, dict, field, footprintsOverlap, list, map, object, optional, overlaps, read as readAddress, record, resolveAddress, schema, select, single, table, impact_target_exports as target, tree, variant };
+export { DocumentDisposedError, DocumentReentrancyError, ProjectionDisposedError, ProjectionError, asReadable, createDocument, createProjectionRuntime, dict, field, list, map, object, optional, schema, select, table, impact_target_exports as target, tree, variant };
 
 //# sourceMappingURL=index.js.map