doxum 0.1.16 → 0.1.17

package/dist/index.cjs

@@ -3,7 +3,7 @@ const require_issue = require("./issue-DhrNdQNg.cjs");
 const require_scope = require("./scope-Ezs-Y3TY.cjs");
 const require_notification = require("./notification-CDSUfiip.cjs");
 const require_driver = require("./driver-BCyfqxsl.cjs");
-const require_definition = require("./definition-Z6TagMup.cjs");
+const require_definition = require("./definition-De6rhTlZ.cjs");
 //#region core/src/schema.ts
 const node = (value) => Object.freeze(value);
 const field = (validator) => node({
@@ -1206,7 +1206,7 @@ const createScheduler = (onError) => {
 				const blocked = node.sources.find((source) => source.fault || source.disposed);
 				if (blocked) node.fault = errorFor(node, blocked.fault ?? new ProjectionDisposedError(), "blocked");
 				else {
-					const build = node.forced || wasFaulted || node.sources.some((source) => source.reset());
+					const build = wasFaulted || node.sources.some((source) => source.reset());
 					try {
 						changed = node.evaluate(build);
 						const failure = node.sources.find((source) => source.fault)?.fault;
@@ -1227,8 +1227,6 @@ const createScheduler = (onError) => {
 						}
 					}
 				}
-				node.forced = false;
-				node.statusChanged = wasFaulted !== (node.fault !== void 0);
 				completed.push(node);
 				if (changed || wasFaulted || node.fault) {
 					require_issue.profile.projection("publishedNodes");
@@ -1368,23 +1366,6 @@ const createScheduler = (onError) => {
 				phase = "idle";
 			}
 		},
-		rebuild(node) {
-			assertIdle();
-			if (node.disposed) throw new ProjectionDisposedError();
-			node.forced = true;
-			enqueue(node);
-			run();
-		},
-		disposeNode(node) {
-			if (node.disposed) return;
-			assertIdle();
-			if (node.consumers.size) throw new Error("Cannot dispose a projection node with downstream consumers.");
-			node.disposed = true;
-			node.sources.forEach((source) => source.consumers.delete(node));
-			nodes.delete(node);
-			node.release();
-			for (const [handle, record] of records) if (record === node) records.delete(handle);
-		},
 		batch,
 		batchContext: () => activeBatch,
 		dispose() {
@@ -1394,521 +1375,49 @@ const createScheduler = (onError) => {
 			const failures = [];
 			cleanups.forEach((cleanup) => {
 				try {
-					cleanup();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			cleanups.clear();
-			nodes.forEach((node) => {
-				node.disposed = true;
-				node.release();
-				node.consumers.clear();
-			});
-			records.forEach((source) => {
-				source.disposed = true;
-				source.consumers.clear();
-				source.clear();
-			});
-			nodes.clear();
-			records.clear();
-			pending.clear();
-			heap.length = 0;
-			completed.length = 0;
-			queued.clear();
-			emissions.clear();
-			guards.clear();
-			errors.length = 0;
-			reportingFailures = [];
-			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
-		},
-		debug: () => ({
-			nodes: nodes.size,
-			sources: records.size - nodes.size,
-			subscriptions: cleanups.size,
-			pending: pending.size + heap.length
-		})
-	};
-};
-const assertSynchronous = (value) => {
-	if (value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function") throw new TypeError("Projection callbacks must be synchronous.");
-};
-const assertScope = (active) => {
-	if (!active()) throw new Error("Projection reader or writer is no longer active.");
-};
-//#endregion
-//#region core/src/projection/node.ts
-const createNode = (scheduler, spec, behavior) => {
-	scheduler.assertIdle();
-	const entries = Object.entries(spec.sources).map(([key, handle]) => [key, scheduler.source(handle)]);
-	const order = scheduler.order();
-	const node = {
-		...behavior,
-		publish: () => {
-			if (node.fault) behavior.clear();
-			else behavior.publish();
-		},
-		order,
-		name: spec.name ? `${spec.name} (${order})` : `projection-${order}`,
-		sources: entries.map(([, source]) => source),
-		consumers: /* @__PURE__ */ new Set(),
-		disposed: false,
-		fault: void 0,
-		forced: false,
-		statusChanged: false,
-		evaluate: (build) => {
-			let active = true;
-			try {
-				const scopeActive = () => active;
-				const inputs = Object.fromEntries(entries.map(([key, source]) => [key, source.context(scopeActive)]));
-				return behavior.evaluate(inputs, build, scopeActive);
-			} finally {
-				active = false;
-			}
-		}
-	};
-	scheduler.initialize(() => {
-		const invalid = node.sources.find((source) => source.fault || source.disposed);
-		if (invalid) throw invalid.fault ?? new ProjectionDisposedError();
-		node.evaluate(true);
-		node.publish();
-		node.clear();
-	});
-	const check = () => {
-		if (node.disposed || !scheduler.active) throw new ProjectionDisposedError();
-		if (node.fault) throw node.fault;
-	};
-	return {
-		node,
-		check,
-		install(handle) {
-			scheduler.register(handle, node);
-			scheduler.addNode(node);
-		},
-		rebuild: () => scheduler.rebuild(node),
-		dispose: () => scheduler.disposeNode(node)
-	};
-};
-//#endregion
-//#region core/src/projection/collection.ts
-const collectionHandles = /* @__PURE__ */ new WeakSet();
-const readonlySet = (values) => {
-	const set = new Set(values);
-	const view = Object.freeze({
-		get size() {
-			return set.size;
-		},
-		has: (value) => set.has(value),
-		entries: () => set.entries(),
-		keys: () => set.keys(),
-		values: () => set.values(),
-		[Symbol.iterator]: () => set.values(),
-		forEach: (callback, thisArg) => set.forEach((value) => callback.call(thisArg, value, value, view))
-	});
-	return view;
-};
-const createCollection = (scheduler, spec) => {
-	const values = /* @__PURE__ */ new Map();
-	let ids = Object.freeze([]);
-	let staged = /* @__PURE__ */ new Map();
-	let nextIds = ids;
-	let change;
-	let instance;
-	let initialized = false;
-	let reset = false;
-	let revision = 0;
-	let idsRevision = 0;
-	let batch;
-	let cause;
-	let publishedTransitions = Object.freeze([]);
-	let all;
-	const items = /* @__PURE__ */ new Map();
-	const subscribedItems = /* @__PURE__ */ new Set();
-	const idsListeners = /* @__PURE__ */ new Set();
-	const allListeners = /* @__PURE__ */ new Set();
-	const listeners = /* @__PURE__ */ new Set();
-	const changedKeys = /* @__PURE__ */ new Set();
-	let orderChanged = false;
-	const current = Object.freeze({
-		get: (key) => {
-			owner.check();
-			return values.get(key);
-		},
-		has: (key) => {
-			owner.check();
-			return values.has(key);
-		},
-		ids: () => {
-			owner.check();
-			return ids;
-		}
-	});
-	const hasNext = (key) => staged.has(key) ? staged.get(key).present : values.has(key);
-	const getNext = (key) => {
-		const entry = staged.get(key);
-		return entry ? entry.present ? entry.value : void 0 : values.get(key);
-	};
-	const owner = createNode(scheduler, spec, {
-		evaluate: (sources, build, active) => {
-			const metadata = Object.values(sources).find((value) => value && typeof value === "object" && ("batch" in value && value.batch !== void 0 || "cause" in value && value.cause !== void 0));
-			batch = scheduler.batchContext() ?? metadata?.batch;
-			cause = metadata?.cause ?? batch?.cause;
-			staged = /* @__PURE__ */ new Map();
-			nextIds = ids;
-			change = void 0;
-			changedKeys.clear();
-			let explicitOrder;
-			let cleared = false;
-			const nextHas = (key) => staged.has(key) ? staged.get(key).present : !cleared && values.has(key);
-			const nextGet = (key) => {
-				const entry = staged.get(key);
-				return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : values.get(key);
-			};
-			const deriveIds = () => {
-				const result = cleared ? [] : ids.filter(nextHas);
-				for (const [key, entry] of staged) if (entry.present && (cleared || !values.has(key))) result.push(key);
-				return result;
-			};
-			const read = (next) => ({
-				get: (key) => {
-					assertScope(active);
-					return next ? nextGet(key) : values.get(key);
-				},
-				has: (key) => {
-					assertScope(active);
-					return next ? nextHas(key) : values.has(key);
-				},
-				ids: () => {
-					assertScope(active);
-					return next ? Object.freeze(explicitOrder ? explicitOrder.slice() : deriveIds()) : ids;
-				}
-			});
-			const writer = {
-				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 = order.slice();
-				},
-				replace: (entries) => {
-					assertScope(active);
-					staged.clear();
-					cleared = true;
-					const order = [];
-					for (const [key, value] of entries) {
-						if (staged.has(key)) throw new TypeError("Duplicate projection key.");
-						writer.set(key, value);
-						order.push(key);
-					}
-					explicitOrder = order;
-				}
-			};
-			const input = {
-				sources,
-				previous: read(false),
-				next: read(true),
-				writer
-			};
-			if (build || !instance) {
-				require_issue.profile.materialized.rebuilt();
-				instance = void 0;
-				cleared = true;
-				const built = spec.build(input);
-				assertSynchronous(built);
-				instance = built;
-			} else {
-				require_issue.profile.materialized.updated();
-				const result = instance.update(input);
-				assertSynchronous(result);
-				if (result?.kind === "rebuild") {
-					staged.clear();
-					cleared = true;
-					explicitOrder = void 0;
-					instance = void 0;
-					const built = spec.build(input);
-					assertSynchronous(built);
-					instance = built;
-					build = true;
-				}
-			}
-			if (cleared) {
-				for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
-			}
-			const added = /* @__PURE__ */ new Set();
-			const removed = /* @__PURE__ */ new Set();
-			const updated = /* @__PURE__ */ new Set();
-			require_issue.profile.projection("touchedKeys", staged.size);
-			for (const [key, entry] of staged) {
-				const existed = values.has(key);
-				if (entry.present) if (!existed) added.add(key);
-				else if (!(spec.isEqual ?? Object.is)(values.get(key), entry.value)) updated.add(key);
-				else staged.delete(key);
-				else if (existed) removed.add(key);
-				else staged.delete(key);
-			}
-			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 !== values.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, i) => key === order[i]) ? ids : Object.freeze(order.slice());
-			}
-			orderChanged = nextIds !== ids;
-			if (added.size || removed.size || updated.size || orderChanged) {
-				let commonOrderChanged = false;
-				if (orderChanged) {
-					const before = ids.filter((key) => !removed.has(key));
-					const after = nextIds.filter((key) => !added.has(key));
-					commonOrderChanged = before.some((key, i) => after[i] !== key);
-				}
-				change = Object.freeze({
-					kind: "incremental",
-					added: readonlySet(added),
-					removed: readonlySet(removed),
-					updated: readonlySet(updated),
-					orderChanged: commonOrderChanged
-				});
-				[
-					...added,
-					...removed,
-					...updated
-				].forEach((key) => changedKeys.add(key));
-				require_issue.profile.projection("changedKeys", changedKeys.size);
-			}
-			const transitions = [];
-			for (const key of changedKeys) {
-				const beforePresent = values.has(key);
-				const afterPresent = hasNext(key);
-				if (beforePresent === afterPresent) {
-					if (!beforePresent) continue;
-					if ((spec.isEqual ?? Object.is)(values.get(key), getNext(key))) continue;
-				}
-				if (!beforePresent) transitions.push({
-					key,
-					kind: "added",
-					before: void 0,
-					after: getNext(key)
-				});
-				else if (!afterPresent) transitions.push({
-					key,
-					kind: "removed",
-					before: values.get(key),
-					after: void 0
-				});
-				else transitions.push({
-					key,
-					kind: "updated",
-					before: values.get(key),
-					after: getNext(key)
-				});
-			}
-			publishedTransitions = Object.freeze(transitions);
-			reset = build;
-			return change !== void 0;
-		},
-		context: (active) => {
-			const transitions = (keys) => {
-				assertScope(active);
-				const selected = keys ? new Set(keys) : void 0;
-				return Object.freeze(publishedTransitions.filter((transition) => !selected || selected.has(transition.key)));
-			};
-			const input = {
-				get: (key) => {
-					assertScope(active);
-					return getNext(key);
-				},
-				has: (key) => {
-					assertScope(active);
-					return hasNext(key);
-				},
-				ids: () => {
-					assertScope(active);
-					return nextIds;
-				},
-				previous: Object.freeze({
-					get: (key) => {
-						assertScope(active);
-						return values.get(key);
-					},
-					has: (key) => {
-						assertScope(active);
-						return values.has(key);
-					},
-					ids: () => {
-						assertScope(active);
-						return ids;
-					}
-				}),
-				change,
-				revision: revision + (change ? 1 : 0),
-				reset,
-				transitions,
-				batch,
-				cause
-			};
-			return Object.freeze(input);
-		},
-		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
-			else values.delete(key);
-			if (change) {
-				if (initialized) revision++;
-				if (orderChanged && initialized) idsRevision++;
-				all = void 0;
-				changedKeys.forEach((key) => {
-					const item = items.get(key);
-					if (item && initialized) item.revision++;
-				});
-			}
-			ids = nextIds;
-			initialized = true;
-		},
-		emit: (call) => {
-			require_issue.profile.materialized.notification();
-			const fault = owner.node.fault !== void 0;
-			const resetEvent = Object.freeze({ kind: "reset" });
-			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
-			if (orderChanged || !change || fault || owner.node.statusChanged) Array.from(idsListeners).forEach((listener) => call(listener));
-			Array.from(allListeners).forEach((listener) => call(listener));
-			if (!change || fault || owner.node.statusChanged) for (const item of subscribedItems) Array.from(item.listeners ?? []).forEach((listener) => call(listener));
-			else for (const key of changedKeys) Array.from(items.get(key)?.listeners ?? []).forEach((listener) => call(listener));
-		},
-		clear: () => {
-			staged.clear();
-			nextIds = ids;
-			change = void 0;
-			reset = false;
-			changedKeys.clear();
-			publishedTransitions = Object.freeze([]);
-			batch = void 0;
-			cause = void 0;
-			orderChanged = false;
-		},
-		release: () => {
-			values.clear();
-			staged.clear();
-			items.clear();
-			subscribedItems.clear();
-			idsListeners.clear();
-			allListeners.clear();
-			listeners.clear();
-			ids = nextIds = Object.freeze([]);
-			all = void 0;
-			instance = void 0;
-		}
-	});
-	const handle = {
-		current: () => {
-			owner.check();
-			return current;
-		},
-		ids: {
-			current: () => {
-				owner.check();
-				return ids;
-			},
-			revision: () => {
-				owner.check();
-				return idsRevision;
-			},
-			subscribe: (listener) => {
-				owner.check();
-				idsListeners.add(listener);
-				return () => {
-					idsListeners.delete(listener);
-				};
-			}
-		},
-		all: {
-			current: () => {
-				owner.check();
-				if (!all) {
-					require_issue.profile.collectionView.arrayCopied();
-					all = Object.freeze(ids.map((key) => values.get(key)));
-				}
-				return all;
-			},
-			revision: () => {
-				owner.check();
-				return revision;
-			},
-			subscribe: (listener) => {
-				owner.check();
-				allListeners.add(listener);
-				return () => {
-					allListeners.delete(listener);
-				};
-			}
-		},
-		item: (key) => {
-			owner.check();
-			const old = items.get(key);
-			if (old) return old.readable;
-			const readable = Object.freeze({
-				current: () => {
-					owner.check();
-					return values.get(key);
-				},
-				revision: () => {
-					owner.check();
-					return item.revision;
-				},
-				subscribe: (listener) => {
-					owner.check();
-					const set = item.listeners ??= /* @__PURE__ */ new Set();
-					set.add(listener);
-					subscribedItems.add(item);
-					return () => {
-						set.delete(listener);
-						if (!set.size) subscribedItems.delete(item);
-					};
+					cleanup();
+				} catch (error) {
+					failures.push(error);
 				}
 			});
-			const item = {
-				readable,
-				revision: 0
-			};
-			projectionHandles.add(readable);
-			items.set(key, item);
-			return readable;
-		},
-		revision: () => {
-			owner.check();
-			return revision;
-		},
-		subscribe: (listener) => {
-			owner.check();
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		},
-		rebuild: owner.rebuild,
-		dispose: owner.dispose
+			cleanups.clear();
+			nodes.forEach((node) => {
+				node.disposed = true;
+				node.release();
+				node.consumers.clear();
+			});
+			records.forEach((source) => {
+				source.disposed = true;
+				source.consumers.clear();
+				source.clear();
+			});
+			nodes.clear();
+			records.clear();
+			pending.clear();
+			heap.length = 0;
+			completed.length = 0;
+			queued.clear();
+			emissions.clear();
+			guards.clear();
+			errors.length = 0;
+			reportingFailures = [];
+			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
+		}
 	};
-	projectionHandles.add(handle.ids);
-	projectionHandles.add(handle.all);
-	collectionHandles.add(handle);
-	owner.install(handle);
-	return Object.freeze(handle);
+};
+const assertSynchronous = (value) => {
+	if (value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function") throw new TypeError("Projection callbacks must be synchronous.");
+};
+const assertScope = (active) => {
+	if (!active()) throw new Error("Projection reader or writer is no longer active.");
 };
 //#endregion
 //#region core/src/projection/source.ts
 const createSources = (scheduler) => {
 	const documents = /* @__PURE__ */ new Map();
 	const readables = /* @__PURE__ */ new Map();
-	const collections = /* @__PURE__ */ new WeakSet();
 	const externalSources = /* @__PURE__ */ new WeakMap();
+	const isCollectionSource = (value) => value.kind === "collection";
 	const document = (runtime) => {
 		scheduler.assertIdle();
 		const state = require_notification.accessOf(runtime);
@@ -1924,13 +1433,18 @@ const createSources = (scheduler) => {
 			targets.forEach((value) => {
 				if (!require_notification.belongs(value, state.schema)) throw new Error("Projection target belongs to another schema.");
 			});
-			const old = bindings.find((entry) => Boolean(collection) === collections.has(entry.handle) && entry.targets.length === targets.length && entry.targets.every((value, i) => require_notification.same(value, targets[i])));
+			const old = bindings.find((entry) => Boolean(collection) === isCollectionSource(entry.handle) && entry.targets.length === targets.length && entry.targets.every((value, i) => require_notification.same(value, targets[i])));
 			if (old) return old.handle;
-			let commits = [];
 			let reset = false;
-			let orderDirty = false;
+			let orderChanged = false;
 			const keys = /* @__PURE__ */ new Set();
-			let candidates;
+			let baseline;
+			let baselineIds = Object.freeze([]);
+			let nextBaseline;
+			let nextBaselineIds = Object.freeze([]);
+			const collectionNode = collection ? require_issue.nodeAt(state.schema, collection.address, state.document) : void 0;
+			const entryNode = collectionNode && (collectionNode.kind === "map" || collectionNode.kind === "table") ? collectionNode.value : void 0;
+			const sameEntry = (left, right) => entryNode ? require_scope.equalValue(entryNode, left, right) : Object.is(left, right);
 			const record = {
 				consumers: /* @__PURE__ */ new Set(),
 				disposed: false,
@@ -1938,11 +1452,16 @@ const createSources = (scheduler) => {
 				revision: runtime.revision,
 				reset: () => reset,
 				clear: () => {
-					commits = [];
-					reset = orderDirty = false;
+					if (collection && nextBaseline) {
+						baseline = nextBaseline;
+						baselineIds = nextBaselineIds;
+					}
+					reset = false;
+					orderChanged = false;
 					batch = void 0;
 					keys.clear();
-					candidates = void 0;
+					nextBaseline = void 0;
+					nextBaselineIds = Object.freeze([]);
 				},
 				context: (active) => {
 					assertScope(active);
@@ -1951,22 +1470,109 @@ const createSources = (scheduler) => {
 						state,
 						active
 					};
-					const read = collection ? require_scope.collectionAccess(context, collection.address) : require_scope.createAccess(context);
-					return Object.freeze({
+					const rawRead = collection ? require_scope.collectionAccess(context, collection.address) : void 0;
+					const snapshots = collection ? /* @__PURE__ */ new Map() : void 0;
+					const read = collection ? Object.freeze({
+						get: (key) => {
+							assertScope(active);
+							if (!snapshots.has(key)) snapshots.set(key, require_scope.snapshot(rawRead.get(key)));
+							return snapshots.get(key);
+						},
+						has: (key) => {
+							assertScope(active);
+							return rawRead.has(key);
+						},
+						ids: () => {
+							assertScope(active);
+							return rawRead.ids();
+						}
+					}) : require_scope.createAccess(context);
+					if (!collection) return Object.freeze({
+						kind: "document",
 						read,
 						revision: runtime.revision(),
-						commits: Object.freeze(commits.slice()),
 						reset: record.reset(),
-						batch,
-						cause: batch?.cause,
-						...collection ? { candidates: candidates ??= Object.freeze({
-							keys: Object.freeze([...keys]),
-							orderDirty
-						}) } : {}
+						cause: batch?.cause
+					});
+					if (!baseline) {
+						const collectionRead = read;
+						baseline = /* @__PURE__ */ new Map();
+						baselineIds = Object.freeze(require_scope.collectionAccess(context, collection.address).ids().slice());
+						for (const key of baselineIds) {
+							const value = collectionRead.get(key);
+							baseline.set(key, value);
+						}
+					}
+					const changed = [...keys];
+					const added = [];
+					const updated = [];
+					const removed = [];
+					const next = new Map(baseline);
+					const collectionRead = read;
+					for (const key of changed) {
+						const beforePresent = baseline.has(key);
+						const afterPresent = collectionRead.has(key);
+						const afterValue = afterPresent ? collectionRead.get(key) : void 0;
+						if (!beforePresent && afterPresent) {
+							added.push({
+								key,
+								after: afterValue
+							});
+							next.set(key, afterValue);
+						} else if (beforePresent && !afterPresent) {
+							removed.push({
+								key,
+								before: baseline.get(key)
+							});
+							next.delete(key);
+						} else if (beforePresent && afterPresent) {
+							const beforeValue = baseline.get(key);
+							if (!sameEntry(beforeValue, afterValue)) updated.push({
+								key,
+								before: beforeValue,
+								after: afterValue
+							});
+							next.set(key, afterValue);
+						}
+					}
+					const ids = record.reset() || orderChanged ? Object.freeze([...collectionRead.ids()]) : baselineIds;
+					if (record.reset()) {
+						next.clear();
+						for (const key of ids) {
+							const value = collectionRead.get(key);
+							next.set(key, value);
+						}
+					}
+					let order;
+					if (orderChanged) {
+						const beforeKeys = new Set(baselineIds);
+						const afterKeys = new Set(ids);
+						const beforeCommon = baselineIds.filter((key) => afterKeys.has(key));
+						const afterCommon = ids.filter((key) => beforeKeys.has(key));
+						if (beforeCommon.some((key, index) => afterCommon[index] !== key)) order = {
+							before: Object.freeze([...baselineIds]),
+							after: ids
+						};
+					}
+					const change = record.reset() ? Object.freeze({ kind: "reset" }) : added.length || updated.length || removed.length || order ? Object.freeze({
+						kind: "incremental",
+						added: Object.freeze(added),
+						updated: Object.freeze(updated),
+						removed: Object.freeze(removed),
+						...order ? { order: Object.freeze(order) } : {}
+					}) : void 0;
+					nextBaseline = next;
+					nextBaselineIds = ids;
+					return Object.freeze({
+						kind: "collection",
+						read,
+						change,
+						revision: runtime.revision(),
+						cause: batch?.cause
 					});
 				}
 			};
-			const handle = collection ? {} : {
+			const handle = collection ? { kind: "collection" } : {
 				collection: (pick) => {
 					scheduler.assertIdle();
 					return make({ collection: compilePath(state.schema, "collection", pick) });
@@ -1978,10 +1584,8 @@ const createSources = (scheduler) => {
 				}
 			};
 			Object.freeze(handle);
-			if (collection) collections.add(handle);
 			scheduler.register(handle, record);
 			const receive = (commit) => {
-				commits.push(commit);
 				reset ||= commit.impact.kind === "reset";
 				if (collection) {
 					const change = collectionImpact(commit.impact, collection);
@@ -1990,9 +1594,8 @@ const createSources = (scheduler) => {
 						change.added.forEach((key) => keys.add(key));
 						change.removed.forEach((key) => keys.add(key));
 						change.updated.forEach((key) => keys.add(key));
-						orderDirty ||= Boolean(change.added.size || change.removed.size || change.orderChanged);
+						orderChanged ||= Boolean(change.added.size || change.removed.size || change.orderChanged);
 					}
-					candidates = void 0;
 				}
 			};
 			bindings.push({
@@ -2035,13 +1638,9 @@ const createSources = (scheduler) => {
 	};
 	const valueSource = (initial, equal) => {
 		let value = initial;
-		let previous = initial;
 		let revision = 0;
-		let detail;
 		let cause;
-		let batch;
 		let reset = false;
-		let pending = false;
 		const handle = Object.freeze({});
 		const record = {
 			consumers: /* @__PURE__ */ new Set(),
@@ -2050,24 +1649,17 @@ const createSources = (scheduler) => {
 			revision: () => revision,
 			reset: () => reset,
 			clear: () => {
-				previous = value;
-				pending = false;
-				detail = void 0;
 				cause = void 0;
-				batch = void 0;
 				reset = false;
 			},
 			context: (active) => {
 				assertScope(active);
 				return Object.freeze({
+					kind: "value",
 					value,
-					previous,
 					revision,
-					changed: !equal(previous, value),
 					reset,
-					detail,
-					cause,
-					batch
+					cause
 				});
 			}
 		};
@@ -2075,18 +1667,14 @@ const createSources = (scheduler) => {
 		const accept = (next, metadata) => {
 			scheduler.assertIdle();
 			const recovering = record.fault !== void 0;
-			const eventful = metadata !== void 0 && (metadata.reset === true || metadata.revision !== void 0 && metadata.revision !== revision || metadata.detail !== void 0 || metadata.cause !== void 0 || metadata.batch !== void 0);
+			const eventful = metadata !== void 0 && (metadata.reset === true || metadata.revision !== void 0 && metadata.revision !== revision || metadata.cause !== void 0);
 			if (equal(value, next) && !recovering && !eventful) return;
 			record.fault = void 0;
-			if (!pending) previous = value;
 			value = next;
 			revision = metadata?.revision ?? revision + 1;
-			detail = metadata?.detail;
-			cause = metadata?.cause ?? cause;
-			batch = scheduler.batchContext() ?? metadata?.batch ?? batch;
+			cause = metadata?.cause ?? scheduler.batchContext()?.cause ?? cause;
 			reset ||= metadata?.reset ?? false;
 			scheduler.capture(record);
-			pending = true;
 		};
 		return {
 			source: handle,
@@ -2113,10 +1701,8 @@ const createSources = (scheduler) => {
 				try {
 					input.accept(event.value, {
 						revision: event.revision,
-						reset: event.reset,
-						detail: event.detail,
-						cause: event.cause,
-						batch: event.batch
+						reset: event.reset ?? false,
+						cause: event.cause
 					});
 				} catch (cause) {
 					fail(cause);
@@ -2141,13 +1727,11 @@ const createSources = (scheduler) => {
 		let revision = port.revision();
 		let change;
 		let reset = false;
-		let detail;
+		let orderChanged = false;
 		let cause;
-		let batch;
-		let publishedTransitions = Object.freeze([]);
 		let transitionKeys = /* @__PURE__ */ new Set();
 		let pending = false;
-		const handle = Object.freeze({});
+		const handle = Object.freeze({ kind: "collection" });
 		const record = {
 			consumers: /* @__PURE__ */ new Set(),
 			disposed: false,
@@ -2159,10 +1743,8 @@ const createSources = (scheduler) => {
 				pending = false;
 				change = void 0;
 				reset = false;
-				detail = void 0;
+				orderChanged = false;
 				cause = void 0;
-				batch = void 0;
-				publishedTransitions = Object.freeze([]);
 				transitionKeys.clear();
 			},
 			context: (active) => {
@@ -2181,101 +1763,65 @@ const createSources = (scheduler) => {
 						return read.ids();
 					}
 				});
-				const previousRead = Object.freeze({
-					get: (key) => {
-						assertScope(active);
-						return previous.get(key);
-					},
-					has: (key) => {
-						assertScope(active);
-						return previous.has(key);
-					},
-					ids: () => {
-						assertScope(active);
-						return previous.ids();
-					}
-				});
 				return Object.freeze({
-					...currentRead,
-					previous: previousRead,
+					kind: "collection",
+					read: currentRead,
 					change,
 					revision,
-					reset,
-					transitions: (keys) => {
-						assertScope(active);
-						const selected = keys ? new Set(keys) : void 0;
-						return Object.freeze(publishedTransitions.filter((transition) => !selected || selected.has(transition.key)));
-					},
-					detail,
-					cause,
-					batch
+					cause
 				});
 			}
 		};
 		scheduler.register(handle, record);
-		collections.add(handle);
 		const fail = (error) => {
 			record.fault = new ProjectionError("source", "external collection source", [revision], error);
 			scheduler.capture(record);
 		};
-		const addTransitionKeys = (impact) => {
-			if (impact?.kind === "incremental") {
-				impact.added.forEach((key) => transitionKeys.add(key));
-				impact.removed.forEach((key) => transitionKeys.add(key));
-				impact.updated.forEach((key) => transitionKeys.add(key));
-			}
-		};
-		const recomputeTransitions = () => {
-			const transitions = [];
+		const deriveChange = () => {
+			if (reset) return Object.freeze({ kind: "reset" });
+			const added = [];
+			const updated = [];
+			const removed = [];
 			for (const key of transitionKeys) {
 				const beforePresent = previous.has(key);
 				const afterPresent = read.has(key);
 				const before = beforePresent ? previous.get(key) : void 0;
 				const after = afterPresent ? read.get(key) : void 0;
 				if (beforePresent === afterPresent && Object.is(before, after)) continue;
-				if (!beforePresent) transitions.push({
+				if (!beforePresent && afterPresent) added.push({
 					key,
-					kind: "added",
-					before: void 0,
 					after
 				});
-				else if (!afterPresent) transitions.push({
+				else if (beforePresent && !afterPresent) removed.push({
 					key,
-					kind: "removed",
-					before,
-					after: void 0
+					before
 				});
-				else transitions.push({
+				else if (beforePresent && afterPresent) updated.push({
 					key,
-					kind: "updated",
 					before,
 					after
 				});
 			}
-			publishedTransitions = Object.freeze(transitions);
-		};
-		const deriveChange = () => {
-			if (reset) return Object.freeze({ kind: "reset" });
-			const added = /* @__PURE__ */ new Set();
-			const removed = /* @__PURE__ */ new Set();
-			const updated = /* @__PURE__ */ new Set();
-			publishedTransitions.forEach((transition) => {
-				if (transition.kind === "added") added.add(transition.key);
-				else if (transition.kind === "removed") removed.add(transition.key);
-				else updated.add(transition.key);
-			});
-			const beforeIds = previous.ids();
-			const afterIds = read.ids();
-			const beforeCommon = beforeIds.filter((key) => read.has(key));
-			const afterCommon = afterIds.filter((key) => previous.has(key));
-			const orderChanged = beforeCommon.length !== afterCommon.length || beforeCommon.some((key, index) => afterCommon[index] !== key);
-			if (!added.size && !removed.size && !updated.size && !orderChanged) return void 0;
+			let order;
+			if (orderChanged) {
+				const beforeIds = previous.ids();
+				const afterIds = read.ids();
+				const beforeKeys = new Set(beforeIds);
+				const afterKeys = new Set(afterIds);
+				const beforeCommon = beforeIds.filter((key) => afterKeys.has(key));
+				const afterCommon = afterIds.filter((key) => beforeKeys.has(key));
+				if (beforeCommon.some((key, index) => afterCommon[index] !== key)) order = Object.freeze({
+					before: Object.freeze([...beforeIds]),
+					after: Object.freeze([...afterIds])
+				});
+			}
+			if (!added.length && !removed.length && !updated.length && !order) return void 0;
 			return Object.freeze({
 				kind: "incremental",
-				added,
-				removed,
-				updated,
-				orderChanged
+				added: Object.freeze(added),
+				updated: Object.freeze(updated),
+				removed: Object.freeze(removed),
+				...order ? { order } : {}
 			});
 		};
 		let unsubscribe;
@@ -2286,12 +1832,18 @@ const createSources = (scheduler) => {
 					if (!pending) previous = event.previous;
 					read = port.current();
 					revision = event.revision;
-					addTransitionKeys(event.change);
-					reset ||= event.reset || event.change?.kind === "reset";
-					detail = event.detail;
-					cause = event.cause ?? cause;
-					batch = scheduler.batchContext() ?? event.batch;
-					recomputeTransitions();
+					if (event.impact?.kind === "incremental") {
+						event.impact.added.forEach((key) => transitionKeys.add(key));
+						event.impact.removed.forEach((key) => transitionKeys.add(key));
+						event.impact.updated.forEach((key) => transitionKeys.add(key));
+						orderChanged ||= Boolean(event.impact.added.size || event.impact.removed.size || event.impact.orderChanged);
+					} else if (!event.impact) {
+						previous.ids().forEach((key) => transitionKeys.add(key));
+						read.ids().forEach((key) => transitionKeys.add(key));
+						orderChanged = true;
+					}
+					reset ||= event.impact?.kind === "reset";
+					cause = event.cause ?? scheduler.batchContext()?.cause ?? cause;
 					change = deriveChange();
 					record.fault = void 0;
 					scheduler.capture(record);
@@ -2407,97 +1959,474 @@ const createSources = (scheduler) => {
 		},
 		assertCollection: (handle) => {
 			scheduler.source(handle);
-			if (!collections.has(handle) && !collectionHandles.has(handle)) throw new Error("map requires a collection source.");
+			if (!isCollectionSource(handle)) throw new Error("map requires a collection source.");
+		}
+	};
+};
+//#endregion
+//#region core/src/projection/node.ts
+const createNode = (scheduler, spec, behavior) => {
+	scheduler.assertIdle();
+	const entries = Object.entries(spec.sources).map(([key, handle]) => [key, scheduler.source(handle)]);
+	const order = scheduler.order();
+	const node = {
+		...behavior,
+		publish: () => {
+			if (node.fault) behavior.clear();
+			else behavior.publish();
+		},
+		order,
+		name: spec.name ? `${spec.name} (${order})` : `projection-${order}`,
+		sources: entries.map(([, source]) => source),
+		consumers: /* @__PURE__ */ new Set(),
+		disposed: false,
+		fault: void 0,
+		evaluate: (build) => {
+			let active = true;
+			try {
+				const scopeActive = () => active;
+				const inputs = Object.fromEntries(entries.map(([key, source]) => [key, source.context(scopeActive)]));
+				return behavior.evaluate(inputs, build, scopeActive);
+			} finally {
+				active = false;
+			}
+		}
+	};
+	scheduler.initialize(() => {
+		const invalid = node.sources.find((source) => source.fault || source.disposed);
+		if (invalid) throw invalid.fault ?? new ProjectionDisposedError();
+		node.evaluate(true);
+		node.publish();
+		node.clear();
+	});
+	const check = () => {
+		if (node.disposed || !scheduler.active) throw new ProjectionDisposedError();
+		if (node.fault) throw node.fault;
+	};
+	return {
+		node,
+		check,
+		install(handle) {
+			scheduler.register(handle, node);
+			scheduler.addNode(node);
 		}
 	};
 };
-//#endregion
-//#region core/src/projection/value.ts
-const createValue = (scheduler, spec, options) => {
+//#endregion
+//#region core/src/projection/value.ts
+const createValue = (scheduler, spec, options) => {
+	let instance;
+	let value;
+	let next;
+	let initialized = false;
+	let revision = 0;
+	let changed = false;
+	let reset = false;
+	let cause;
+	const listeners = /* @__PURE__ */ new Set();
+	const owner = createNode(scheduler, spec, {
+		evaluate: (sources, build) => {
+			cause = Object.values(sources).find((value) => value && typeof value === "object" && "cause" in value && value.cause !== void 0)?.cause ?? scheduler.batchContext()?.cause;
+			let candidate;
+			if (build || !instance) {
+				require_issue.profile.materialized.rebuilt();
+				instance = void 0;
+				const built = spec.build(sources);
+				assertSynchronous(built);
+				instance = built;
+				candidate = built.value;
+			} else {
+				require_issue.profile.materialized.updated();
+				const result = instance.update(sources);
+				assertSynchronous(result);
+				if (result.kind === "rebuild") {
+					instance = void 0;
+					const built = spec.build(sources);
+					assertSynchronous(built);
+					instance = built;
+					candidate = built.value;
+					build = true;
+				} else candidate = result.kind === "changed" ? result.value : value;
+			}
+			changed = !initialized || !(options?.isEqual ?? Object.is)(value, candidate);
+			next = changed ? candidate : value;
+			reset = build;
+			return changed;
+		},
+		context: (active) => {
+			assertScope(active);
+			return Object.freeze({
+				kind: "value",
+				value: next,
+				revision: revision + (changed ? 1 : 0),
+				reset,
+				cause
+			});
+		},
+		revision: () => revision,
+		reset: () => reset,
+		publish: () => {
+			if (changed && initialized) revision++;
+			value = next;
+			initialized = true;
+		},
+		emit: (call) => {
+			require_issue.profile.materialized.notification();
+			Array.from(listeners).forEach((listener) => call(listener));
+		},
+		clear: () => {
+			next = value;
+			changed = false;
+			reset = false;
+			cause = void 0;
+		},
+		release: () => {
+			listeners.clear();
+			instance = void 0;
+			value = next = void 0;
+		}
+	});
+	const handle = Object.freeze({
+		kind: "value",
+		current: () => {
+			owner.check();
+			return value;
+		},
+		revision: () => {
+			owner.check();
+			return revision;
+		},
+		subscribe: (listener) => {
+			owner.check();
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	});
+	owner.install(handle);
+	return handle;
+};
+//#endregion
+//#region core/src/projection/collection.ts
+const height = (node) => node?.height ?? 0;
+const makeTreeNode = (key, value, left, right) => Object.freeze({
+	key,
+	value,
+	left,
+	right,
+	height: Math.max(height(left), height(right)) + 1
+});
+const rotateLeft = (node) => {
+	const right = node.right;
+	return makeTreeNode(right.key, right.value, makeTreeNode(node.key, node.value, node.left, right.left), right.right);
+};
+const rotateRight = (node) => {
+	const left = node.left;
+	return makeTreeNode(left.key, left.value, left.left, makeTreeNode(node.key, node.value, left.right, node.right));
+};
+const rebalance = (node) => {
+	const balance = height(node.left) - height(node.right);
+	if (balance > 1) {
+		if (height(node.left.left) < height(node.left.right)) return rotateRight(makeTreeNode(node.key, node.value, rotateLeft(node.left), node.right));
+		return rotateRight(node);
+	}
+	if (balance < -1) {
+		if (height(node.right.right) < height(node.right.left)) return rotateLeft(makeTreeNode(node.key, node.value, node.left, rotateRight(node.right)));
+		return rotateLeft(node);
+	}
+	return node;
+};
+const treeSet = (node, key, value) => {
+	if (!node) return makeTreeNode(key, value);
+	if (key === node.key) return makeTreeNode(key, value, node.left, node.right);
+	if (key < node.key) return rebalance(makeTreeNode(node.key, node.value, treeSet(node.left, key, value), node.right));
+	return rebalance(makeTreeNode(node.key, node.value, node.left, treeSet(node.right, key, value)));
+};
+const treeMin = (node) => node.left ? treeMin(node.left) : node;
+const treeRemove = (node, key) => {
+	if (!node) return void 0;
+	if (key < node.key) return rebalance(makeTreeNode(node.key, node.value, treeRemove(node.left, key), node.right));
+	if (key > node.key) return rebalance(makeTreeNode(node.key, node.value, node.left, treeRemove(node.right, key)));
+	if (!node.left) return node.right;
+	if (!node.right) return node.left;
+	const next = treeMin(node.right);
+	return rebalance(makeTreeNode(next.key, next.value, node.left, treeRemove(node.right, next.key)));
+};
+const treeGet = (node, key) => {
+	let current = node;
+	while (current) {
+		if (key === current.key) return current.value;
+		current = key < current.key ? current.left : current.right;
+	}
+};
+const treeHas = (node, key) => {
+	let current = node;
+	while (current) {
+		if (key === current.key) return true;
+		current = key < current.key ? current.left : current.right;
+	}
+	return false;
+};
+const treeFromSorted = (entries, start = 0, end = entries.length) => {
+	if (start >= end) return void 0;
+	const middle = start + end >> 1;
+	const [key, value] = entries[middle];
+	return makeTreeNode(key, value, treeFromSorted(entries, start, middle), treeFromSorted(entries, middle + 1, end));
+};
+const createCollection = (scheduler, spec) => {
+	const values = /* @__PURE__ */ new Map();
+	let ids = Object.freeze([]);
+	let staged = /* @__PURE__ */ new Map();
+	let nextIds = ids;
+	let change;
 	let instance;
-	let value;
-	let next;
-	let previous;
 	let initialized = false;
-	let revision = 0;
-	let changed = false;
 	let reset = false;
-	let batch;
+	let revision = 0;
+	let publishedRoot;
 	let cause;
 	const listeners = /* @__PURE__ */ new Set();
+	const changedKeys = /* @__PURE__ */ new Set();
+	let orderChanged = false;
+	const readPublished = (root, publishedIds) => Object.freeze({
+		get: (key) => {
+			owner.check();
+			return treeGet(root, key);
+		},
+		has: (key) => {
+			owner.check();
+			return treeHas(root, key);
+		},
+		ids: () => {
+			owner.check();
+			return publishedIds;
+		}
+	});
+	const hasNext = (key) => staged.has(key) ? staged.get(key).present : values.has(key);
+	const getNext = (key) => {
+		const entry = staged.get(key);
+		return entry ? entry.present ? entry.value : void 0 : values.get(key);
+	};
 	const owner = createNode(scheduler, spec, {
-		evaluate: (sources, build) => {
-			const metadata = Object.values(sources).find((value) => value && typeof value === "object" && ("batch" in value && value.batch !== void 0 || "cause" in value && value.cause !== void 0));
-			batch = scheduler.batchContext() ?? metadata?.batch;
-			cause = metadata?.cause ?? batch?.cause;
-			let candidate;
+		evaluate: (sources, build, active) => {
+			cause = Object.values(sources).find((value) => value && typeof value === "object" && "cause" in value && value.cause !== void 0)?.cause ?? scheduler.batchContext()?.cause;
+			staged = /* @__PURE__ */ new Map();
+			nextIds = ids;
+			change = void 0;
+			changedKeys.clear();
+			let explicitOrder;
+			let cleared = false;
+			const nextHas = (key) => staged.has(key) ? staged.get(key).present : !cleared && values.has(key);
+			const nextGet = (key) => {
+				const entry = staged.get(key);
+				return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : values.get(key);
+			};
+			const deriveIds = () => {
+				const result = cleared ? [] : ids.filter(nextHas);
+				for (const [key, entry] of staged) if (entry.present && (cleared || !values.has(key))) result.push(key);
+				return result;
+			};
+			const read = (next) => ({
+				get: (key) => {
+					assertScope(active);
+					return next ? nextGet(key) : values.get(key);
+				},
+				has: (key) => {
+					assertScope(active);
+					return next ? nextHas(key) : values.has(key);
+				},
+				ids: () => {
+					assertScope(active);
+					return next ? Object.freeze(explicitOrder ? explicitOrder.slice() : deriveIds()) : ids;
+				}
+			});
+			const input = {
+				sources,
+				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 = order.slice();
+					}
+				}
+			};
 			if (build || !instance) {
 				require_issue.profile.materialized.rebuilt();
 				instance = void 0;
-				const built = spec.build(sources);
+				cleared = true;
+				const built = spec.build(input);
 				assertSynchronous(built);
 				instance = built;
-				candidate = built.value;
 			} else {
 				require_issue.profile.materialized.updated();
-				const result = instance.update(sources);
+				const result = instance.update(input);
 				assertSynchronous(result);
-				if (result.kind === "rebuild") {
+				if (result?.kind === "rebuild") {
+					staged.clear();
+					cleared = true;
+					explicitOrder = void 0;
 					instance = void 0;
-					const built = spec.build(sources);
+					const built = spec.build(input);
 					assertSynchronous(built);
 					instance = built;
-					candidate = built.value;
 					build = true;
-				} else candidate = result.kind === "changed" ? result.value : value;
+				}
+			}
+			if (cleared) {
+				for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
+			}
+			const added = /* @__PURE__ */ new Set();
+			const removed = /* @__PURE__ */ new Set();
+			const updated = /* @__PURE__ */ new Set();
+			require_issue.profile.projection("touchedKeys", staged.size);
+			for (const [key, entry] of staged) {
+				const existed = values.has(key);
+				if (entry.present) if (!existed) added.add(key);
+				else if (!(spec.isEqual ?? Object.is)(values.get(key), entry.value)) updated.add(key);
+				else staged.delete(key);
+				else if (existed) removed.add(key);
+				else staged.delete(key);
+			}
+			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 !== values.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, i) => key === order[i]) ? ids : Object.freeze(order.slice());
+			}
+			orderChanged = nextIds !== ids;
+			[
+				...added,
+				...removed,
+				...updated
+			].forEach((key) => changedKeys.add(key));
+			require_issue.profile.projection("changedKeys", changedKeys.size);
+			const addedEntries = [];
+			const updatedEntries = [];
+			const removedEntries = [];
+			for (const key of changedKeys) {
+				const beforePresent = values.has(key);
+				const afterPresent = hasNext(key);
+				if (beforePresent === afterPresent) {
+					if (!beforePresent) continue;
+					if ((spec.isEqual ?? Object.is)(values.get(key), getNext(key))) continue;
+				}
+				if (!beforePresent) addedEntries.push({
+					key,
+					after: getNext(key)
+				});
+				else if (!afterPresent) removedEntries.push({
+					key,
+					before: values.get(key)
+				});
+				else updatedEntries.push({
+					key,
+					before: values.get(key),
+					after: getNext(key)
+				});
+			}
+			if (build) change = Object.freeze({ kind: "reset" });
+			else if (addedEntries.length || updatedEntries.length || removedEntries.length || orderChanged) {
+				let commonOrderChanged = false;
+				if (orderChanged) {
+					const before = ids.filter((key) => !removed.has(key));
+					const after = nextIds.filter((key) => !added.has(key));
+					commonOrderChanged = before.some((key, i) => after[i] !== key);
+				}
+				change = Object.freeze({
+					kind: "incremental",
+					added: Object.freeze(addedEntries),
+					updated: Object.freeze(updatedEntries),
+					removed: Object.freeze(removedEntries),
+					...commonOrderChanged ? { order: Object.freeze({
+						before: Object.freeze([...ids]),
+						after: Object.freeze([...nextIds])
+					}) } : {}
+				});
 			}
-			previous = value;
-			changed = !initialized || !(options?.isEqual ?? Object.is)(value, candidate);
-			next = changed ? candidate : value;
 			reset = build;
-			return changed;
+			return change !== void 0;
 		},
 		context: (active) => {
-			assertScope(active);
-			return Object.freeze({
-				value: next,
-				previous,
-				changed,
-				revision: revision + (changed ? 1 : 0),
-				reset,
-				cause,
-				batch
-			});
+			const input = {
+				kind: "collection",
+				read: {
+					get: (key) => {
+						assertScope(active);
+						return getNext(key);
+					},
+					has: (key) => {
+						assertScope(active);
+						return hasNext(key);
+					},
+					ids: () => {
+						assertScope(active);
+						return nextIds;
+					}
+				},
+				change,
+				revision: revision + (change ? 1 : 0),
+				cause
+			};
+			return Object.freeze(input);
 		},
 		revision: () => revision,
 		reset: () => reset,
 		publish: () => {
-			if (changed && initialized) revision++;
-			value = next;
+			if (change) if (change.kind === "reset") {
+				const entries = [];
+				for (const [key, entry] of staged) if (entry.present) entries.push([key, entry.value]);
+				entries.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+				publishedRoot = treeFromSorted(entries);
+			} else for (const [key, entry] of staged) publishedRoot = entry.present ? treeSet(publishedRoot, key, entry.value) : treeRemove(publishedRoot, key);
+			for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
+			else values.delete(key);
+			if (change) {
+				if (initialized) revision++;
+			}
+			ids = nextIds;
 			initialized = true;
 		},
 		emit: (call) => {
 			require_issue.profile.materialized.notification();
-			Array.from(listeners).forEach((listener) => call(listener));
+			const resetEvent = Object.freeze({ kind: "reset" });
+			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
 		},
 		clear: () => {
-			next = value;
-			previous = value;
-			changed = false;
+			staged.clear();
+			nextIds = ids;
+			change = void 0;
 			reset = false;
-			batch = void 0;
+			changedKeys.clear();
 			cause = void 0;
+			orderChanged = false;
 		},
 		release: () => {
+			values.clear();
+			staged.clear();
+			publishedRoot = void 0;
 			listeners.clear();
+			ids = nextIds = Object.freeze([]);
 			instance = void 0;
-			value = next = previous = void 0;
 		}
 	});
-	const handle = Object.freeze({
+	const handle = {
+		kind: "collection",
 		current: () => {
 			owner.check();
-			return value;
+			return readPublished(publishedRoot, ids);
 		},
 		revision: () => {
 			owner.check();
@@ -2509,36 +2438,17 @@ const createValue = (scheduler, spec, options) => {
 			return () => {
 				listeners.delete(listener);
 			};
-		},
-		rebuild: owner.rebuild,
-		dispose: owner.dispose
-	});
+		}
+	};
 	owner.install(handle);
-	return handle;
+	return Object.freeze(handle);
 };
 //#endregion
-//#region core/src/projection/runtime.ts
-const createRuntimeExecutor = (options) => {
+//#region core/src/projection/graph.ts
+const createProjectionGraph = (options) => {
 	const scheduler = createScheduler(options.onError);
 	const sources = createSources(scheduler);
-	function value(input, computeOrOptions, options) {
-		if (typeof computeOrOptions !== "function") return createValue(scheduler, input, computeOrOptions);
-		const compute = (input) => {
-			const result = computeOrOptions(input);
-			assertSynchronous(result);
-			return result;
-		};
-		return createValue(scheduler, {
-			sources: input,
-			build: (input) => ({
-				value: compute(input),
-				update: (input) => ({
-					kind: "changed",
-					value: compute(input)
-				})
-			})
-		}, options);
-	}
+	const value = (spec, options) => createValue(scheduler, spec, options);
 	const map = (source, mapper, options) => {
 		sources.assertCollection(source);
 		const calculate = (id, entry) => {
@@ -2549,58 +2459,47 @@ const createRuntimeExecutor = (options) => {
 		return createCollection(scheduler, {
 			sources: { source },
 			isEqual: options?.isEqual,
-			build: ({ sources, writer }) => {
-				const input = sources.source;
-				const read = "read" in input ? input.read : input;
+			build: ({ sources, output }) => {
+				const read = sources.source.read;
 				const ids = read.ids();
 				require_issue.profile.collectionView.idsScanned(ids.length);
 				for (const id of ids) {
 					require_issue.profile.collectionView.mapped();
-					writer.set(id, calculate(id, read.get(id)));
+					output.set(id, calculate(id, read.get(id)));
 				}
-				writer.order(ids);
-				return { update: ({ sources, writer }) => {
+				output.order(ids);
+				return { update: ({ sources, output }) => {
 					const input = sources.source;
-					if (input.reset) return { kind: "rebuild" };
-					const read = "read" in input ? input.read : input;
-					let keys;
-					let structural;
-					if ("candidates" in input) {
-						keys = input.candidates.keys;
-						structural = input.candidates.orderDirty;
-					} else {
-						const change = input.change;
-						if (!change) return;
-						if (change.kind === "reset") return { kind: "rebuild" };
-						keys = new Set([
-							...change.added,
-							...change.removed,
-							...change.updated
-						]);
-						structural = Boolean(change.added.size || change.removed.size || change.orderChanged);
+					const read = input.read;
+					if (input.change?.kind === "reset") return { kind: "rebuild" };
+					const change = input.change;
+					if (!change) return;
+					for (const entry of change.added) {
+						require_issue.profile.collectionView.mapped();
+						output.set(entry.key, calculate(entry.key, entry.after));
 					}
-					for (const key of keys) if (!read.has(key)) writer.remove(key);
-					else {
+					for (const entry of change.updated) {
 						require_issue.profile.collectionView.mapped();
-						writer.set(key, calculate(key, read.get(key)));
+						output.set(entry.key, calculate(entry.key, entry.after));
 					}
-					if (structural) {
+					for (const entry of change.removed) output.remove(entry.key);
+					if (change.added.length || change.removed.length || change.order) {
 						const ids = read.ids();
 						require_issue.profile.collectionView.idsScanned(ids.length);
-						writer.order(ids);
+						output.order(ids);
 					}
 				} };
 			}
 		});
 	};
-	const runtime = {
+	const graph = {
 		document: sources.document,
 		fromSource: (source, options) => sources.fromSource(source, options),
 		fromCollectionSource: (source) => sources.fromCollectionSource(source),
 		input: sources.input,
 		fromReadable: sources.fromReadable,
 		value,
-		collection: () => (spec) => createCollection(scheduler, spec),
+		collection: (spec) => createCollection(scheduler, spec),
 		map,
 		batch: scheduler.batch,
 		dispose: () => {
@@ -2611,10 +2510,10 @@ const createRuntimeExecutor = (options) => {
 			}
 		}
 	};
-	return Object.freeze(runtime);
+	return Object.freeze(graph);
 };
 //#endregion
-//#region core/src/projection/store.ts
+//#region core/src/projection/runtime.ts
 let activeTracker;
 const trackKey = (key) => {
 	activeTracker?.keys.add(key);
@@ -2667,6 +2566,50 @@ const mapView = (read) => {
 	};
 	return Object.freeze(view);
 };
+const lazyMapView = (read) => {
+	const ids = read.ids();
+	const entries = function* () {
+		for (const key of ids) yield [key, read.get(key)];
+	};
+	const values = function* () {
+		for (const key of ids) yield read.get(key);
+	};
+	const view = {
+		get: (key) => {
+			trackKey(key);
+			return read.get(key);
+		},
+		has: (key) => {
+			trackKey(key);
+			return read.has(key);
+		},
+		get size() {
+			trackStructure();
+			return ids.length;
+		},
+		keys: () => {
+			trackStructure();
+			return ids[Symbol.iterator]();
+		},
+		values: () => {
+			trackAll();
+			return values();
+		},
+		entries: () => {
+			trackAll();
+			return entries();
+		},
+		forEach: (callback, thisArg) => {
+			trackAll();
+			for (const key of ids) callback.call(thisArg, read.get(key), key, view);
+		},
+		[Symbol.iterator]: () => {
+			trackAll();
+			return entries();
+		}
+	};
+	return Object.freeze(view);
+};
 const isMapLike = (value) => value instanceof Map || value !== null && typeof value === "object" && typeof value.get === "function" && typeof value.keys === "function" && typeof value.entries === "function";
 const mapRead = (value) => ({
 	get: (key) => value.get(key),
@@ -2674,22 +2617,35 @@ const mapRead = (value) => ({
 	ids: () => Object.freeze([...value.keys()])
 });
 const mapChange = (previous, current) => {
-	const added = /* @__PURE__ */ new Set();
-	const removed = /* @__PURE__ */ new Set();
-	const updated = /* @__PURE__ */ new Set();
-	for (const key of previous.keys()) if (!current.has(key)) removed.add(key);
-	else if (!Object.is(previous.get(key), current.get(key))) updated.add(key);
-	for (const key of current.keys()) if (!previous.has(key)) added.add(key);
+	const added = [];
+	const removed = [];
+	const updated = [];
+	for (const key of previous.keys()) if (!current.has(key)) removed.push({
+		key,
+		before: previous.get(key)
+	});
+	else if (!Object.is(previous.get(key), current.get(key))) updated.push({
+		key,
+		before: previous.get(key),
+		after: current.get(key)
+	});
+	for (const key of current.keys()) if (!previous.has(key)) added.push({
+		key,
+		after: current.get(key)
+	});
 	const before = [...previous.keys()].filter((key) => current.has(key));
 	const after = [...current.keys()].filter((key) => previous.has(key));
 	const orderChanged = before.length !== after.length || before.some((key, index) => key !== after[index]);
-	if (!added.size && !removed.size && !updated.size && !orderChanged) return void 0;
+	if (!added.length && !removed.length && !updated.length && !orderChanged) return void 0;
 	return {
 		kind: "incremental",
-		added,
-		removed,
-		updated,
-		orderChanged
+		added: Object.freeze(added),
+		removed: Object.freeze(removed),
+		updated: Object.freeze(updated),
+		...orderChanged ? { order: Object.freeze({
+			before: Object.freeze([...previous.keys()]),
+			after: Object.freeze([...current.keys()])
+		}) } : {}
 	};
 };
 const sameSelection = (left, right) => {
@@ -2699,45 +2655,71 @@ const sameSelection = (left, right) => {
 };
 const selectionAffects = (selection, change) => {
 	if (!change || change.kind === "reset") return true;
-	if (selection.all && (change.added.size || change.removed.size || change.updated.size || change.orderChanged)) return true;
-	if (selection.structure && (change.added.size || change.removed.size || change.orderChanged)) return true;
-	for (const key of selection.keys) if (change.added.has(key) || change.removed.has(key) || change.updated.has(key)) 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;
 	return false;
 };
 const currentValue = (event) => {
 	if (!event || typeof event !== "object") return event;
-	if ("value" in event) return event.value;
-	if ("read" in event) return require_scope.snapshot(event.read);
-	if ("ids" in event && typeof event.ids === "function") return mapView(event);
+	if ("kind" in event && event.kind === "value") return event.value;
+	if ("kind" in event && event.kind === "document") return require_scope.snapshot(event.read);
+	if ("kind" in event && event.kind === "collection") return mapView(event.read);
 	return event;
 };
 const sourceOf = (instance) => instance;
 const createProjectionRuntime = (options) => {
-	const runtime = createRuntimeExecutor({ onError: options?.onError ?? (() => void 0) });
-	const instances = /* @__PURE__ */ new WeakMap();
-	const inputs = /* @__PURE__ */ new WeakMap();
-	const collections = /* @__PURE__ */ new WeakMap();
+	const runtime = createProjectionGraph({ onError: options?.onError ?? (() => void 0) });
+	const materialized = /* @__PURE__ */ new WeakMap();
 	const materialize = (projection) => {
-		const old = instances.get(projection);
-		if (old) return old;
+		const old = materialized.get(projection);
+		if (old) return old.node;
 		const definition = require_definition.definitionOf(projection);
 		let instance;
+		let setter;
 		switch (definition.kind) {
 			case "input": {
 				const input = runtime.input(definition.initial, { isEqual: definition.isEqual });
-				inputs.set(projection, input);
-				instance = runtime.value({ input: input.source }, ({ input }) => input.value);
+				setter = input.set;
+				instance = runtime.value({
+					sources: { input: input.source },
+					build: (values) => ({
+						value: values.input.value,
+						update: (next) => ({
+							kind: "changed",
+							value: next.input.value
+						})
+					})
+				});
 				break;
 			}
 			case "readable": {
 				const source = runtime.fromReadable(definition.readable, { isEqual: definition.isEqual });
-				instance = runtime.value({ source }, ({ source }) => source.value);
+				instance = runtime.value({
+					sources: { source },
+					build: (values) => ({
+						value: values.source.value,
+						update: (next) => ({
+							kind: "changed",
+							value: next.source.value
+						})
+					})
+				});
 				break;
 			}
 			case "source-value":
 				{
 					const source = runtime.fromSource(definition.source);
-					instance = runtime.value({ source }, ({ source }) => source.value);
+					instance = runtime.value({
+						sources: { source },
+						build: (values) => ({
+							value: values.source.value,
+							update: (next) => ({
+								kind: "changed",
+								value: next.source.value
+							})
+						})
+					});
 				}
 				break;
 			case "source-collection": {
@@ -2748,26 +2730,51 @@ const createProjectionRuntime = (options) => {
 			case "document": {
 				const document = runtime.document(definition.document);
 				if (!definition.selector) {
-					instance = runtime.value({ document }, ({ document }) => require_scope.snapshot(document.read));
+					instance = runtime.value({
+						sources: { document },
+						build: (values) => ({
+							value: require_scope.snapshot(values.document.read),
+							update: (next) => ({
+								kind: "changed",
+								value: require_scope.snapshot(next.document.read)
+							})
+						})
+					});
 					break;
 				}
 				const state = require_notification.accessOf(definition.document);
 				try {
 					const collection = document.collection(definition.selector);
-					instance = runtime.map(collection, (_id, entry) => require_scope.snapshot(entry));
+					instance = runtime.map(collection, (_id, entry) => entry);
 					break;
 				} catch {
 					const selected = document.targets(definition.selector);
 					const address = compilePath(state.schema, "value", definition.selector).address;
-					instance = runtime.value({ selected }, () => {
-						return require_issue.read(require_scope.snapshot(state.document), address, state.schema);
+					instance = runtime.value({
+						sources: { selected },
+						build: () => ({
+							value: require_issue.read(require_scope.snapshot(state.document), address, state.schema),
+							update: () => ({
+								kind: "changed",
+								value: require_issue.read(require_scope.snapshot(state.document), address, state.schema)
+							})
+						})
 					});
 				}
 				break;
 			}
 			case "derive": {
 				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency))]));
-				instance = runtime.value(sources, (values) => definition.compute(...Object.values(values).map(currentValue)), { isEqual: definition.isEqual });
+				instance = runtime.value({
+					sources,
+					build: (values) => ({
+						value: definition.compute(...Object.values(values).map(currentValue)),
+						update: (next) => ({
+							kind: "changed",
+							value: definition.compute(...Object.values(next).map(currentValue))
+						})
+					})
+				}, { isEqual: definition.isEqual });
 				break;
 			}
 			case "incremental-value": {
@@ -2780,7 +2787,7 @@ const createProjectionRuntime = (options) => {
 			}
 			case "incremental-collection": {
 				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
-				instance = runtime.collection()({
+				instance = runtime.collection({
 					sources,
 					build: definition.build,
 					isEqual: definition.isEqual,
@@ -2789,32 +2796,37 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 		}
-		instances.set(projection, instance);
+		materialized.set(projection, {
+			node: instance,
+			set: setter
+		});
 		return instance;
 	};
 	const get = (projection) => {
 		const instance = materialize(projection);
 		const current = instance.current();
-		if (current && typeof current === "object" && "ids" in current && typeof current.ids === "function") {
-			const existing = collections.get(instance);
+		if (instance.kind === "collection") {
+			const record = materialized.get(projection) ?? materialized.get(instance);
+			const existing = record?.collection;
 			const revision = instance.revision();
 			if (existing?.revision === revision) return existing.value;
-			const value = mapView(current);
-			collections.set(instance, {
+			const value = lazyMapView(current);
+			if (record) record.collection = {
 				revision,
 				value
-			});
+			};
 			return value;
 		}
 		if (isMapLike(current)) {
-			const existing = collections.get(instance);
+			const record = materialized.get(projection) ?? materialized.get(instance);
+			const existing = record?.collection;
 			const revision = instance.revision();
 			if (existing?.revision === revision) return existing.value;
 			const value = mapView(mapRead(current));
-			collections.set(instance, {
+			if (record) record.collection = {
 				revision,
 				value
-			});
+			};
 			return value;
 		}
 		return current;
@@ -2932,8 +2944,8 @@ const createProjectionRuntime = (options) => {
 		readable,
 		set: ((input, value) => {
 			materialize(input);
-			const target = inputs.get(input);
-			if (!target) throw new TypeError("Projection is not an input.");
+			const target = materialized.get(input);
+			if (!target?.set) throw new TypeError("Projection is not an input.");
 			target.set(value);
 		}),
 		batch: runtime.batch,