doxum 0.1.19 → 0.1.21

package/dist/index.js

@@ -1,96 +1,8 @@
-import { A as insert, D as equal, F as remove, L as profile, M as keys, N as matches, _ as resolveTreeContainer, a as compiledShape, c as debugKey, d as overlaps, f as read$1, g as resolveLocated, h as resolveContainer, i as AddressIndex, j as install, l as memberKey, n as fail, o as contains, p as resolveAddress, r as invalidValue, s as createAddressResolver, t as MutationRejected, u as nodeAt, v as resolveValue } from "./issue-DVaGQGeP.js";
-import { a as ParseError, c as copyValue, i as snapshot, l as equalValue, n as createAccess, o as checkKey, r as replace, s as checkValue, t as collectionAccess, u as parse } from "./scope-d-L87NeC.js";
-import { _ as affected, a as documentReadableOwner, d as accessOf, f as bindRuntimeAccess, g as TransactionRejected, h as DocumentReentrancyError, i as disposeNotification, l as subscribeRoot, m as DocumentDisposedError, n as bindDocumentReadable, o as notify, p as readWith, r as createNotification, s as shareNotification, t as attachProjection, u as subscribeTargets, v as belongs, y as same } from "./notification-IQIJyH3Q.js";
-import { n as bindRuntimeDriver, o as decodeChanges, r as disposeRuntimeDriver, s as sealChanges, t as assertRuntimeWritable } from "./driver-CSnhMjbP.js";
-import { a as projectionHandles, c as definitionOf, d as isProjection, f as observe, i as createScheduler, l as derive, m as ownerOf, n as assertScope, o as ProjectionDisposedError, p as ownDefinition, r as assertSynchronous, s as ProjectionError, t as incremental, u as input } from "./advanced-BYZCjNWL.js";
-//#region core/src/schema.ts
-const node = (value) => Object.freeze(value);
-const field = (validator) => node({
-	kind: "field",
-	...validator ? { validator } : {}
-});
-const optional = (value) => {
-	if (![
-		"field",
-		"variant",
-		"map",
-		"list",
-		"tree"
-	].includes(value.kind)) throw new TypeError("Only field, variant, map, list and tree nodes support optional presence.");
-	return node({
-		...value,
-		optional: true
-	});
-};
-const object = (shape) => node({
-	kind: "object",
-	shape: Object.freeze({ ...shape })
-});
-const variant = (tag, variants) => node({
-	kind: "variant",
-	tag,
-	variants: Object.freeze({ ...variants })
-});
-const table = (value, options) => node({
-	kind: "table",
-	value,
-	...options
-});
-const map = (value, options) => node({
-	kind: "map",
-	value,
-	...options
-});
-const list = (value, config) => node({
-	kind: "list",
-	keyOf: config.keyOf,
-	value
-});
-const tree = (value) => node({
-	kind: "tree",
-	value
-});
-const paths = /* @__PURE__ */ new WeakMap();
-const pathProxy = (nodes, address, owner) => {
-	const proxy = new Proxy({}, { get: (_target, property) => {
-		if (typeof property !== "string") return void 0;
-		if (nodes.every((node) => node.kind === "table" || node.kind === "map") && property === "item") return (id) => {
-			if (typeof id !== "string") throw new TypeError("Collection keys must be strings.");
-			for (const node of nodes) if (node.kind === "table" || node.kind === "map") {
-				const invalid = checkKey(node.key, id, [...address, id]);
-				if (invalid) throw new TypeError(invalid.message);
-			}
-			return pathProxy(nodes.map((node) => node.value), [...address, id], owner);
-		};
-		const children = nodes.flatMap((node) => {
-			if (node.kind === "object") return Object.hasOwn(node.shape, property) ? [node.shape[property]] : [];
-			if (node.kind !== "variant") return [];
-			if (property === node.tag) return [field()];
-			return Object.values(node.variants).flatMap((branch) => Object.hasOwn(branch.shape, property) ? [branch.shape[property]] : []);
-		});
-		if (!children.length) throw new TypeError(`Invalid schema path segment: ${property}`);
-		return pathProxy(children, [...address, property], owner);
-	} });
-	paths.set(proxy, {
-		nodes,
-		address,
-		owner
-	});
-	return proxy;
-};
-const compilePath = (owner, kind, pick) => {
-	const scope = {};
-	const value = pick(pathProxy([owner], [], scope));
-	const selected = typeof value === "object" && value !== null ? paths.get(value) : void 0;
-	if (!selected || selected.owner !== scope) throw new TypeError("Selector must return a path from its callback.");
-	if (kind === "collection" && !selected.nodes.every((node) => node.kind === "table" || node.kind === "map")) throw new TypeError("Collection selectors require a table or map path.");
-	return Object.freeze({
-		kind,
-		schema: owner,
-		address: Object.freeze([...selected.address])
-	});
-};
-//#endregion
+import { A as install, B as profile, E as equal, F as matches, L as remove, O as indexedKeys, R as toArray, _ as resolveTreeContainer, a as compiledShape, c as debugKey, d as overlaps, f as read$1, g as resolveLocated, h as resolveContainer, i as AddressIndex, k as insert, l as memberKey, n as fail, o as contains, p as resolveAddress, r as invalidValue, s as createAddressResolver, t as MutationRejected, u as nodeAt, v as resolveValue } from "./issue-W0hT8u8D.js";
+import { a as DocumentReentrancyError, c as createAccess, d as ParseError, f as checkKey, g as parse, h as equalValue, i as DocumentDisposedError, l as replace, m as copyValue, n as bindRuntimeAccess, o as TransactionRejected, p as checkValue, r as readWith, s as collectionAccess, t as accessOf, u as snapshot } from "./access-BeSV5ve-.js";
+import { C as list, D as table, E as optional, O as tree, S as field, T as object, _ as createScheduler, a as observe, b as collectionEntryNode, c as projectionRef, d as createCollectionOutput, f as mapRead, g as assertSynchronous, h as assertScope, i as isProjection, k as variant, l as collectionChangeBetween, m as stageCollectionRead, n as derive, o as ownProjection, p as snapshotCollectionView, r as input, s as producerOf, t as incremental, u as collectionView, v as ProjectionDisposedError, w as map, x as compilePath, y as ProjectionError } from "./advanced-COFJtWMT.js";
+import { a as documentReadableOwner, d as affected, f as belongs, i as disposeNotification, l as subscribeRoot, n as bindDocumentReadable, o as notify, r as createNotification, s as shareNotification, t as attachProjection, u as subscribeTargets } from "./notification-Bkjau6B6.js";
+import { n as bindRuntimeDriver, o as decodeChanges, r as disposeRuntimeDriver, s as sealChanges, t as assertRuntimeWritable } from "./driver-CLYJOGDQ.js";
 //#region core/src/impact.ts
 const queries = /* @__PURE__ */ new WeakMap();
 const affectsTarget = (impact, value) => queries.get(impact).affects(value);
@@ -372,7 +284,7 @@ const installMember = (parent, key, present, value) => {
 	});
 };
 const orderOf = (node, value) => {
-	if (node.kind === "list") return value.map(node.keyOf);
+	if (node.kind === "list") return toArray(indexedKeys(value, node.keyOf));
 	if (node.kind === "table") return [...value.ids];
 	throw new Error("Order requires a table or list.");
 };
@@ -514,7 +426,7 @@ const sealMembers = (fact, changes) => {
 	}
 	let order;
 	if (fact.order) {
-		const current = fact.node.kind === "list" ? keys(fact.value, fact.node.keyOf) : fact.value.ids;
+		const current = fact.node.kind === "list" ? indexedKeys(fact.value, fact.node.keyOf) : fact.value.ids;
 		if (!equal(fact.order, current)) {
 			const after = orderOf(fact.node, fact.value);
 			profile.recorder("publishedOrderItems", after.length);
@@ -1103,1945 +1015,1219 @@ const asReadable = (runtime) => {
 //#region core/src/projection/select.ts
 const read = (runtime, selector) => readWith(runtime, selector);
 //#endregion
-//#region core/src/projection/source.ts
-const createSources = (scheduler) => {
-	const documents = /* @__PURE__ */ new Map();
-	const readables = /* @__PURE__ */ new Map();
-	const externalSources = /* @__PURE__ */ new WeakMap();
-	const isCollectionSource = (value) => value.kind === "collection";
-	const document = (runtime) => {
-		scheduler.assertIdle();
-		const state = accessOf(runtime);
-		if (state.disposed) throw new Error("Document has been disposed.");
-		const existing = documents.get(state);
-		if (existing) return existing;
-		const bindings = [];
-		let batch;
-		const make = (input) => {
-			const collection = "collection" in input ? input.collection : void 0;
-			const targets = "targets" in input ? input.targets : [input.collection];
-			if (state.disposed) throw new Error("Document has been disposed.");
-			targets.forEach((value) => {
-				if (!belongs(value, state.schema)) throw new Error("Projection target belongs to another schema.");
-			});
-			const old = bindings.find((entry) => Boolean(collection) === isCollectionSource(entry.handle) && entry.targets.length === targets.length && entry.targets.every((value, i) => same(value, targets[i])));
-			if (old) return old.handle;
-			let reset = false;
-			let orderChanged = false;
-			const keys = /* @__PURE__ */ new Set();
-			let baseline;
-			let baselineIds = Object.freeze([]);
-			let nextBaseline;
-			let nextBaselineIds = Object.freeze([]);
-			const collectionNode = collection ? 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 ? equalValue(entryNode, left, right) : Object.is(left, right);
-			const record = {
-				consumers: /* @__PURE__ */ new Set(),
-				disposed: false,
-				fault: void 0,
-				revision: runtime.revision,
-				reset: () => reset,
-				clear: () => {
-					if (collection && nextBaseline) {
-						baseline = nextBaseline;
-						baselineIds = nextBaselineIds;
-					}
-					reset = false;
-					orderChanged = false;
-					batch = void 0;
-					keys.clear();
-					nextBaseline = void 0;
-					nextBaselineIds = Object.freeze([]);
-				},
-				context: (active) => {
-					assertScope(active);
-					if (state.disposed) throw new Error("Document has been disposed.");
-					const context = {
-						state,
-						active
-					};
-					const rawRead = collection ? 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, snapshot(rawRead.get(key)));
-							return snapshots.get(key);
-						},
-						has: (key) => {
-							assertScope(active);
-							return rawRead.has(key);
-						},
-						ids: () => {
-							assertScope(active);
-							return rawRead.ids();
-						}
-					}) : createAccess(context);
-					if (!collection) return Object.freeze({
-						kind: "document",
-						read,
-						revision: runtime.revision(),
-						reset: record.reset(),
-						cause: batch?.cause
-					});
-					if (!baseline) {
-						const collectionRead = read;
-						baseline = /* @__PURE__ */ new Map();
-						baselineIds = Object.freeze(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 ? { kind: "collection" } : {
-				collection: (pick) => {
-					scheduler.assertIdle();
-					return make({ collection: compilePath(state.schema, "collection", pick) });
-				},
-				targets: (...selected) => {
-					scheduler.assertIdle();
-					if (!selected.length) throw new TypeError("Expected at least one target.");
-					return make({ targets: selected.map((pick) => compilePath(state.schema, "value", pick)) });
-				}
-			};
-			Object.freeze(handle);
-			scheduler.register(handle, record);
-			const receive = (commit) => {
-				reset ||= commit.impact.kind === "reset";
-				if (collection) {
-					const change = collectionImpact(commit.impact, collection);
-					if (change.kind === "reset") reset = true;
-					else {
-						change.added.forEach((key) => keys.add(key));
-						change.removed.forEach((key) => keys.add(key));
-						change.updated.forEach((key) => keys.add(key));
-						orderChanged ||= Boolean(change.added.size || change.removed.size || change.orderChanged);
-					}
-				}
-			};
-			bindings.push({
-				handle,
-				targets,
-				record,
-				receive
-			});
-			return handle;
-		};
-		const handle = make({ targets: [] });
-		const guard = (locked) => {
-			state.projectionLocks = (state.projectionLocks ?? 0) + (locked ? 1 : -1);
-		};
-		scheduler.guards.add(guard);
-		const unsubscribe = attachProjection(runtime, {
-			capture: (commit) => {
-				for (const binding of bindings) if (!binding.targets.length || binding.targets.some((value) => affectsTarget(commit.impact, value))) {
-					binding.receive(commit);
-					batch = scheduler.batchContext();
-					scheduler.capture(binding.record);
-				}
-			},
-			settle: scheduler.settle,
-			flush: scheduler.flush,
-			dispose: () => {
-				bindings.forEach(({ record }) => {
-					record.fault = new ProjectionError("source", "document disposed", [runtime.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
-					scheduler.capture(record);
-				});
-				scheduler.run();
-			}
-		});
-		scheduler.cleanups.add(() => {
-			unsubscribe();
-			scheduler.guards.delete(guard);
-		});
-		documents.set(state, handle);
-		return handle;
-	};
-	const valueSource = (initial, equal) => {
-		let value = initial;
-		let revision = 0;
-		let cause;
-		let reset = false;
-		const handle = Object.freeze({});
-		const record = {
-			consumers: /* @__PURE__ */ new Set(),
-			disposed: false,
-			fault: void 0,
-			revision: () => revision,
-			reset: () => reset,
-			clear: () => {
-				cause = void 0;
-				reset = false;
+//#region core/src/projection/value-output.ts
+const unset = Symbol("projection-value-unset");
+/** Owns staged and published state for one scalar Projection output. */
+const createValueOutput = () => {
+	let value;
+	let staged = unset;
+	let next;
+	let initialized = false;
+	let revision = 0;
+	let changed = false;
+	let reset = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const begin = (active, initialize) => {
+		staged = unset;
+		next = value;
+		changed = false;
+		reset = initialize;
+		return {
+			previous: initialized ? value : void 0,
+			next: () => {
+				assertScope(active);
+				if (staged !== unset) return staged;
+				return initialize ? void 0 : initialized ? value : void 0;
 			},
-			context: (active) => {
+			output: Object.freeze({ set: (candidate) => {
 				assertScope(active);
-				return Object.freeze({
-					kind: "value",
-					value,
-					revision,
-					reset,
-					cause
-				});
-			}
-		};
-		scheduler.register(handle, record);
-		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.cause !== void 0);
-			if (equal(value, next) && !recovering && !eventful) return;
-			record.fault = void 0;
-			value = next;
-			revision = metadata?.revision ?? revision + 1;
-			cause = metadata?.cause ?? scheduler.batchContext()?.cause ?? cause;
-			reset ||= metadata?.reset ?? false;
-			scheduler.capture(record);
-		};
-		return {
-			source: handle,
-			accept,
-			set(next) {
-				accept(next);
-				scheduler.run();
-			}
+				staged = candidate;
+			} })
 		};
 	};
-	const collectionInput = (initial) => {
-		const values = new Map(initial);
-		const touched = /* @__PURE__ */ new Map();
-		let beforeIds;
-		let revision = 0;
-		let cause;
-		const handle = Object.freeze({ kind: "collection" });
-		const change = () => {
-			const added = [];
-			const updated = [];
-			const removed = [];
-			for (const [key, before] of touched) {
-				const afterPresent = values.has(key);
-				if (!before.present && afterPresent) added.push({
-					key,
-					after: values.get(key)
-				});
-				else if (before.present && !afterPresent) removed.push({
-					key,
-					before: before.value
-				});
-				else if (before.present && afterPresent && !Object.is(before.value, values.get(key))) updated.push({
-					key,
-					before: before.value,
-					after: values.get(key)
-				});
-			}
-			let order;
-			if (beforeIds) {
-				const afterIds = [...values.keys()];
-				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) => key !== afterCommon[index])) order = Object.freeze({
-					before: beforeIds,
-					after: Object.freeze(afterIds)
-				});
-			}
-			if (!added.length && !updated.length && !removed.length && !order) return void 0;
+	const seal = (nextReset, isEqual) => {
+		if (reset && staged === unset) throw new TypeError("Value output must be initialized on reset.");
+		if (staged === unset) {
+			reset = nextReset;
+			changed = false;
+			next = value;
+			return false;
+		}
+		const candidate = staged;
+		changed = !initialized || !isEqual(value, candidate);
+		next = changed ? candidate : value;
+		reset = nextReset;
+		return changed;
+	};
+	return {
+		begin,
+		seal,
+		context: (active, cause) => {
+			assertScope(active);
 			return Object.freeze({
-				kind: "incremental",
-				added: Object.freeze(added),
-				updated: Object.freeze(updated),
-				removed: Object.freeze(removed),
-				...order ? { order } : {}
+				kind: "value",
+				value: next,
+				revision,
+				reset,
+				cause
 			});
-		};
-		const record = {
-			consumers: /* @__PURE__ */ new Set(),
-			disposed: false,
-			fault: void 0,
-			revision: () => revision,
-			reset: () => false,
-			shouldSettle: () => change() !== void 0,
-			clear: () => {
-				touched.clear();
-				beforeIds = void 0;
-				cause = void 0;
-			},
-			context: (active) => {
-				assertScope(active);
-				const read = Object.freeze({
-					get: (key) => {
-						assertScope(active);
-						return values.get(key);
-					},
-					has: (key) => {
-						assertScope(active);
-						return values.has(key);
-					},
-					ids: () => {
-						assertScope(active);
-						return Object.freeze([...values.keys()]);
-					}
-				});
-				return Object.freeze({
-					kind: "collection",
-					read,
-					change: change(),
-					revision,
-					cause
-				});
-			}
-		};
-		scheduler.register(handle, record);
-		return {
-			source: handle,
-			update(run) {
-				scheduler.assertIdle();
-				const staged = /* @__PURE__ */ new Map();
-				let active = true;
-				const draft = Object.freeze({
-					get: (key) => {
-						assertScope(() => active);
-						const entry = staged.get(key);
-						return entry ? entry.present ? entry.value : void 0 : values.get(key);
-					},
-					has: (key) => {
-						assertScope(() => active);
-						const entry = staged.get(key);
-						return entry ? entry.present : values.has(key);
-					},
-					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);
-						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-						staged.set(key, { present: false });
-					}
-				});
-				try {
-					assertSynchronous(run(draft));
-				} finally {
-					active = false;
-				}
-				let changed = false;
-				for (const [key, entry] of staged) {
-					const present = values.has(key);
-					if (entry.present ? present && Object.is(values.get(key), entry.value) : !present) continue;
-					if (!touched.has(key)) touched.set(key, {
-						present,
-						value: values.get(key)
-					});
-					if (!beforeIds && present !== entry.present) beforeIds = Object.freeze([...values.keys()]);
-					if (entry.present) values.set(key, entry.value);
-					else values.delete(key);
-					changed = true;
-				}
-				if (!changed) return;
-				revision++;
-				cause = scheduler.batchContext()?.cause ?? cause;
-				scheduler.capture(record);
-				scheduler.run();
-			}
-		};
+		},
+		current: (check) => {
+			check();
+			return value;
+		},
+		revision: () => revision,
+		reset: () => reset,
+		publish: () => {
+			if (changed && initialized) revision++;
+			if (changed) value = next;
+			initialized = true;
+		},
+		emit: (call) => {
+			profile.materialized.notification();
+			Array.from(listeners).forEach((listener) => call(listener));
+		},
+		clear: () => {
+			staged = unset;
+			next = value;
+			changed = false;
+			reset = false;
+		},
+		release: () => {
+			listeners.clear();
+			staged = unset;
+			value = next = void 0;
+			initialized = false;
+			revision = 0;
+			changed = false;
+			reset = false;
+		},
+		subscribe: (listener) => listeners.add(listener),
+		unsubscribe: (listener) => listeners.delete(listener)
 	};
-	const externalValueSource = (port, equal) => {
-		scheduler.assertIdle();
-		const old = externalSources.get(port);
-		if (old) return old;
-		const input = valueSource(port.current(), equal);
-		const fail = (cause) => {
-			const record = scheduler.source(input.source);
-			record.fault = new ProjectionError("source", "external source", [record.revision()], cause);
-			scheduler.capture(record);
-		};
-		let unsubscribe;
-		try {
-			unsubscribe = port.subscribe((event) => {
-				try {
-					input.accept(event.value, {
-						revision: event.revision,
-						reset: event.reset ?? false,
-						cause: event.cause
-					});
-				} catch (cause) {
-					fail(cause);
-				}
-				scheduler.run();
-			});
-		} catch (cause) {
-			unsubscribe?.();
-			scheduler.unregisterSource(input.source);
-			throw cause;
-		}
-		scheduler.cleanups.add(() => unsubscribe?.());
-		externalSources.set(port, input.source);
-		return input.source;
+};
+//#endregion
+//#region core/src/projection/processor.ts
+/** Materializes every derive/incremental/group definition through one processor lifecycle. */
+const createProcessor = (scheduler, definition, dependencies) => {
+	scheduler.assertIdle();
+	let processor;
+	let instance;
+	let cause;
+	const check = () => {
+		if (!scheduler.active || processor.disposed) throw new ProjectionDisposedError();
+		if (processor.fault) throw processor.fault;
 	};
-	const externalCollectionSource = (port) => {
-		scheduler.assertIdle();
-		const old = externalSources.get(port);
-		if (old) return old;
-		let read = port.current();
-		let previous = read;
-		let revision = port.revision();
-		let change;
-		let reset = false;
-		let orderChanged = false;
-		let cause;
-		let transitionKeys = /* @__PURE__ */ new Set();
-		let pending = false;
-		const handle = Object.freeze({ kind: "collection" });
-		const record = {
-			consumers: /* @__PURE__ */ new Set(),
-			disposed: false,
-			fault: void 0,
-			revision: () => revision,
-			reset: () => reset,
-			clear: () => {
-				previous = read;
-				pending = false;
-				change = void 0;
-				reset = false;
-				orderChanged = false;
-				cause = void 0;
-				transitionKeys.clear();
-			},
-			context: (active) => {
-				assertScope(active);
-				const currentRead = Object.freeze({
-					get: (key) => {
-						assertScope(active);
-						return read.get(key);
+	const bound = definition.outputs.map((outputDefinition) => {
+		if (outputDefinition.kind === "value") {
+			const state = createValueOutput();
+			return {
+				kind: "value",
+				definition: outputDefinition,
+				state,
+				output: {
+					kind: "value",
+					get owner() {
+						return processor;
 					},
-					has: (key) => {
-						assertScope(active);
-						return read.has(key);
+					consumers: /* @__PURE__ */ new Set(),
+					context: (active) => state.context(active, cause),
+					current: () => state.current(check),
+					revision: state.revision,
+					reset: state.reset,
+					subscribe: (listener) => {
+						check();
+						const wrapped = () => listener();
+						state.subscribe(wrapped);
+						return () => state.unsubscribe(wrapped);
 					},
-					ids: () => {
-						assertScope(active);
-						return read.ids();
-					}
-				});
-				return Object.freeze({
-					kind: "collection",
-					read: currentRead,
-					change,
-					revision,
-					cause
-				});
+					emit: state.emit,
+					clear: state.clear,
+					release: state.release
+				}
+			};
+		}
+		const state = createCollectionOutput();
+		return {
+			kind: "collection",
+			definition: outputDefinition,
+			state,
+			output: {
+				kind: "collection",
+				get owner() {
+					return processor;
+				},
+				consumers: /* @__PURE__ */ new Set(),
+				context: (active) => state.context(active, cause),
+				current: () => state.current(check),
+				revision: state.revision,
+				reset: state.reset,
+				subscribe: (listener) => {
+					check();
+					const wrapped = (change) => listener(change);
+					state.subscribe(wrapped);
+					return () => state.unsubscribe(wrapped);
+				},
+				emit: state.emit,
+				clear: state.clear,
+				release: state.release
 			}
 		};
-		scheduler.register(handle, record);
-		const fail = (error) => {
-			record.fault = new ProjectionError("source", "external collection source", [revision], error);
-			scheduler.capture(record);
-		};
-		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 && afterPresent) added.push({
-					key,
-					after
-				});
-				else if (beforePresent && !afterPresent) removed.push({
-					key,
-					before
-				});
-				else if (beforePresent && afterPresent) updated.push({
-					key,
-					before,
-					after
-				});
-			}
-			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;
+	});
+	const begin = (active, initialize) => Object.freeze(bound.map((entry) => {
+		if (entry.kind === "value") {
+			const evaluation = entry.state.begin(active, initialize);
 			return Object.freeze({
-				kind: "incremental",
-				added: Object.freeze(added),
-				updated: Object.freeze(updated),
-				removed: Object.freeze(removed),
-				...order ? { order } : {}
-			});
-		};
-		let unsubscribe;
-		try {
-			unsubscribe = port.subscribe((event) => {
-				try {
-					scheduler.assertIdle();
-					if (!pending) previous = event.previous;
-					read = port.current();
-					revision = event.revision;
-					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);
-					pending = true;
-				} catch (error) {
-					fail(error);
-				}
-				scheduler.run();
+				kind: "value",
+				...evaluation
 			});
-		} catch (error) {
-			unsubscribe?.();
-			scheduler.unregisterSource(handle);
-			throw error;
 		}
-		scheduler.cleanups.add(() => unsubscribe?.());
-		externalSources.set(port, handle);
-		return handle;
+		const evaluation = entry.state.begin(active, initialize);
+		return Object.freeze({
+			kind: "collection",
+			...evaluation
+		});
+	}));
+	const seal = (reset) => {
+		const changed = [];
+		for (const entry of bound) if (entry.state.seal(reset, entry.definition.equality)) changed.push(entry.output);
+		return Object.freeze(changed);
 	};
-	return {
-		dispose: () => {
-			documents.clear();
-			readables.clear();
-		},
-		document,
-		fromSource: (source, options) => externalValueSource(source, options?.isEqual ?? Object.is),
-		fromCollectionSource: (source) => externalCollectionSource(source),
-		input: (initial, options) => {
-			const { source, set } = valueSource(initial, options?.isEqual ?? Object.is);
-			return Object.freeze({
-				source,
-				set
+	const run = (reset, runCause) => {
+		cause = runCause;
+		let active = true;
+		try {
+			const scopeActive = () => active;
+			const sources = Object.freeze(dependencies.map((output) => output.context(scopeActive)));
+			let outputs = begin(scopeActive, reset);
+			if (!instance) instance = definition.create();
+			profile.materialized[reset ? "rebuilt" : "updated"]();
+			let result = instance.evaluate({
+				reset,
+				cause: runCause,
+				sources,
+				outputs
 			});
-		},
-		collectionInput,
-		fromReadable: (readable, options) => {
-			scheduler.assertIdle();
-			if (projectionHandles.has(readable)) throw new Error("Projection nodes must be declared directly as sources.");
-			const equal = options?.isEqual ?? Object.is;
-			let bindings = readables.get(readable);
-			const old = bindings?.get(equal);
-			if (old) return old.source;
-			const input = valueSource(readable.current(), equal);
-			if (bindings) {
-				bindings.set(equal, {
-					source: input.source,
-					accept: (value) => input.accept(value)
+			assertSynchronous(result);
+			if (result?.kind === "rebuild") {
+				if (reset) throw new TypeError("Initial or reset projection processor cannot rebuild.");
+				instance.release?.();
+				instance = definition.create();
+				outputs = begin(scopeActive, true);
+				result = instance.evaluate({
+					reset: true,
+					cause: runCause,
+					sources,
+					outputs
 				});
-				return input.source;
+				assertSynchronous(result);
+				if (result?.kind === "rebuild") throw new TypeError("Reset projection processor cannot rebuild again.");
+				return seal(true);
 			}
-			bindings = new Map([[equal, {
-				source: input.source,
-				accept: (value) => input.accept(value)
-			}]]);
-			const members = bindings;
-			const receive = (settle = true) => {
-				if (!scheduler.active) return;
-				let value;
-				try {
-					value = readable.current();
-				} catch (cause) {
-					for (const member of members.values()) {
-						const record = scheduler.source(member.source);
-						record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
-						scheduler.capture(record);
-					}
-					if (settle) scheduler.run();
-					return;
-				}
-				for (const member of members.values()) try {
-					member.accept(value);
-				} catch (cause) {
-					const record = scheduler.source(member.source);
-					record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
-					scheduler.capture(record);
-				}
-				if (settle) scheduler.run();
-			};
-			let unsubscribe;
-			let detach;
-			try {
-				const owner = documentReadableOwner(readable);
-				if (owner) {
-					document(owner);
-					detach = attachProjection(owner, {
-						capture: () => receive(false),
-						settle: scheduler.settle,
-						flush: scheduler.flush,
-						dispose: () => {
-							for (const member of members.values()) {
-								const record = scheduler.source(member.source);
-								record.fault = new ProjectionError("source", "document readable disposed", [record.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
-								scheduler.capture(record);
-							}
-							scheduler.run();
-						}
-					});
-				}
-				unsubscribe = readable.subscribe(() => receive());
-				input.accept(readable.current());
-			} catch (error) {
-				try {
-					unsubscribe?.();
-					detach?.();
-				} finally {
-					scheduler.unregisterSource(input.source);
-				}
-				throw error;
-			}
-			scheduler.cleanups.add(unsubscribe);
-			if (detach) scheduler.cleanups.add(detach);
-			readables.set(readable, bindings);
-			scheduler.run();
-			return input.source;
-		},
-		assertCollection: (handle) => {
-			scheduler.source(handle);
-			if (!isCollectionSource(handle)) throw new Error("map requires a collection source.");
+			return seal(reset);
+		} finally {
+			active = false;
 		}
 	};
-};
-//#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 = {
-		owner: void 0,
-		...behavior,
-		publish: () => {
-			if (node.fault) behavior.clear();
-			else behavior.publish();
-		},
+	processor = {
+		kind: "processor",
 		order,
-		name: spec.name ? `${spec.name} (${order})` : `projection-${order}`,
-		sources: entries.map(([, source]) => source),
-		consumers: /* @__PURE__ */ new Set(),
-		disposed: false,
+		name: definition.name ? `${definition.name} (${order})` : `projection-${order}`,
+		dependencies: Object.freeze([...dependencies]),
+		outputs: Object.freeze(bound.map((entry) => entry.output)),
 		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;
-			}
-		}
-	};
-	node.owner = node;
-	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);
+		disposed: false,
+		evaluate: run,
+		publish: () => bound.forEach((entry) => entry.state.publish()),
+		clear: () => {
+			bound.forEach((entry) => entry.state.clear());
+			cause = void 0;
+		},
+		release: () => {
+			instance?.release?.();
+			instance = void 0;
+			bound.forEach((entry) => {
+				entry.output.consumers.clear();
+				entry.state.release();
+			});
+			cause = void 0;
 		}
 	};
+	try {
+		scheduler.initialize(() => {
+			const invalid = dependencies.find((output) => output.owner.fault || output.owner.disposed);
+			if (invalid) throw invalid.owner.fault ?? new ProjectionDisposedError();
+			if (processor.evaluate(true, void 0).length) processor.publish();
+			processor.clear();
+		});
+	} catch (error) {
+		processor.release();
+		throw error;
+	}
+	scheduler.addProcessor(processor);
+	return processor;
 };
 //#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) {
-				profile.materialized.rebuilt();
-				instance = void 0;
-				const built = spec.build(sources);
-				assertSynchronous(built);
-				instance = built;
-				candidate = built.value;
-			} else {
-				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;
+//#region core/src/projection/projection-readable.ts
+let activeTracker;
+const trackKey = (key) => {
+	activeTracker?.keys.add(key);
+};
+const trackStructure = () => {
+	if (activeTracker) activeTracker.structure = true;
+};
+const trackAll = () => {
+	if (activeTracker) activeTracker.all = true;
+};
+const isMapLike = (value) => value instanceof Map || value !== null && typeof value === "object" && typeof value.get === "function" && typeof value.keys === "function" && typeof value.entries === "function";
+const trackedMap = (source) => {
+	const view = {
+		get: (key) => {
+			trackKey(key);
+			return source.get(key);
 		},
-		context: (active) => {
-			assertScope(active);
-			return Object.freeze({
-				kind: "value",
-				value: next,
-				revision: revision + (changed ? 1 : 0),
-				reset,
-				cause
-			});
+		has: (key) => {
+			trackKey(key);
+			return source.has(key);
 		},
-		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			if (changed && initialized) revision++;
-			value = next;
-			initialized = true;
+		get size() {
+			trackStructure();
+			return source.size;
 		},
-		emit: (call) => {
-			profile.materialized.notification();
-			Array.from(listeners).forEach((listener) => call(listener));
+		keys: () => {
+			trackStructure();
+			return source.keys();
 		},
-		clear: () => {
-			next = value;
-			changed = false;
-			reset = false;
-			cause = void 0;
+		values: () => {
+			trackAll();
+			return source.values();
 		},
-		release: () => {
-			listeners.clear();
-			instance = void 0;
-			value = next = void 0;
-		}
-	});
-	const handle = Object.freeze({
-		kind: "value",
-		current: () => {
-			owner.check();
-			return value;
+		entries: () => {
+			trackAll();
+			return source.entries();
 		},
-		revision: () => {
-			owner.check();
-			return revision;
+		forEach: (callback, thisArg) => {
+			trackAll();
+			source.forEach((value, key) => callback.call(thisArg, value, key, view));
 		},
-		subscribe: (listener) => {
-			owner.check();
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
+		[Symbol.iterator]: () => {
+			trackAll();
+			return source[Symbol.iterator]();
 		}
-	});
-	owner.install(handle);
-	return handle;
-};
-//#endregion
-//#region core/src/projection/collection-state.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;
-	}
+	};
+	return Object.freeze(view);
 };
-const treeHas = (node, key) => {
-	let current = node;
-	while (current) {
-		if (key === current.key) return true;
-		current = key < current.key ? current.left : current.right;
-	}
+const selectionAffects = (selection, change) => {
+	if (!change || change.kind === "reset") return true;
+	if (selection.all && (change.added.length || change.removed.length || change.updated.length || change.order)) return true;
+	if (selection.structure && (change.added.length || change.removed.length || change.order)) return true;
+	for (const key of selection.keys) if (change.added.some((entry) => entry.key === key) || change.removed.some((entry) => entry.key === key) || change.updated.some((entry) => entry.key === key)) return true;
 	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));
-};
-/**
-* The one keyed publication kernel used by ordinary collection nodes and
-* processor-group output leaves. It owns staged intent, exact transitions and
-* the persistent published snapshot; callers only provide the processor
-* callback and the equality policy.
-*/
-const createCollectionState = () => {
-	const values = /* @__PURE__ */ new Map();
-	let ids = Object.freeze([]);
-	let staged = /* @__PURE__ */ new Map();
-	let nextIds = ids;
-	let change;
+const createDirectReadable = (source) => Object.freeze({
+	current: source.current,
+	revision: source.revision,
+	subscribe: (listener) => source.subscribe(() => listener())
+});
+/** Consumer-side selector tracking; it never mutates processor dependencies. */
+const createSelectorReadable = (source, selector, equality = Object.is) => {
 	let initialized = false;
-	let reset = false;
-	let revision = 0;
-	let publishedRoot;
-	let changedKeys = /* @__PURE__ */ new Set();
-	let orderChanged = false;
-	let explicitOrder;
-	let cleared = false;
+	let value;
+	let selectedRevision = 0;
+	let sourceRevision = -1;
+	let selection = Object.freeze({
+		keys: /* @__PURE__ */ new Set(),
+		all: true,
+		structure: false
+	});
+	let previousCollection;
+	let unsubscribeSource;
 	const listeners = /* @__PURE__ */ new Set();
-	const hasNext = (key) => staged.has(key) ? staged.get(key).present : !cleared && values.has(key);
-	const getNext = (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(hasNext);
-		for (const [key, entry] of staged) if (entry.present && (cleared || !values.has(key))) result.push(key);
-		return result;
+	const updateCollectionSnapshot = (current) => {
+		const candidate = current ?? source.current();
+		previousCollection = isMapLike(candidate) ? candidate : void 0;
 	};
-	const begin = (active, nextReset) => {
-		staged = /* @__PURE__ */ new Map();
-		nextIds = ids;
-		change = void 0;
-		changedKeys = /* @__PURE__ */ new Set();
-		explicitOrder = void 0;
-		orderChanged = false;
-		cleared = nextReset;
-		const read = (next) => ({
-			get: (key) => {
-				assertScope(active);
-				return next ? getNext(key) : values.get(key);
-			},
-			has: (key) => {
-				assertScope(active);
-				return next ? hasNext(key) : values.has(key);
-			},
-			ids: () => {
-				assertScope(active);
-				return next ? Object.freeze(explicitOrder ? [...explicitOrder] : [...deriveIds()]) : ids;
-			}
-		});
-		return {
-			previous: read(false),
-			next: read(true),
-			output: {
-				set: (key, value) => {
-					assertScope(active);
-					if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-					staged.set(key, {
-						present: true,
-						value
-					});
-				},
-				remove: (key) => {
-					assertScope(active);
-					staged.set(key, { present: false });
-				},
-				order: (order) => {
-					assertScope(active);
-					explicitOrder = Object.freeze([...order]);
-				}
-			}
+	const evaluate = () => {
+		const tracker = {
+			keys: /* @__PURE__ */ new Set(),
+			all: false,
+			structure: false
 		};
-	};
-	const seal = (nextReset, isEqual) => {
-		if (cleared) {
-			for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
+		const previousTracker = activeTracker;
+		activeTracker = tracker;
+		let current;
+		let next;
+		try {
+			current = source.current();
+			next = selector(isMapLike(current) ? trackedMap(current) : current);
+		} finally {
+			activeTracker = previousTracker;
 		}
-		profile.projection("touchedKeys", staged.size);
-		const added = /* @__PURE__ */ new Set();
-		const removed = /* @__PURE__ */ new Set();
-		const updated = /* @__PURE__ */ new Set();
-		for (const [key, entry] of staged) {
-			const existed = values.has(key);
-			if (entry.present) {
-				if (!existed) added.add(key);
-				else if (!isEqual(values.get(key), entry.value)) updated.add(key);
-				else if (!nextReset) staged.delete(key);
-			} else if (existed) removed.add(key);
-			else staged.delete(key);
+		const nextSelection = Object.freeze({
+			keys: new Set(tracker.keys),
+			all: tracker.all || isMapLike(current) && tracker.keys.size === 0 && !tracker.structure,
+			structure: tracker.structure
+		});
+		const changed = !initialized || !equality(value, next);
+		if (changed) {
+			if (initialized) selectedRevision++;
+			value = next;
 		}
-		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, index) => key === order[index]) ? ids : Object.freeze([...order]);
-		} else nextIds = ids;
-		orderChanged = nextIds !== ids;
-		for (const key of added) changedKeys.add(key);
-		for (const key of removed) changedKeys.add(key);
-		for (const key of updated) changedKeys.add(key);
-		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 || isEqual(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)
-			});
+		selection = nextSelection;
+		initialized = true;
+		sourceRevision = source.revision();
+		updateCollectionSnapshot(current);
+		return changed;
+	};
+	const ensureCurrent = () => {
+		const revision = source.revision();
+		if (!initialized || !unsubscribeSource && sourceRevision !== revision) evaluate();
+		return value;
+	};
+	const onProjectionChange = (incoming) => {
+		let change = incoming;
+		if (!change && previousCollection) {
+			const current = source.current();
+			if (isMapLike(current)) {
+				change = collectionChangeBetween(previousCollection, current);
+				previousCollection = current;
+				if (!change) {
+					sourceRevision = source.revision();
+					return;
+				}
+			} else previousCollection = void 0;
 		}
-		if (nextReset) 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, index) => after[index] !== 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])
-				}) } : {}
-			});
+		if (!selectionAffects(selection, change)) {
+			sourceRevision = source.revision();
+			updateCollectionSnapshot();
+			return;
 		}
-		reset = nextReset;
-		return change !== void 0;
+		if (evaluate()) Array.from(listeners).forEach((listener) => listener());
 	};
-	const context = (active, cause) => Object.freeze({
-		kind: "collection",
-		read: {
-			get: (key) => {
-				assertScope(active);
-				return getNext(key);
-			},
-			has: (key) => {
-				assertScope(active);
-				return hasNext(key);
-			},
-			ids: () => {
-				assertScope(active);
-				return nextIds;
-			}
+	const installSource = () => {
+		if (!unsubscribeSource) unsubscribeSource = source.subscribe(onProjectionChange);
+	};
+	return Object.freeze({
+		current: ensureCurrent,
+		revision: () => {
+			ensureCurrent();
+			return selectedRevision;
 		},
-		change,
-		revision: revision + (change ? 1 : 0),
-		cause
+		subscribe: (listener) => {
+			ensureCurrent();
+			listeners.add(listener);
+			installSource();
+			return () => {
+				listeners.delete(listener);
+				if (!listeners.size && unsubscribeSource) {
+					unsubscribeSource();
+					unsubscribeSource = void 0;
+				}
+			};
+		}
 	});
-	const current = (check) => {
-		const root = publishedRoot;
-		const publishedIds = ids;
-		return Object.freeze({
-			get: (key) => {
-				check();
-				return treeGet(root, key);
-			},
-			has: (key) => {
-				check();
-				return treeHas(root, key);
-			},
-			ids: () => {
-				check();
-				return publishedIds;
-			}
-		});
+};
+//#endregion
+//#region core/src/projection/source.ts
+const sourceError = (source, cause) => new ProjectionError("source", source.name, [source.outputs[0].revision()], cause);
+const createValueBoundary = (scheduler, name, initial, equality) => {
+	const state = createValueOutput();
+	let boundary;
+	let latest = initial;
+	let pendingReset = false;
+	let pendingCause;
+	let contextCause;
+	let recovering = false;
+	let cleanup;
+	const check = () => {
+		if (!scheduler.active || boundary.disposed) throw new ProjectionDisposedError();
+		if (boundary.fault) throw boundary.fault;
 	};
-	return {
-		begin,
-		seal,
-		context,
-		current,
-		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			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 && initialized) revision++;
-			ids = nextIds;
-			initialized = true;
+	const output = {
+		kind: "value",
+		get owner() {
+			return boundary;
 		},
-		emit: (call) => {
-			const resetEvent = Object.freeze({ kind: "reset" });
-			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
+		consumers: /* @__PURE__ */ new Set(),
+		context: (active) => state.context(active, contextCause),
+		current: () => state.current(check),
+		revision: state.revision,
+		reset: state.reset,
+		subscribe: (listener) => {
+			check();
+			const wrapped = () => listener();
+			state.subscribe(wrapped);
+			return () => state.unsubscribe(wrapped);
+		},
+		emit: state.emit,
+		clear: state.clear,
+		release: state.release
+	};
+	boundary = {
+		kind: "source",
+		name,
+		outputs: Object.freeze([output]),
+		fault: void 0,
+		disposed: false,
+		pendingCause: () => pendingCause,
+		recovering: () => recovering,
+		prepare: (cause) => {
+			contextCause = cause;
+			let active = true;
+			try {
+				state.begin(() => active, pendingReset).output.set(latest);
+				const changed = state.seal(pendingReset, equality);
+				recovering = false;
+				return {
+					changed,
+					force: pendingReset
+				};
+			} finally {
+				active = false;
+			}
 		},
+		publish: state.publish,
 		clear: () => {
-			staged.clear();
-			nextIds = ids;
-			change = void 0;
-			reset = false;
-			changedKeys.clear();
-			explicitOrder = void 0;
-			orderChanged = false;
-			cleared = false;
+			state.clear();
+			pendingReset = false;
+			pendingCause = void 0;
+			contextCause = void 0;
+			recovering = false;
 		},
 		release: () => {
-			values.clear();
-			staged.clear();
-			publishedRoot = void 0;
-			listeners.clear();
-			ids = nextIds = Object.freeze([]);
-			change = void 0;
-			initialized = false;
-			revision = 0;
-		},
-		subscribe: (listener) => {
-			listeners.add(listener);
+			cleanup?.();
+			cleanup = void 0;
+			state.release();
+			output.consumers.clear();
+		}
+	};
+	scheduler.initialize(() => {
+		let active = true;
+		try {
+			state.begin(() => active, true).output.set(initial);
+			state.seal(true, equality);
+			state.publish();
+			state.clear();
+		} finally {
+			active = false;
+		}
+	});
+	scheduler.addSource(boundary);
+	const mark = (metadata = {}) => {
+		scheduler.assertIdle();
+		pendingReset ||= metadata.reset ?? false;
+		if (metadata.cause !== void 0) pendingCause ??= metadata.cause;
+		if (boundary.fault) recovering = true;
+		scheduler.capture(boundary);
+	};
+	const fail = (cause) => {
+		boundary.fault = sourceError(boundary, cause);
+		recovering = false;
+		scheduler.capture(boundary);
+	};
+	return {
+		producer: boundary,
+		output,
+		setLatest: (value) => {
+			latest = value;
 		},
-		unsubscribe: (listener) => {
-			listeners.delete(listener);
+		mark,
+		fail,
+		detach: (next) => {
+			cleanup = next;
 		}
 	};
 };
-//#endregion
-//#region core/src/projection/collection.ts
-const createCollection = (scheduler, spec) => {
-	const state = createCollectionState();
-	let instance;
-	let cause;
-	const owner = createNode(scheduler, spec, {
-		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;
-			const input = state.begin(active, build);
-			if (build || !instance) {
-				profile.materialized.rebuilt();
-				instance = void 0;
-				const built = spec.build({
-					sources,
-					...input
-				});
-				assertSynchronous(built);
-				instance = built;
-			} else {
-				profile.materialized.updated();
-				const result = instance.update({
-					sources,
-					...input
-				});
-				assertSynchronous(result);
-				if (result?.kind === "rebuild") {
-					const rebuildInput = state.begin(active, true);
-					instance = void 0;
-					const built = spec.build({
-						sources,
-						...rebuildInput
-					});
-					assertSynchronous(built);
-					instance = built;
-					build = true;
-				}
-			}
-			return state.seal(build, spec.isEqual ?? Object.is);
+const createCollectionBoundary = (scheduler, name, readLatest, equality) => {
+	const state = createCollectionOutput();
+	let boundary;
+	let pendingReset = false;
+	let pendingCause;
+	let contextCause;
+	let recovering = false;
+	let fullScan = false;
+	let orderMayChange = false;
+	const candidates = /* @__PURE__ */ new Set();
+	let cleanup;
+	const check = () => {
+		if (!scheduler.active || boundary.disposed) throw new ProjectionDisposedError();
+		if (boundary.fault) throw boundary.fault;
+	};
+	const output = {
+		kind: "collection",
+		get owner() {
+			return boundary;
 		},
-		context: (active) => state.context(active, cause),
+		consumers: /* @__PURE__ */ new Set(),
+		context: (active) => state.context(active, contextCause),
+		current: () => state.current(check),
 		revision: state.revision,
 		reset: state.reset,
-		publish: state.publish,
+		subscribe: (listener) => {
+			check();
+			const wrapped = (change) => listener(change);
+			state.subscribe(wrapped);
+			return () => state.unsubscribe(wrapped);
+		},
 		emit: state.emit,
 		clear: state.clear,
+		release: state.release
+	};
+	boundary = {
+		kind: "source",
+		name,
+		outputs: Object.freeze([output]),
+		fault: void 0,
+		disposed: false,
+		pendingCause: () => pendingCause,
+		recovering: () => recovering,
+		prepare: (cause) => {
+			contextCause = cause;
+			let active = true;
+			try {
+				const changed = stageCollectionRead(state, readLatest(() => active), () => active, {
+					reset: pendingReset,
+					...fullScan ? {} : { candidates },
+					orderMayChange,
+					isEqual: equality
+				});
+				recovering = false;
+				return {
+					changed,
+					force: pendingReset
+				};
+			} finally {
+				active = false;
+			}
+		},
+		publish: state.publish,
+		clear: () => {
+			state.clear();
+			pendingReset = false;
+			pendingCause = void 0;
+			contextCause = void 0;
+			recovering = false;
+			fullScan = false;
+			orderMayChange = false;
+			candidates.clear();
+		},
 		release: () => {
+			cleanup?.();
+			cleanup = void 0;
 			state.release();
-			instance = void 0;
+			output.consumers.clear();
+		}
+	};
+	scheduler.initialize(() => {
+		let active = true;
+		try {
+			stageCollectionRead(state, readLatest(() => active), () => active, {
+				reset: true,
+				isEqual: equality
+			});
+			state.publish();
+			state.clear();
+		} finally {
+			active = false;
 		}
 	});
-	const handle = {
-		kind: "collection",
-		current: () => {
-			owner.check();
-			return state.current(owner.check);
-		},
-		revision: () => {
-			owner.check();
-			return state.revision();
-		},
-		subscribe: (listener) => {
-			owner.check();
-			state.subscribe(listener);
-			return () => state.unsubscribe(listener);
+	scheduler.addSource(boundary);
+	const mark = (metadata = {}) => {
+		scheduler.assertIdle();
+		pendingReset ||= metadata.reset ?? false;
+		if (metadata.cause !== void 0) pendingCause ??= metadata.cause;
+		fullScan ||= metadata.fullScan ?? false;
+		orderMayChange ||= metadata.orderMayChange ?? false;
+		if (metadata.candidates) for (const key of metadata.candidates) candidates.add(key);
+		if (boundary.fault) recovering = true;
+		scheduler.capture(boundary);
+	};
+	const fail = (cause) => {
+		boundary.fault = sourceError(boundary, cause);
+		recovering = false;
+		scheduler.capture(boundary);
+	};
+	return {
+		producer: boundary,
+		output,
+		mark,
+		fail,
+		detach: (next) => {
+			cleanup = next;
 		}
 	};
-	owner.install(handle);
-	return Object.freeze(handle);
 };
-//#endregion
-//#region core/src/projection/group.ts
-/**
-* Materializes one processor callback with several keyed output leaves. The
-* scheduler sees one node and the output leaves remain ordinary source records
-* for dependency, revision and listener matching.
-*/
-const createCollectionGroup = (scheduler, spec) => {
-	scheduler.assertIdle();
-	const sources = Object.entries(spec.sources).map(([key, handle]) => [key, scheduler.source(handle)]);
-	const states = spec.outputs.map(() => createCollectionState());
-	let instance;
-	let cause;
-	let changedOutputs = Object.freeze([]);
-	let node;
-	const order = scheduler.order();
-	const outputs = states.map((state, index) => {
-		const output = {
-			owner: void 0,
-			consumers: /* @__PURE__ */ new Set(),
-			context: (active) => state.context(active, cause),
-			revision: state.revision,
-			reset: state.reset,
-			fault: void 0,
-			disposed: false,
-			clear: state.clear,
-			emit: state.emit
+const createSourceRegistry = (scheduler) => {
+	const documents = /* @__PURE__ */ new Map();
+	const readables = /* @__PURE__ */ new Map();
+	const externalValues = /* @__PURE__ */ new WeakMap();
+	const externalCollections = /* @__PURE__ */ new WeakMap();
+	const documentConnection = (runtime) => {
+		const state = accessOf(runtime);
+		const cached = documents.get(state);
+		if (cached) return cached;
+		if (state.disposed) throw new Error("Document has been disposed.");
+		const bindings = /* @__PURE__ */ new Set();
+		const guard = (locked) => {
+			state.projectionLocks = (state.projectionLocks ?? 0) + (locked ? 1 : -1);
+		};
+		scheduler.guards.add(guard);
+		let closed = false;
+		let detach = () => void 0;
+		const connection = {
+			add(binding) {
+				if (closed) throw new Error("Document projection connection is closed.");
+				bindings.add(binding);
+				let active = true;
+				return () => {
+					if (!active) return;
+					active = false;
+					bindings.delete(binding);
+					if (!bindings.size) connection.close();
+				};
+			},
+			close() {
+				if (closed) return;
+				closed = true;
+				detach();
+				bindings.clear();
+				scheduler.guards.delete(guard);
+				documents.delete(state);
+			}
 		};
-		Object.defineProperty(output, "fault", {
-			configurable: false,
-			enumerable: true,
-			get: () => node.fault,
-			set: (value) => {
-				node.fault = value;
+		detach = attachProjection(runtime, {
+			capture: (commit) => {
+				for (const binding of bindings) if (binding.matches(commit)) binding.capture(commit);
+			},
+			settle: scheduler.settle,
+			flush: scheduler.flush,
+			dispose: () => {
+				for (const binding of bindings) binding.dispose();
+				scheduler.run();
 			}
 		});
-		return output;
-	});
-	const check = () => {
-		if (node.disposed || !scheduler.active) throw new ProjectionDisposedError();
-		if (node.fault) throw node.fault;
+		documents.set(state, connection);
+		return connection;
 	};
-	const evaluate = (inputSources, build, active) => {
-		cause = Object.values(inputSources).find((value) => value && typeof value === "object" && "cause" in value && value.cause !== void 0)?.cause ?? scheduler.batchContext()?.cause;
-		const makeInput = (reset) => {
-			const evaluations = states.map((state) => state.begin(active, reset));
-			return {
-				sources: inputSources,
-				previous: evaluations.map((evaluation) => evaluation.previous),
-				next: evaluations.map((evaluation) => evaluation.next),
-				outputs: evaluations.map((evaluation) => evaluation.output)
-			};
+	const valueInput = (definition) => {
+		if (definition.source.kind !== "value-input") throw new Error("Invalid value input source.");
+		const source = definition.source;
+		const boundary = createValueBoundary(scheduler, "projection input", source.initial, source.equality);
+		return {
+			...boundary,
+			write: {
+				kind: "value",
+				set(value) {
+					scheduler.assertIdle();
+					boundary.setLatest(value);
+					boundary.mark();
+					scheduler.run();
+				}
+			}
 		};
-		let input = makeInput(build);
-		if (build || !instance) {
-			profile.materialized.rebuilt();
-			instance = void 0;
-			const built = spec.build(input);
-			assertSynchronous(built);
-			instance = built;
-		} else {
-			profile.materialized.updated();
-			const result = instance.update(input);
-			assertSynchronous(result);
-			if (result?.kind === "rebuild") {
-				input = makeInput(true);
-				instance = void 0;
-				const built = spec.build(input);
-				assertSynchronous(built);
-				instance = built;
-				build = true;
+	};
+	const collectionInput = (definition) => {
+		if (definition.source.kind !== "collection-input") throw new Error("Invalid collection input source.");
+		const values = new Map(definition.source.initial);
+		const boundary = createCollectionBoundary(scheduler, "projection collection input", () => mapRead(values), definition.output.equality);
+		return {
+			...boundary,
+			write: {
+				kind: "collection",
+				update(run) {
+					scheduler.assertIdle();
+					const staged = /* @__PURE__ */ new Map();
+					const operations = [];
+					let active = true;
+					const draft = Object.freeze({
+						get: (key) => {
+							assertScope(() => active);
+							const entry = staged.get(key);
+							return entry ? entry.present ? entry.value : void 0 : values.get(key);
+						},
+						has: (key) => {
+							assertScope(() => active);
+							const entry = staged.get(key);
+							return entry ? entry.present : values.has(key);
+						},
+						set: (key, value) => {
+							assertScope(() => active);
+							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+							staged.set(key, {
+								present: true,
+								value
+							});
+							operations.push({
+								kind: "set",
+								key,
+								value
+							});
+						},
+						remove: (key) => {
+							assertScope(() => active);
+							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+							staged.set(key, { present: false });
+							operations.push({
+								kind: "remove",
+								key
+							});
+						}
+					});
+					try {
+						assertSynchronous(run(draft));
+					} finally {
+						active = false;
+					}
+					const candidates = /* @__PURE__ */ new Set();
+					let structural = false;
+					let changed = false;
+					for (const operation of operations) {
+						const present = values.has(operation.key);
+						if (operation.kind === "set") {
+							if (present && Object.is(values.get(operation.key), operation.value)) continue;
+							structural ||= !present;
+							values.set(operation.key, operation.value);
+						} else {
+							if (!present) continue;
+							structural = true;
+							values.delete(operation.key);
+						}
+						candidates.add(operation.key);
+						changed = true;
+					}
+					if (!changed) return;
+					boundary.mark({
+						candidates,
+						orderMayChange: structural
+					});
+					scheduler.run();
+				}
 			}
-		}
-		changedOutputs = Object.freeze(states.flatMap((state, index) => state.seal(build, spec.outputs[index].isEqual ?? Object.is) ? [outputs[index]] : []));
-		return changedOutputs.length > 0;
+		};
 	};
-	node = {
-		owner: void 0,
-		order,
-		name: `processor-group (${order})`,
-		sources: sources.map(([, source]) => source),
-		consumers: /* @__PURE__ */ new Set(),
-		outputs,
-		disposed: false,
-		fault: void 0,
-		context: (active) => {
-			assertScope(active);
-			return Object.freeze({ kind: "group" });
-		},
-		revision: () => Math.max(0, ...states.map((state) => state.revision())),
-		reset: () => states.some((state) => state.reset()),
-		evaluate: (build) => {
-			let active = true;
-			try {
-				const scopeActive = () => active;
-				return evaluate(Object.fromEntries(sources.map(([key, source]) => [key, source.context(scopeActive)])), build, scopeActive);
-			} finally {
-				active = false;
+	const documentValue = (definition) => {
+		if (definition.source.kind !== "document-value") throw new Error("Invalid document value source.");
+		const { document, selector } = definition.source;
+		const state = accessOf(document);
+		const address = selector?.address ?? Object.freeze([]);
+		const schemaNode = () => nodeAt(state.schema, address, state.document);
+		const read = () => {
+			if (state.disposed) throw new Error("Document has been disposed.");
+			const node = schemaNode();
+			if (!node) return void 0;
+			return copyValue(node, selector ? read$1(state.document, address, state.schema) : state.document);
+		};
+		const boundary = createValueBoundary(scheduler, "document source", read(), (left, right) => {
+			const node = schemaNode();
+			return node ? equalValue(node, left, right) : Object.is(left, right);
+		});
+		const remove = documentConnection(document).add({
+			matches: (commit) => !selector || affectsTarget(commit.impact, selector),
+			capture: (commit) => {
+				try {
+					boundary.setLatest(read());
+					boundary.mark({ reset: commit.impact.kind === "reset" });
+				} catch (cause) {
+					boundary.fail(cause);
+				}
+			},
+			dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
+		});
+		boundary.detach(remove);
+		return boundary;
+	};
+	const documentCollection = (definition) => {
+		if (definition.source.kind !== "document-collection") throw new Error("Invalid document collection source.");
+		const { document, selector } = definition.source;
+		const state = accessOf(document);
+		const read = (active) => {
+			if (state.disposed) throw new Error("Document has been disposed.");
+			const raw = collectionAccess({
+				state,
+				active
+			}, selector.address);
+			const snapshots = /* @__PURE__ */ new Map();
+			return Object.freeze({
+				get: (key) => {
+					assertScope(active);
+					if (!snapshots.has(key)) snapshots.set(key, snapshot(raw.get(key)));
+					return snapshots.get(key);
+				},
+				has: (key) => {
+					assertScope(active);
+					return raw.has(key);
+				},
+				ids: () => {
+					assertScope(active);
+					return raw.ids();
+				}
+			});
+		};
+		const collectionNode = () => nodeAt(state.schema, selector.address, state.document);
+		const boundary = createCollectionBoundary(scheduler, "document collection source", read, (left, right) => {
+			const node = collectionNode();
+			const entry = node && collectionEntryNode(node);
+			return entry ? equalValue(entry, left, right) : Object.is(left, right);
+		});
+		const remove = documentConnection(document).add({
+			matches: (commit) => affectsTarget(commit.impact, selector),
+			capture: (commit) => {
+				const impact = collectionImpact(commit.impact, selector);
+				if (impact.kind === "reset") {
+					boundary.mark({ reset: true });
+					return;
+				}
+				const candidates = new Set([
+					...impact.added,
+					...impact.updated,
+					...impact.removed
+				]);
+				boundary.mark({
+					candidates,
+					orderMayChange: Boolean(impact.added.size || impact.removed.size || impact.orderChanged)
+				});
+			},
+			dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
+		});
+		boundary.detach(remove);
+		return boundary;
+	};
+	const readable = (definition) => {
+		if (definition.source.kind !== "readable") throw new Error("Invalid Readable source.");
+		const { readable, equality } = definition.source;
+		let initial = readable.current();
+		const boundary = createValueBoundary(scheduler, "external readable", initial, equality);
+		const member = {
+			boundary,
+			receive(value, metadata) {
+				initial = value;
+				boundary.setLatest(value);
+				boundary.mark(metadata);
 			}
-		},
-		changedOutputs: () => changedOutputs,
-		publish: () => {
-			if (node.fault) states.forEach((state) => state.clear());
-			else states.forEach((state) => state.publish());
-		},
-		emit: () => void 0,
-		clear: () => {
-			states.forEach((state) => state.clear());
-			changedOutputs = Object.freeze([]);
-			cause = void 0;
-		},
-		release: () => {
-			states.forEach((state) => state.release());
-			outputs.forEach((output) => {
-				output.disposed = true;
-				output.consumers.clear();
+		};
+		let connection = readables.get(readable);
+		if (!connection) {
+			const members = /* @__PURE__ */ new Set();
+			let closed = false;
+			let unsubscribe;
+			let detachDocument;
+			const receive = (settle) => {
+				if (closed || !scheduler.active) return;
+				try {
+					const value = readable.current();
+					members.forEach((next) => next.receive(value));
+				} catch (cause) {
+					members.forEach((next) => next.boundary.fail(cause));
+				}
+				if (settle) scheduler.run();
+			};
+			const created = {
+				members,
+				close() {
+					if (closed) return;
+					closed = true;
+					unsubscribe?.();
+					detachDocument?.();
+					readables.delete(readable);
+				}
+			};
+			const owner = documentReadableOwner(readable);
+			if (owner) detachDocument = documentConnection(owner).add({
+				matches: () => true,
+				capture: () => receive(false),
+				dispose: () => {
+					members.forEach((next) => next.boundary.fail(/* @__PURE__ */ new Error("Document has been disposed.")));
+				}
 			});
-			instance = void 0;
+			unsubscribe = readable.subscribe(() => receive(true));
+			connection = created;
+			readables.set(readable, connection);
 		}
+		connection.members.add(member);
+		boundary.detach(() => {
+			connection.members.delete(member);
+			if (!connection.members.size) connection.close();
+		});
+		return boundary;
 	};
-	node.owner = node;
-	outputs.forEach((output) => {
-		output.owner = node;
-	});
-	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 handles = outputs.map((output, index) => {
-		const handle = {
-			kind: "collection",
-			current: () => {
-				check();
-				return states[index].current(check);
-			},
-			revision: () => {
-				check();
-				return states[index].revision();
-			},
-			subscribe: (listener) => {
-				check();
-				states[index].subscribe(listener);
-				return () => states[index].unsubscribe(listener);
+	const externalValue = (definition) => {
+		if (definition.source.kind !== "external-value") throw new Error("Invalid external value source.");
+		const { source, equality } = definition.source;
+		const boundary = createValueBoundary(scheduler, "external source", source.current(), equality);
+		const member = {
+			boundary,
+			receive(value, metadata) {
+				boundary.setLatest(value);
+				boundary.mark(metadata);
 			}
 		};
-		scheduler.register(handle, output);
-		return Object.freeze(handle);
-	});
-	scheduler.addNode(node);
-	return Object.freeze(handles);
-};
-//#endregion
-//#region core/src/projection/graph.ts
-const createProjectionGraph = (options) => {
-	const scheduler = createScheduler(options.onError);
-	const sources = createSources(scheduler);
-	const value = (spec, options) => createValue(scheduler, spec, options);
-	const map = (source, mapper, options) => {
-		sources.assertCollection(source);
-		const calculate = (id, entry) => {
-			const value = mapper(id, entry);
-			assertSynchronous(value);
-			return value;
-		};
-		return createCollection(scheduler, {
-			sources: { source },
-			isEqual: options?.isEqual,
-			build: ({ sources, output }) => {
-				const read = sources.source.read;
-				const ids = read.ids();
-				profile.collectionView.idsScanned(ids.length);
-				for (const id of ids) {
-					profile.collectionView.mapped();
-					output.set(id, calculate(id, read.get(id)));
+		let connection = externalValues.get(source);
+		if (!connection) {
+			const members = /* @__PURE__ */ new Set();
+			let closed = false;
+			let unsubscribe;
+			const created = {
+				members,
+				close() {
+					if (closed) return;
+					closed = true;
+					unsubscribe?.();
+					externalValues.delete(source);
 				}
-				output.order(ids);
-				return { update: ({ sources, output }) => {
-					const input = sources.source;
-					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) {
-						profile.collectionView.mapped();
-						output.set(entry.key, calculate(entry.key, entry.after));
-					}
-					for (const entry of change.updated) {
-						profile.collectionView.mapped();
-						output.set(entry.key, calculate(entry.key, entry.after));
-					}
-					for (const entry of change.removed) output.remove(entry.key);
-					if (change.added.length || change.removed.length || change.order) {
-						const ids = read.ids();
-						profile.collectionView.idsScanned(ids.length);
-						output.order(ids);
+			};
+			try {
+				unsubscribe = source.subscribe((event) => {
+					try {
+						members.forEach((next) => next.receive(event.value, {
+							reset: event.reset,
+							cause: event.cause
+						}));
+					} catch (cause) {
+						members.forEach((next) => next.boundary.fail(cause));
 					}
-				} };
+					scheduler.run();
+				});
+			} catch (cause) {
+				created.close();
+				throw cause;
 			}
+			connection = created;
+			externalValues.set(source, connection);
+		}
+		connection.members.add(member);
+		boundary.detach(() => {
+			connection.members.delete(member);
+			if (!connection.members.size) connection.close();
 		});
+		return boundary;
 	};
-	const graph = {
-		document: sources.document,
-		fromSource: (source, options) => sources.fromSource(source, options),
-		fromCollectionSource: (source) => sources.fromCollectionSource(source),
-		input: sources.input,
-		collectionInput: sources.collectionInput,
-		fromReadable: sources.fromReadable,
-		value,
-		collection: (spec) => createCollection(scheduler, spec),
-		group: (spec) => createCollectionGroup(scheduler, spec),
-		map,
-		batch: scheduler.batch,
-		assertIdle: scheduler.assertIdle,
-		releaseNode: scheduler.releaseNode,
-		releaseInput: scheduler.unregisterSource,
-		dispose: () => {
+	const externalCollection = (definition) => {
+		if (definition.source.kind !== "external-collection") throw new Error("Invalid external collection source.");
+		const source = definition.source.source;
+		const boundary = createCollectionBoundary(scheduler, "external collection source", () => {
+			const current = source.current();
+			return Object.freeze({
+				get: (key) => current.get(key),
+				has: (key) => current.has(key),
+				ids: () => current.ids()
+			});
+		}, definition.output.equality);
+		let connection = externalCollections.get(source);
+		if (!connection) {
+			const members = /* @__PURE__ */ new Set();
+			let closed = false;
+			let unsubscribe;
+			const created = {
+				members,
+				close() {
+					if (closed) return;
+					closed = true;
+					unsubscribe?.();
+					externalCollections.delete(source);
+				}
+			};
 			try {
-				scheduler.dispose();
-			} finally {
-				if (!scheduler.active) sources.dispose();
+				unsubscribe = source.subscribe((event) => {
+					try {
+						const impact = event.impact;
+						if (impact?.kind === "reset") members.forEach((next) => next.mark({
+							reset: true,
+							cause: event.cause
+						}));
+						else if (impact?.kind === "incremental") {
+							const candidates = new Set([
+								...impact.added,
+								...impact.updated,
+								...impact.removed
+							]);
+							members.forEach((next) => next.mark({
+								candidates,
+								orderMayChange: Boolean(impact.added.size || impact.removed.size || impact.orderChanged),
+								cause: event.cause
+							}));
+						} else members.forEach((next) => next.mark({
+							fullScan: true,
+							orderMayChange: true,
+							cause: event.cause
+						}));
+					} catch (cause) {
+						members.forEach((next) => next.fail(cause));
+					}
+					scheduler.run();
+				});
+			} catch (cause) {
+				created.close();
+				throw cause;
 			}
+			connection = created;
+			externalCollections.set(source, connection);
 		}
+		connection.members.add(boundary);
+		boundary.detach(() => {
+			connection.members.delete(boundary);
+			if (!connection.members.size) connection.close();
+		});
+		return boundary;
 	};
-	return Object.freeze(graph);
-};
-//#endregion
-//#region core/src/projection/runtime.ts
-let activeTracker;
-const trackKey = (key) => {
-	activeTracker?.keys.add(key);
-};
-const trackStructure = () => {
-	if (!activeTracker) return;
-	activeTracker.structure = true;
-};
-const trackAll = () => {
-	if (!activeTracker) return;
-	activeTracker.all = true;
-};
-const mapView = (read) => {
-	const keys = read.ids();
-	const source = /* @__PURE__ */ new Map();
-	for (const key of keys) source.set(key, read.get(key));
-	const view = {
-		get: (key) => {
-			trackKey(key);
-			return source.get(key);
-		},
-		has: (key) => {
-			trackKey(key);
-			return source.has(key);
-		},
-		get size() {
-			trackStructure();
-			return source.size;
-		},
-		keys: () => {
-			trackStructure();
-			return source.keys();
-		},
-		values: () => {
-			trackAll();
-			return source.values();
-		},
-		entries: () => {
-			trackAll();
-			return source.entries();
-		},
-		forEach: (callback, thisArg) => {
-			trackAll();
-			source.forEach((value, key) => callback.call(thisArg, value, key, view));
-		},
-		[Symbol.iterator]: () => {
-			trackAll();
-			return source[Symbol.iterator]();
-		}
-	};
-	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);
+	return {
+		materialize(definition) {
+			switch (definition.source.kind) {
+				case "value-input": return valueInput(definition);
+				case "collection-input": return collectionInput(definition);
+				case "document-value": return documentValue(definition);
+				case "document-collection": return documentCollection(definition);
+				case "readable": return readable(definition);
+				case "external-value": return externalValue(definition);
+				case "external-collection": return externalCollection(definition);
+			}
 		},
-		[Symbol.iterator]: () => {
-			trackAll();
-			return entries();
+		dispose() {
+			documents.forEach((connection) => connection.close());
+			readables.forEach((connection) => connection.close());
+			documents.clear();
+			readables.clear();
 		}
 	};
-	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),
-	has: (key) => value.has(key),
-	ids: () => Object.freeze([...value.keys()])
-});
-const mapChange = (previous, current) => {
-	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.length && !removed.length && !updated.length && !orderChanged) return void 0;
-	return {
-		kind: "incremental",
-		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) => {
-	if (left.all !== right.all || left.structure !== right.structure || left.keys.size !== right.keys.size) return false;
-	for (const key of left.keys) if (!right.keys.has(key)) return false;
-	return true;
-};
-const selectionAffects = (selection, change) => {
-	if (!change || change.kind === "reset") return true;
-	if (selection.all && (change.added.length || change.removed.length || change.updated.length || change.order)) return true;
-	if (selection.structure && (change.added.length || change.removed.length || change.order)) return true;
-	for (const key of selection.keys) if (change.added.some((entry) => entry.key === key) || change.removed.some((entry) => entry.key === key) || change.updated.some((entry) => entry.key === key)) return true;
-	return false;
 };
-const currentValue = (event) => {
-	if (!event || typeof event !== "object") return event;
-	if ("kind" in event && event.kind === "value") return event.value;
-	if ("kind" in event && event.kind === "document") return snapshot(event.read);
-	if ("kind" in event && event.kind === "collection") return mapView(event.read);
-	return event;
-};
-const sourceOf = (instance) => instance;
+//#endregion
+//#region core/src/projection/runtime.ts
 const createProjectionRuntime = (options) => {
-	const runtime = createProjectionGraph({ onError: options?.onError ?? (() => void 0) });
+	const scheduler = createScheduler(options?.onError ?? (() => void 0));
+	const sources = createSourceRegistry(scheduler);
 	const materialized = /* @__PURE__ */ new WeakMap();
-	const groups = /* @__PURE__ */ new WeakMap();
-	let disposed = false;
+	const publicViews = /* @__PURE__ */ new WeakMap();
 	const scopes = /* @__PURE__ */ new Set();
-	let materialize;
-	const materializeGroup = (definition, requester) => {
-		const existing = groups.get(definition);
-		if (existing) return existing;
-		if (definition.projections.map((projection) => ownerOf(projection)).filter((owner) => owner !== void 0).some((owner) => owner !== requester)) throw new TypeError("Projection group belongs to another scope.");
-		const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency, requester))]));
-		const nodes = runtime.group({
-			sources,
-			outputs: definition.outputs,
-			build: definition.build
-		});
-		const group = Object.freeze({
-			definition,
-			nodes
-		});
-		groups.set(definition, group);
-		for (let index = 0; index < definition.projections.length; index++) materialized.set(definition.projections[index], {
-			kind: "projection",
-			node: nodes[index]
-		});
-		if (requester) requester.materialized.push(definition);
-		return group;
+	const assertAccess = (definition, requester) => {
+		scheduler.assertActive();
+		const owner = definition.owner;
+		if (owner === void 0) return;
+		if (owner !== requester) throw new TypeError("Projection belongs to another scope.");
+		if (!requester?.active) throw new ProjectionDisposedError();
 	};
-	materialize = (projection, requester) => {
-		const owner = ownerOf(projection);
-		if (owner) {
-			if (owner !== requester) throw new TypeError("Projection belongs to another scope.");
-			if (!requester.active) throw new ProjectionDisposedError();
-		}
-		const old = materialized.get(projection);
-		if (old) return old.node;
-		const definition = definitionOf(projection);
-		if (definition.kind === "incremental-group-output") return materializeGroup(definition.group, requester).nodes[definition.output];
-		let instance;
-		let write;
-		switch (definition.kind) {
-			case "input": {
-				const input = runtime.input(definition.initial, { isEqual: definition.isEqual });
-				write = {
-					kind: "value-input",
-					source: input.source,
-					set: 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 "collection-input": {
-				const source = runtime.collectionInput(definition.initial);
-				write = {
-					kind: "collection-input",
-					source: source.source,
-					update: source.update
-				};
-				instance = runtime.map(source.source, (_key, value) => value);
-				break;
-			}
-			case "readable": {
-				const source = runtime.fromReadable(definition.readable, { isEqual: definition.isEqual });
-				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({
-						sources: { source },
-						build: (values) => ({
-							value: values.source.value,
-							update: (next) => ({
-								kind: "changed",
-								value: next.source.value
-							})
-						})
-					});
-				}
-				break;
-			case "source-collection": {
-				const source = runtime.fromCollectionSource(definition.source);
-				instance = runtime.map(source, (_key, value) => value);
-				break;
-			}
-			case "document": {
-				const document = runtime.document(definition.document);
-				if (!definition.selector) {
-					instance = runtime.value({
-						sources: { document },
-						build: (values) => ({
-							value: snapshot(values.document.read),
-							update: (next) => ({
-								kind: "changed",
-								value: snapshot(next.document.read)
-							})
-						})
-					});
-					break;
-				}
-				const state = accessOf(definition.document);
-				try {
-					const collection = document.collection(definition.selector);
-					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({
-						sources: { selected },
-						build: () => ({
-							value: read$1(snapshot(state.document), address, state.schema),
-							update: () => ({
-								kind: "changed",
-								value: read$1(snapshot(state.document), address, state.schema)
-							})
-						})
-					});
-				}
-				break;
-			}
-			case "derive": {
-				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency, owner))]));
-				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": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency, owner))]));
-				instance = runtime.value({
-					sources,
-					build: definition.build
-				}, { isEqual: definition.isEqual });
-				break;
-			}
-			case "incremental-collection": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency, owner))]));
-				instance = runtime.collection({
-					sources,
-					build: definition.build,
-					isEqual: definition.isEqual,
-					name: definition.name
-				});
-				break;
-			}
+	const rememberScoped = (definition, requester) => {
+		if (requester && definition.owner === requester) requester.materialized.push(definition);
+	};
+	const materializeProducer = (definition, requester) => {
+		assertAccess(definition, requester);
+		const existing = materialized.get(definition);
+		if (existing) return existing;
+		let result;
+		if (definition.kind === "source") {
+			const source = sources.materialize(definition);
+			result = Object.freeze({
+				record: source.producer,
+				outputs: Object.freeze([source.output]),
+				...source.write ? { write: source.write } : {}
+			});
+		} else {
+			if (definition.owner === void 0 && definition.dependencies.some((dependency) => producerOf(dependency).owner !== void 0)) throw new TypeError("A root projection cannot depend on a scoped projection.");
+			const dependencies = definition.dependencies.map((dependency) => resolveOutput(dependency, requester));
+			const processor = createProcessor(scheduler, definition, Object.freeze(dependencies));
+			result = Object.freeze({
+				record: processor,
+				outputs: processor.outputs
+			});
 		}
-		const record = write ? {
-			node: instance,
-			...write
-		} : {
-			kind: "projection",
-			node: instance
-		};
-		materialized.set(projection, record);
-		if (owner) owner.materialized.push(projection);
-		return instance;
+		materialized.set(definition, result);
+		rememberScoped(definition, requester);
+		return result;
+	};
+	const resolveOutput = (projection, requester) => {
+		const ref = projectionRef(projection);
+		const output = materializeProducer(ref.producer, requester).outputs[ref.output];
+		if (!output) throw new TypeError("Projection output does not exist.");
+		return output;
+	};
+	const assertOutput = (output) => {
+		scheduler.assertActive();
+		if (output.owner.disposed) throw new ProjectionDisposedError();
+		if (output.owner.fault) throw output.owner.fault;
 	};
-	const get = (projection, requester) => {
-		const instance = materialize(projection, requester);
-		const current = instance.current();
-		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 = lazyMapView(current);
-			if (record) record.collection = {
+	const publicCurrent = (output) => {
+		assertOutput(output);
+		const current = output.current();
+		const revision = output.revision();
+		const cached = publicViews.get(output);
+		if (cached?.revision === revision) return cached.value;
+		if (output.kind === "collection") {
+			const value = collectionView(current);
+			publicViews.set(output, {
 				revision,
 				value
-			};
+			});
 			return value;
 		}
 		if (isMapLike(current)) {
-			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));
-			if (record) record.collection = {
+			const value = snapshotCollectionView(mapRead(current));
+			publicViews.set(output, {
 				revision,
 				value
-			};
+			});
 			return value;
 		}
+		publicViews.delete(output);
 		return current;
 	};
-	const makeReadable = (projection, selector, equality = Object.is, requester) => {
-		if (!selector) return Object.freeze({
-			current: () => get(projection, requester),
-			revision: () => materialize(projection, requester).revision(),
-			subscribe: (listener) => materialize(projection, requester).subscribe(listener)
-		});
-		let initialized = false;
-		let value;
-		let selectedRevision = 0;
-		let sourceRevision = -1;
-		let selection = Object.freeze({
-			keys: /* @__PURE__ */ new Set(),
-			all: true,
-			structure: false
-		});
-		let previousCollection;
-		let unsubscribeSource;
-		const listeners = /* @__PURE__ */ new Set();
-		const updateCollectionSnapshot = () => {
-			const current = get(projection, requester);
-			previousCollection = isMapLike(current) ? current : void 0;
-		};
-		const evaluate = () => {
-			const tracker = {
-				keys: /* @__PURE__ */ new Set(),
-				all: false,
-				structure: false
-			};
-			const previousTracker = activeTracker;
-			activeTracker = tracker;
-			let source;
-			let next;
-			try {
-				source = get(projection, requester);
-				next = selector(source);
-			} finally {
-				activeTracker = previousTracker;
-			}
-			const nextSelection = Object.freeze({
-				keys: new Set(tracker.keys),
-				all: tracker.all || isMapLike(source) && tracker.keys.size === 0,
-				structure: tracker.structure
-			});
-			const changed = !initialized || !equality(value, next);
-			if (changed) {
-				if (initialized) selectedRevision++;
-				value = next;
-			}
-			selection = nextSelection;
-			initialized = true;
-			sourceRevision = materialize(projection, requester).revision();
-			updateCollectionSnapshot();
-			return changed;
-		};
-		const ensureCurrent = () => {
-			const revision = materialize(projection, requester).revision();
-			if (!initialized || !unsubscribeSource && sourceRevision !== revision) evaluate();
-			return value;
-		};
-		const onProjectionChange = (incoming) => {
-			let change = incoming;
-			if (!change && previousCollection) {
-				const current = get(projection, requester);
-				if (isMapLike(current)) {
-					change = mapChange(previousCollection, current);
-					previousCollection = current;
-					if (!change) {
-						sourceRevision = materialize(projection, requester).revision();
-						return;
-					}
-				} else previousCollection = void 0;
-			}
-			if (!selectionAffects(selection, change)) {
-				sourceRevision = materialize(projection, requester).revision();
-				updateCollectionSnapshot();
-				return;
-			}
-			const previousSelection = selection;
-			const changed = evaluate();
-			if (unsubscribeSource && !sameSelection(previousSelection, selection)) {
-				unsubscribeSource();
-				unsubscribeSource = materialize(projection, requester).subscribe(onProjectionChange);
-			}
-			if (changed) Array.from(listeners).forEach((listener) => listener());
-		};
-		const installSource = () => {
-			if (!unsubscribeSource) unsubscribeSource = materialize(projection, requester).subscribe(onProjectionChange);
-		};
+	const get = (projection, requester) => publicCurrent(resolveOutput(projection, requester));
+	const readableSource = (projection, requester) => {
+		const output = resolveOutput(projection, requester);
 		return Object.freeze({
-			current: ensureCurrent,
+			kind: output.kind,
+			current: () => get(projection, requester),
 			revision: () => {
-				ensureCurrent();
-				return selectedRevision;
+				assertOutput(output);
+				return output.revision();
 			},
-			subscribe: (listener) => {
-				ensureCurrent();
-				listeners.add(listener);
-				installSource();
-				return () => {
-					listeners.delete(listener);
-					if (!listeners.size && unsubscribeSource) {
-						unsubscribeSource();
-						unsubscribeSource = void 0;
-					}
-				};
-			}
+			subscribe: output.subscribe
 		});
 	};
+	const makeReadable = (projection, selector, equality, requester) => {
+		const source = readableSource(projection, requester);
+		return selector ? createSelectorReadable(source, selector, equality) : createDirectReadable(source);
+	};
 	function readable(projection, selector, equality) {
 		return makeReadable(projection, selector, equality);
 	}
+	const inputWrite = (target, requester) => {
+		const ref = projectionRef(target);
+		if (ref.output !== 0 || ref.producer.kind !== "source") throw new TypeError("Projection is not an input.");
+		if (ref.producer.source.kind !== "value-input" && ref.producer.source.kind !== "collection-input") throw new TypeError("Projection is not an input.");
+		const write = materializeProducer(ref.producer, requester).write;
+		if (!write) throw new TypeError("Projection input is not writable.");
+		return write;
+	};
 	const setInput = (target, value, requester) => {
-		materialize(target, requester);
-		const record = materialized.get(target);
-		if (record?.kind !== "value-input") throw new TypeError("Projection is not a value input.");
-		record.set(value);
+		const write = inputWrite(target, requester);
+		if (write.kind !== "value") throw new TypeError("Projection is not a value input.");
+		write.set(value);
 	};
 	const updateInput = (target, run, requester) => {
-		materialize(target, requester);
-		const record = materialized.get(target);
-		if (record?.kind !== "collection-input") throw new TypeError("Projection is not a collection input.");
-		record.update(run);
+		const write = inputWrite(target, requester);
+		if (write.kind !== "collection") throw new TypeError("Projection is not a collection input.");
+		write.update(run);
+	};
+	function batch(optionsOrCallback, maybeCallback) {
+		return typeof optionsOrCallback === "function" ? scheduler.batch(optionsOrCallback) : scheduler.batch(optionsOrCallback, maybeCallback);
+	}
+	const disposeScope = (state) => {
+		if (!state.active) return;
+		scheduler.assertIdle();
+		state.active = false;
+		state.subscriptions.forEach((unsubscribe) => unsubscribe());
+		state.subscriptions.clear();
+		for (let index = state.materialized.length - 1; index >= 0; index--) {
+			const definition = state.materialized[index];
+			const current = materialized.get(definition);
+			if (!current) continue;
+			scheduler.releaseProducer(current.record);
+			materialized.delete(definition);
+		}
+		state.materialized.length = 0;
+		scopes.delete(state);
 	};
 	const createScope = () => {
-		runtime.assertIdle();
+		scheduler.assertIdle();
 		const state = {
 			active: true,
 			materialized: [],
@@ -3050,33 +2236,26 @@ const createProjectionRuntime = (options) => {
 		scopes.add(state);
 		const assertActive = () => {
 			if (!state.active) throw new ProjectionDisposedError();
+			scheduler.assertActive();
 		};
 		const own = (projection) => {
 			assertActive();
-			const definition = definitionOf(projection);
-			const dependencies = definition.kind === "derive" ? definition.dependencies : definition.kind === "incremental-value" || definition.kind === "incremental-collection" ? Object.values(definition.dependencies) : definition.kind === "incremental-group-output" ? Object.values(definition.group.dependencies) : [];
-			for (const dependency of dependencies) {
-				const dependencyOwner = ownerOf(dependency);
-				if (dependencyOwner && dependencyOwner !== state) throw new TypeError("A scope cannot depend on another scope.");
-			}
-			ownDefinition(projection, state);
-			return projection;
+			return ownProjection(projection, state);
 		};
-		const scopedInput = Object.assign((initial, equality) => own(input(initial, equality)), { collection: (initial) => own(input.collection(initial)) });
-		const scopedDerive = (dependencies, compute, equality) => own(derive(dependencies, compute, equality));
 		const ownOutputTree = (tree) => {
 			if (isProjection(tree)) return own(tree);
 			if (!tree || typeof tree !== "object") throw new TypeError("Incremental group output tree must be an object.");
 			for (const value of Object.values(tree)) ownOutputTree(value);
 			return tree;
 		};
+		const scopedInput = Object.assign((initial, equality) => own(input(initial, equality)), { collection: (initial) => own(input.collection(initial)) });
+		const scopedDerive = (dependencies, compute, equality) => own(derive(dependencies, compute, equality));
 		const scopedIncremental = Object.assign((dependencies, processor) => own(incremental(dependencies, processor)), {
 			collection: (dependencies, processor) => own(incremental.collection(dependencies, processor)),
 			group: (dependencies, defineOutputs, processor) => ownOutputTree(incremental.group(dependencies, defineOutputs, processor))
 		});
 		function scopeReadable(projection, selector, equality) {
 			assertActive();
-			materialize(projection, state);
 			const source = makeReadable(projection, selector, equality, state);
 			return Object.freeze({
 				current: () => {
@@ -3104,7 +2283,7 @@ const createProjectionRuntime = (options) => {
 		}
 		function scopeBatch(optionsOrCallback, maybeCallback) {
 			assertActive();
-			return typeof optionsOrCallback === "function" ? runtime.batch(optionsOrCallback) : runtime.batch(optionsOrCallback, maybeCallback);
+			return typeof optionsOrCallback === "function" ? batch(optionsOrCallback) : batch(optionsOrCallback, maybeCallback);
 		}
 		return Object.freeze({
 			input: scopedInput,
@@ -3124,41 +2303,19 @@ const createProjectionRuntime = (options) => {
 				updateInput(target, run, state);
 			},
 			batch: scopeBatch,
-			dispose: () => {
-				if (!state.active) return;
-				runtime.assertIdle();
-				state.active = false;
-				state.subscriptions.forEach((unsubscribe) => unsubscribe());
-				for (const definition of state.materialized.reverse()) {
-					const group = groups.get(definition);
-					if (group) {
-						runtime.releaseNode(group.nodes[0]);
-						groups.delete(definition);
-						group.definition.projections.forEach((projection) => materialized.delete(projection));
-						continue;
-					}
-					const record = materialized.get(definition);
-					if (!record) continue;
-					runtime.releaseNode(record.node);
-					if (record.kind !== "projection") runtime.releaseInput(record.source);
-					materialized.delete(definition);
-				}
-				state.materialized.length = 0;
-				scopes.delete(state);
-			}
+			dispose: () => disposeScope(state)
 		});
 	};
-	const store = {
+	return Object.freeze({
 		get,
 		readable,
 		set: setInput,
 		update: updateInput,
-		batch: runtime.batch,
+		batch,
 		scope: createScope,
 		dispose: () => {
-			if (disposed) return;
-			runtime.assertIdle();
-			disposed = true;
+			if (!scheduler.active) return;
+			scheduler.assertIdle();
 			for (const scope of scopes) {
 				scope.active = false;
 				scope.subscriptions.forEach((unsubscribe) => unsubscribe());
@@ -3166,10 +2323,10 @@ const createProjectionRuntime = (options) => {
 				scope.materialized.length = 0;
 			}
 			scopes.clear();
-			runtime.dispose();
+			sources.dispose();
+			scheduler.dispose();
 		}
-	};
-	return Object.freeze(store);
+	});
 };
 //#endregion
 export { DocumentDisposedError, DocumentReentrancyError, ParseError, ProjectionDisposedError, ProjectionError, TransactionRejected, asReadable, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, snapshot, table, tree, variant };