doxum 0.1.17 → 0.1.19

package/dist/index.cjs

@@ -3,7 +3,7 @@ const require_issue = require("./issue-DhrNdQNg.cjs");
 const require_scope = require("./scope-Ezs-Y3TY.cjs");
 const require_notification = require("./notification-CDSUfiip.cjs");
 const require_driver = require("./driver-BCyfqxsl.cjs");
-const require_definition = require("./definition-De6rhTlZ.cjs");
+const require_advanced = require("./advanced-CMMNk49G.cjs");
 //#region core/src/schema.ts
 const node = (value) => Object.freeze(value);
 const field = (validator) => node({
@@ -1104,314 +1104,6 @@ const asReadable = (runtime) => {
 //#region core/src/projection/select.ts
 const read = (runtime, selector) => require_notification.readWith(runtime, selector);
 //#endregion
-//#region core/src/projection/contract.ts
-var ProjectionError = class extends Error {
-	constructor(phase, identity, revisions, cause) {
-		super(`Projection ${phase} failed: ${identity}`, { cause });
-		this.phase = phase;
-		this.identity = identity;
-		this.revisions = revisions;
-		this.name = "ProjectionError";
-	}
-};
-var ProjectionDisposedError = class extends Error {
-	constructor() {
-		super("Projection has been disposed.");
-		this.name = "ProjectionDisposedError";
-	}
-};
-//#endregion
-//#region core/src/projection/scheduler.ts
-const projectionHandles = /* @__PURE__ */ new WeakSet();
-const createScheduler = (onError) => {
-	let disposed = false;
-	let depth = 0;
-	let batchSequence = 0;
-	let activeBatch;
-	let phase = "idle";
-	let sequence = 0;
-	const records = /* @__PURE__ */ new Map();
-	const nodes = /* @__PURE__ */ new Set();
-	const pending = /* @__PURE__ */ new Set();
-	const heap = [];
-	const queued = /* @__PURE__ */ new Set();
-	const completed = [];
-	const emissions = /* @__PURE__ */ new Set();
-	const errors = [];
-	let reportingFailures = [];
-	const guards = /* @__PURE__ */ new Set();
-	const cleanups = /* @__PURE__ */ new Set();
-	const assertActive = () => {
-		if (disposed) throw new ProjectionDisposedError();
-	};
-	const assertIdle = () => {
-		assertActive();
-		if (phase !== "idle") throw new Error("Projection cannot be re-entered during processing or notification.");
-	};
-	const lock = (value) => guards.forEach((guard) => guard(value));
-	const enqueue = (node) => {
-		if (node.disposed || queued.has(node)) return;
-		queued.add(node);
-		require_issue.profile.projection("scheduledNodes");
-		let i = heap.length;
-		heap.push(node);
-		while (i > 0) {
-			const p = i - 1 >> 1;
-			if (heap[p].order < node.order) break;
-			heap[i] = heap[p];
-			i = p;
-		}
-		heap[i] = node;
-	};
-	const pop = () => {
-		const first = heap[0];
-		const last = heap.pop();
-		if (heap.length) {
-			let i = 0;
-			while (i * 2 + 1 < heap.length) {
-				let c = i * 2 + 1;
-				if (c + 1 < heap.length && heap[c + 1].order < heap[c].order) c++;
-				if (last.order < heap[c].order) break;
-				heap[i] = heap[c];
-				i = c;
-			}
-			heap[i] = last;
-		}
-		return first;
-	};
-	const errorFor = (node, cause, kind = "processor") => new ProjectionError(kind, node.name, node.sources.map((source) => source.revision()), cause);
-	const capture = (source) => {
-		if (disposed) return;
-		if (phase !== "idle") {
-			source.fault = new ProjectionError("source", "reentrant source", [source.revision()], /* @__PURE__ */ new Error("Source changed while projection was running."));
-			errors.push(source.fault);
-			throw source.fault;
-		}
-		pending.add(source);
-		require_issue.profile.projection("sourceEvents");
-		if (source.fault) errors.push(source.fault);
-	};
-	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
-		phase = "compute";
-		lock(true);
-		try {
-			pending.forEach((source) => source.consumers.forEach(enqueue));
-			while (heap.length) {
-				const node = pop();
-				if (node.disposed) continue;
-				const wasFaulted = node.fault !== void 0;
-				require_issue.profile.projection("processedNodes");
-				let changed = false;
-				const blocked = node.sources.find((source) => source.fault || source.disposed);
-				if (blocked) node.fault = errorFor(node, blocked.fault ?? new ProjectionDisposedError(), "blocked");
-				else {
-					const build = wasFaulted || node.sources.some((source) => source.reset());
-					try {
-						changed = node.evaluate(build);
-						const failure = node.sources.find((source) => source.fault)?.fault;
-						if (failure) throw failure;
-						node.fault = void 0;
-					} catch (cause) {
-						const error = errorFor(node, cause);
-						errors.push(error);
-						node.fault = error;
-						if (!build) try {
-							changed = node.evaluate(true);
-							const failure = node.sources.find((source) => source.fault)?.fault;
-							if (failure) throw failure;
-							node.fault = void 0;
-						} catch (cause) {
-							node.fault = errorFor(node, cause);
-							errors.push(node.fault);
-						}
-					}
-				}
-				completed.push(node);
-				if (changed || wasFaulted || node.fault) {
-					require_issue.profile.projection("publishedNodes");
-					emissions.add(node);
-					node.consumers.forEach(enqueue);
-				}
-			}
-			completed.forEach((node) => node.publish());
-		} finally {
-			lock(false);
-			phase = "idle";
-		}
-	};
-	const flush = () => {
-		if (disposed || depth) return [];
-		if (pending.size || completed.length) require_issue.profile.projection("flushes");
-		phase = "notify";
-		lock(true);
-		const reportFailures = [];
-		try {
-			emissions.forEach((node) => node.emit((listener) => {
-				try {
-					listener();
-				} catch (cause) {
-					errors.push(errorFor(node, cause, "listener"));
-				}
-			}));
-			for (const error of errors.slice()) try {
-				onError(error);
-			} catch (cause) {
-				reportFailures.push(cause);
-			}
-			return Object.freeze([...errors.map((error) => Object.freeze({
-				phase: error.phase === "listener" ? "listener" : "processor",
-				error
-			})), ...reportFailures.map((error) => Object.freeze({
-				phase: "listener",
-				error
-			}))]);
-		} finally {
-			pending.forEach((source) => source.clear());
-			completed.forEach((node) => node.clear());
-			pending.clear();
-			queued.clear();
-			completed.length = 0;
-			emissions.clear();
-			errors.length = 0;
-			reportingFailures = reportFailures;
-			lock(false);
-			phase = "idle";
-		}
-	};
-	const run = () => {
-		settle();
-		const result = flush();
-		const failures = reportingFailures;
-		reportingFailures = [];
-		if (failures.length) throw new AggregateError(failures, "Projection error reporter failed.");
-		return result;
-	};
-	const batch = (optionsOrCallback, maybeCallback) => {
-		assertIdle();
-		const options = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
-		const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : maybeCallback;
-		if (!callback) throw new TypeError("Projection batch requires a callback.");
-		if (depth === 0) activeBatch = Object.freeze({
-			id: ++batchSequence,
-			...options?.cause === void 0 ? {} : { cause: options.cause }
-		});
-		depth++;
-		let failed = false;
-		try {
-			const value = callback();
-			assertSynchronous(value);
-			return value;
-		} catch (error) {
-			failed = true;
-			throw error;
-		} finally {
-			depth--;
-			if (!depth) try {
-				if (failed) try {
-					run();
-				} catch {}
-				else run();
-			} finally {
-				activeBatch = void 0;
-			}
-		}
-	};
-	return {
-		assertActive,
-		assertIdle,
-		capture,
-		settle,
-		flush,
-		run,
-		records,
-		guards,
-		cleanups,
-		get active() {
-			return !disposed;
-		},
-		register(handle, record) {
-			assertIdle();
-			records.set(handle, record);
-			projectionHandles.add(handle);
-		},
-		unregisterSource(handle) {
-			const record = records.get(handle);
-			if (record) {
-				record.disposed = true;
-				pending.delete(record);
-				record.clear();
-				records.delete(handle);
-			}
-		},
-		source(handle) {
-			assertActive();
-			const source = records.get(handle);
-			if (!source || source.disposed) throw new Error("Unknown, disposed, or foreign projection source.");
-			return source;
-		},
-		addNode(node) {
-			nodes.add(node);
-			node.sources.forEach((source) => source.consumers.add(node));
-		},
-		order: () => sequence++,
-		initialize(run) {
-			assertIdle();
-			phase = "compute";
-			lock(true);
-			try {
-				return run();
-			} finally {
-				lock(false);
-				phase = "idle";
-			}
-		},
-		batch,
-		batchContext: () => activeBatch,
-		dispose() {
-			if (disposed) return;
-			assertIdle();
-			disposed = true;
-			const failures = [];
-			cleanups.forEach((cleanup) => {
-				try {
-					cleanup();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			cleanups.clear();
-			nodes.forEach((node) => {
-				node.disposed = true;
-				node.release();
-				node.consumers.clear();
-			});
-			records.forEach((source) => {
-				source.disposed = true;
-				source.consumers.clear();
-				source.clear();
-			});
-			nodes.clear();
-			records.clear();
-			pending.clear();
-			heap.length = 0;
-			completed.length = 0;
-			queued.clear();
-			emissions.clear();
-			guards.clear();
-			errors.length = 0;
-			reportingFailures = [];
-			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
-		}
-	};
-};
-const assertSynchronous = (value) => {
-	if (value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function") throw new TypeError("Projection callbacks must be synchronous.");
-};
-const assertScope = (active) => {
-	if (!active()) throw new Error("Projection reader or writer is no longer active.");
-};
-//#endregion
 //#region core/src/projection/source.ts
 const createSources = (scheduler) => {
 	const documents = /* @__PURE__ */ new Map();
@@ -1464,7 +1156,7 @@ const createSources = (scheduler) => {
 					nextBaselineIds = Object.freeze([]);
 				},
 				context: (active) => {
-					assertScope(active);
+					require_advanced.assertScope(active);
 					if (state.disposed) throw new Error("Document has been disposed.");
 					const context = {
 						state,
@@ -1474,16 +1166,16 @@ const createSources = (scheduler) => {
 					const snapshots = collection ? /* @__PURE__ */ new Map() : void 0;
 					const read = collection ? Object.freeze({
 						get: (key) => {
-							assertScope(active);
+							require_advanced.assertScope(active);
 							if (!snapshots.has(key)) snapshots.set(key, require_scope.snapshot(rawRead.get(key)));
 							return snapshots.get(key);
 						},
 						has: (key) => {
-							assertScope(active);
+							require_advanced.assertScope(active);
 							return rawRead.has(key);
 						},
 						ids: () => {
-							assertScope(active);
+							require_advanced.assertScope(active);
 							return rawRead.ids();
 						}
 					}) : require_scope.createAccess(context);
@@ -1623,7 +1315,7 @@ const createSources = (scheduler) => {
 			flush: scheduler.flush,
 			dispose: () => {
 				bindings.forEach(({ record }) => {
-					record.fault = new ProjectionError("source", "document disposed", [runtime.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
+					record.fault = new require_advanced.ProjectionError("source", "document disposed", [runtime.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
 					scheduler.capture(record);
 				});
 				scheduler.run();
@@ -1653,7 +1345,7 @@ const createSources = (scheduler) => {
 				reset = false;
 			},
 			context: (active) => {
-				assertScope(active);
+				require_advanced.assertScope(active);
 				return Object.freeze({
 					kind: "value",
 					value,
@@ -1685,6 +1377,149 @@ const createSources = (scheduler) => {
 			}
 		};
 	};
+	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;
+			return Object.freeze({
+				kind: "incremental",
+				added: Object.freeze(added),
+				updated: Object.freeze(updated),
+				removed: Object.freeze(removed),
+				...order ? { order } : {}
+			});
+		};
+		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) => {
+				require_advanced.assertScope(active);
+				const read = Object.freeze({
+					get: (key) => {
+						require_advanced.assertScope(active);
+						return values.get(key);
+					},
+					has: (key) => {
+						require_advanced.assertScope(active);
+						return values.has(key);
+					},
+					ids: () => {
+						require_advanced.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) => {
+						require_advanced.assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present ? entry.value : void 0 : values.get(key);
+					},
+					has: (key) => {
+						require_advanced.assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present : values.has(key);
+					},
+					set: (key, value) => {
+						require_advanced.assertScope(() => active);
+						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						staged.set(key, {
+							present: true,
+							value
+						});
+					},
+					remove: (key) => {
+						require_advanced.assertScope(() => active);
+						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						staged.set(key, { present: false });
+					}
+				});
+				try {
+					require_advanced.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();
+			}
+		};
+	};
 	const externalValueSource = (port, equal) => {
 		scheduler.assertIdle();
 		const old = externalSources.get(port);
@@ -1692,7 +1527,7 @@ const createSources = (scheduler) => {
 		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);
+			record.fault = new require_advanced.ProjectionError("source", "external source", [record.revision()], cause);
 			scheduler.capture(record);
 		};
 		let unsubscribe;
@@ -1748,18 +1583,18 @@ const createSources = (scheduler) => {
 				transitionKeys.clear();
 			},
 			context: (active) => {
-				assertScope(active);
+				require_advanced.assertScope(active);
 				const currentRead = Object.freeze({
 					get: (key) => {
-						assertScope(active);
+						require_advanced.assertScope(active);
 						return read.get(key);
 					},
 					has: (key) => {
-						assertScope(active);
+						require_advanced.assertScope(active);
 						return read.has(key);
 					},
 					ids: () => {
-						assertScope(active);
+						require_advanced.assertScope(active);
 						return read.ids();
 					}
 				});
@@ -1774,7 +1609,7 @@ const createSources = (scheduler) => {
 		};
 		scheduler.register(handle, record);
 		const fail = (error) => {
-			record.fault = new ProjectionError("source", "external collection source", [revision], error);
+			record.fault = new require_advanced.ProjectionError("source", "external collection source", [revision], error);
 			scheduler.capture(record);
 		};
 		const deriveChange = () => {
@@ -1877,9 +1712,10 @@ const createSources = (scheduler) => {
 				set
 			});
 		},
+		collectionInput,
 		fromReadable: (readable, options) => {
 			scheduler.assertIdle();
-			if (projectionHandles.has(readable)) throw new Error("Projection nodes must be declared directly as sources.");
+			if (require_advanced.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);
@@ -1905,7 +1741,7 @@ const createSources = (scheduler) => {
 				} catch (cause) {
 					for (const member of members.values()) {
 						const record = scheduler.source(member.source);
-						record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
+						record.fault = new require_advanced.ProjectionError("source", "external readable", [record.revision()], cause);
 						scheduler.capture(record);
 					}
 					if (settle) scheduler.run();
@@ -1915,7 +1751,7 @@ const createSources = (scheduler) => {
 					member.accept(value);
 				} catch (cause) {
 					const record = scheduler.source(member.source);
-					record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
+					record.fault = new require_advanced.ProjectionError("source", "external readable", [record.revision()], cause);
 					scheduler.capture(record);
 				}
 				if (settle) scheduler.run();
@@ -1933,7 +1769,7 @@ const createSources = (scheduler) => {
 						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."));
+								record.fault = new require_advanced.ProjectionError("source", "document readable disposed", [record.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
 								scheduler.capture(record);
 							}
 							scheduler.run();
@@ -1970,6 +1806,7 @@ const createNode = (scheduler, spec, behavior) => {
 	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();
@@ -1992,15 +1829,16 @@ const createNode = (scheduler, spec, behavior) => {
 			}
 		}
 	};
+	node.owner = node;
 	scheduler.initialize(() => {
 		const invalid = node.sources.find((source) => source.fault || source.disposed);
-		if (invalid) throw invalid.fault ?? new ProjectionDisposedError();
+		if (invalid) throw invalid.fault ?? new require_advanced.ProjectionDisposedError();
 		node.evaluate(true);
 		node.publish();
 		node.clear();
 	});
 	const check = () => {
-		if (node.disposed || !scheduler.active) throw new ProjectionDisposedError();
+		if (node.disposed || !scheduler.active) throw new require_advanced.ProjectionDisposedError();
 		if (node.fault) throw node.fault;
 	};
 	return {
@@ -2032,17 +1870,17 @@ const createValue = (scheduler, spec, options) => {
 				require_issue.profile.materialized.rebuilt();
 				instance = void 0;
 				const built = spec.build(sources);
-				assertSynchronous(built);
+				require_advanced.assertSynchronous(built);
 				instance = built;
 				candidate = built.value;
 			} else {
 				require_issue.profile.materialized.updated();
 				const result = instance.update(sources);
-				assertSynchronous(result);
+				require_advanced.assertSynchronous(result);
 				if (result.kind === "rebuild") {
 					instance = void 0;
 					const built = spec.build(sources);
-					assertSynchronous(built);
+					require_advanced.assertSynchronous(built);
 					instance = built;
 					candidate = built.value;
 					build = true;
@@ -2054,7 +1892,7 @@ const createValue = (scheduler, spec, options) => {
 			return changed;
 		},
 		context: (active) => {
-			assertScope(active);
+			require_advanced.assertScope(active);
 			return Object.freeze({
 				kind: "value",
 				value: next,
@@ -2108,7 +1946,7 @@ const createValue = (scheduler, spec, options) => {
 	return handle;
 };
 //#endregion
-//#region core/src/projection/collection.ts
+//#region core/src/projection/collection-state.ts
 const height = (node) => node?.height ?? 0;
 const makeTreeNode = (key, value, left, right) => Object.freeze({
 	key,
@@ -2174,214 +2012,197 @@ const treeFromSorted = (entries, start = 0, end = entries.length) => {
 	const [key, value] = entries[middle];
 	return makeTreeNode(key, value, treeFromSorted(entries, start, middle), treeFromSorted(entries, middle + 1, end));
 };
-const createCollection = (scheduler, spec) => {
+/**
+* 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;
-	let instance;
 	let initialized = false;
 	let reset = false;
 	let revision = 0;
 	let publishedRoot;
-	let cause;
-	const listeners = /* @__PURE__ */ new Set();
-	const changedKeys = /* @__PURE__ */ new Set();
+	let changedKeys = /* @__PURE__ */ new Set();
 	let orderChanged = false;
-	const readPublished = (root, publishedIds) => Object.freeze({
-		get: (key) => {
-			owner.check();
-			return treeGet(root, key);
-		},
-		has: (key) => {
-			owner.check();
-			return treeHas(root, key);
-		},
-		ids: () => {
-			owner.check();
-			return publishedIds;
-		}
-	});
-	const hasNext = (key) => staged.has(key) ? staged.get(key).present : values.has(key);
+	let explicitOrder;
+	let cleared = false;
+	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 : values.get(key);
+		return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : values.get(key);
 	};
-	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;
-			staged = /* @__PURE__ */ new Map();
-			nextIds = ids;
-			change = void 0;
-			changedKeys.clear();
-			let explicitOrder;
-			let cleared = false;
-			const nextHas = (key) => staged.has(key) ? staged.get(key).present : !cleared && values.has(key);
-			const nextGet = (key) => {
-				const entry = staged.get(key);
-				return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : values.get(key);
-			};
-			const deriveIds = () => {
-				const result = cleared ? [] : ids.filter(nextHas);
-				for (const [key, entry] of staged) if (entry.present && (cleared || !values.has(key))) result.push(key);
-				return result;
-			};
-			const read = (next) => ({
-				get: (key) => {
-					assertScope(active);
-					return next ? nextGet(key) : values.get(key);
+	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 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) => {
+				require_advanced.assertScope(active);
+				return next ? getNext(key) : values.get(key);
+			},
+			has: (key) => {
+				require_advanced.assertScope(active);
+				return next ? hasNext(key) : values.has(key);
+			},
+			ids: () => {
+				require_advanced.assertScope(active);
+				return next ? Object.freeze(explicitOrder ? [...explicitOrder] : [...deriveIds()]) : ids;
+			}
+		});
+		return {
+			previous: read(false),
+			next: read(true),
+			output: {
+				set: (key, value) => {
+					require_advanced.assertScope(active);
+					if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+					staged.set(key, {
+						present: true,
+						value
+					});
 				},
-				has: (key) => {
-					assertScope(active);
-					return next ? nextHas(key) : values.has(key);
+				remove: (key) => {
+					require_advanced.assertScope(active);
+					staged.set(key, { present: false });
 				},
-				ids: () => {
-					assertScope(active);
-					return next ? Object.freeze(explicitOrder ? explicitOrder.slice() : deriveIds()) : ids;
-				}
-			});
-			const input = {
-				sources,
-				previous: read(false),
-				next: read(true),
-				output: {
-					set: (key, value) => {
-						assertScope(active);
-						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-						staged.set(key, {
-							present: true,
-							value
-						});
-					},
-					remove: (key) => {
-						assertScope(active);
-						staged.set(key, { present: false });
-					},
-					order: (order) => {
-						assertScope(active);
-						explicitOrder = order.slice();
-					}
+				order: (order) => {
+					require_advanced.assertScope(active);
+					explicitOrder = Object.freeze([...order]);
 				}
-			};
-			if (build || !instance) {
-				require_issue.profile.materialized.rebuilt();
-				instance = void 0;
-				cleared = true;
-				const built = spec.build(input);
-				assertSynchronous(built);
-				instance = built;
-			} else {
-				require_issue.profile.materialized.updated();
-				const result = instance.update(input);
-				assertSynchronous(result);
-				if (result?.kind === "rebuild") {
-					staged.clear();
-					cleared = true;
-					explicitOrder = void 0;
-					instance = void 0;
-					const built = spec.build(input);
-					assertSynchronous(built);
-					instance = built;
-					build = true;
-				}
-			}
-			if (cleared) {
-				for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
 			}
-			const added = /* @__PURE__ */ new Set();
-			const removed = /* @__PURE__ */ new Set();
-			const updated = /* @__PURE__ */ new Set();
-			require_issue.profile.projection("touchedKeys", staged.size);
-			for (const [key, entry] of staged) {
-				const existed = values.has(key);
-				if (entry.present) if (!existed) added.add(key);
-				else if (!(spec.isEqual ?? Object.is)(values.get(key), entry.value)) updated.add(key);
-				else staged.delete(key);
-				else if (existed) removed.add(key);
-				else staged.delete(key);
-			}
-			if (explicitOrder || added.size || removed.size) {
-				const order = explicitOrder ?? [...ids.filter((key) => !removed.has(key)), ...added];
-				if (new Set(order).size !== order.length || order.length !== values.size + added.size - removed.size || order.some((key) => !hasNext(key))) throw new TypeError("Projection order must contain every key exactly once.");
-				nextIds = ids.length === order.length && ids.every((key, i) => key === order[i]) ? ids : Object.freeze(order.slice());
+		};
+	};
+	const seal = (nextReset, isEqual) => {
+		if (cleared) {
+			for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
+		}
+		require_issue.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);
+		}
+		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);
+		require_issue.profile.projection("changedKeys", changedKeys.size);
+		const addedEntries = [];
+		const updatedEntries = [];
+		const removedEntries = [];
+		for (const key of changedKeys) {
+			const beforePresent = values.has(key);
+			const afterPresent = hasNext(key);
+			if (beforePresent === afterPresent) {
+				if (!beforePresent || isEqual(values.get(key), getNext(key))) continue;
 			}
-			orderChanged = nextIds !== ids;
-			[
-				...added,
-				...removed,
-				...updated
-			].forEach((key) => changedKeys.add(key));
-			require_issue.profile.projection("changedKeys", changedKeys.size);
-			const addedEntries = [];
-			const updatedEntries = [];
-			const removedEntries = [];
-			for (const key of changedKeys) {
-				const beforePresent = values.has(key);
-				const afterPresent = hasNext(key);
-				if (beforePresent === afterPresent) {
-					if (!beforePresent) continue;
-					if ((spec.isEqual ?? Object.is)(values.get(key), getNext(key))) continue;
-				}
-				if (!beforePresent) addedEntries.push({
-					key,
-					after: getNext(key)
-				});
-				else if (!afterPresent) removedEntries.push({
-					key,
-					before: values.get(key)
-				});
-				else updatedEntries.push({
-					key,
-					before: values.get(key),
-					after: getNext(key)
-				});
+			if (!beforePresent) addedEntries.push({
+				key,
+				after: getNext(key)
+			});
+			else if (!afterPresent) removedEntries.push({
+				key,
+				before: values.get(key)
+			});
+			else updatedEntries.push({
+				key,
+				before: values.get(key),
+				after: getNext(key)
+			});
+		}
+		if (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);
 			}
-			if (build) change = Object.freeze({ kind: "reset" });
-			else if (addedEntries.length || updatedEntries.length || removedEntries.length || orderChanged) {
-				let commonOrderChanged = false;
-				if (orderChanged) {
-					const before = ids.filter((key) => !removed.has(key));
-					const after = nextIds.filter((key) => !added.has(key));
-					commonOrderChanged = before.some((key, i) => after[i] !== key);
-				}
-				change = Object.freeze({
-					kind: "incremental",
-					added: Object.freeze(addedEntries),
-					updated: Object.freeze(updatedEntries),
-					removed: Object.freeze(removedEntries),
-					...commonOrderChanged ? { order: Object.freeze({
-						before: Object.freeze([...ids]),
-						after: Object.freeze([...nextIds])
-					}) } : {}
-				});
+			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])
+				}) } : {}
+			});
+		}
+		reset = nextReset;
+		return change !== void 0;
+	};
+	const context = (active, cause) => Object.freeze({
+		kind: "collection",
+		read: {
+			get: (key) => {
+				require_advanced.assertScope(active);
+				return getNext(key);
+			},
+			has: (key) => {
+				require_advanced.assertScope(active);
+				return hasNext(key);
+			},
+			ids: () => {
+				require_advanced.assertScope(active);
+				return nextIds;
 			}
-			reset = build;
-			return change !== void 0;
-		},
-		context: (active) => {
-			const input = {
-				kind: "collection",
-				read: {
-					get: (key) => {
-						assertScope(active);
-						return getNext(key);
-					},
-					has: (key) => {
-						assertScope(active);
-						return hasNext(key);
-					},
-					ids: () => {
-						assertScope(active);
-						return nextIds;
-					}
-				},
-				change,
-				revision: revision + (change ? 1 : 0),
-				cause
-			};
-			return Object.freeze(input);
 		},
+		change,
+		revision: revision + (change ? 1 : 0),
+		cause
+	});
+	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;
+			}
+		});
+	};
+	return {
+		begin,
+		seal,
+		context,
+		current,
 		revision: () => revision,
 		reset: () => reset,
 		publish: () => {
@@ -2393,14 +2214,11 @@ const createCollection = (scheduler, spec) => {
 			} else for (const [key, entry] of staged) publishedRoot = entry.present ? treeSet(publishedRoot, key, entry.value) : treeRemove(publishedRoot, key);
 			for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
 			else values.delete(key);
-			if (change) {
-				if (initialized) revision++;
-			}
+			if (change && initialized) revision++;
 			ids = nextIds;
 			initialized = true;
 		},
 		emit: (call) => {
-			require_issue.profile.materialized.notification();
 			const resetEvent = Object.freeze({ kind: "reset" });
 			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
 		},
@@ -2410,8 +2228,9 @@ const createCollection = (scheduler, spec) => {
 			change = void 0;
 			reset = false;
 			changedKeys.clear();
-			cause = void 0;
+			explicitOrder = void 0;
 			orderChanged = false;
+			cleared = false;
 		},
 		release: () => {
 			values.clear();
@@ -2419,6 +2238,66 @@ const createCollection = (scheduler, spec) => {
 			publishedRoot = void 0;
 			listeners.clear();
 			ids = nextIds = Object.freeze([]);
+			change = void 0;
+			initialized = false;
+			revision = 0;
+		},
+		subscribe: (listener) => {
+			listeners.add(listener);
+		},
+		unsubscribe: (listener) => {
+			listeners.delete(listener);
+		}
+	};
+};
+//#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) {
+				require_issue.profile.materialized.rebuilt();
+				instance = void 0;
+				const built = spec.build({
+					sources,
+					...input
+				});
+				require_advanced.assertSynchronous(built);
+				instance = built;
+			} else {
+				require_issue.profile.materialized.updated();
+				const result = instance.update({
+					sources,
+					...input
+				});
+				require_advanced.assertSynchronous(result);
+				if (result?.kind === "rebuild") {
+					const rebuildInput = state.begin(active, true);
+					instance = void 0;
+					const built = spec.build({
+						sources,
+						...rebuildInput
+					});
+					require_advanced.assertSynchronous(built);
+					instance = built;
+					build = true;
+				}
+			}
+			return state.seal(build, spec.isEqual ?? Object.is);
+		},
+		context: (active) => state.context(active, cause),
+		revision: state.revision,
+		reset: state.reset,
+		publish: state.publish,
+		emit: state.emit,
+		clear: state.clear,
+		release: () => {
+			state.release();
 			instance = void 0;
 		}
 	});
@@ -2426,34 +2305,186 @@ const createCollection = (scheduler, spec) => {
 		kind: "collection",
 		current: () => {
 			owner.check();
-			return readPublished(publishedRoot, ids);
+			return state.current(owner.check);
 		},
 		revision: () => {
 			owner.check();
-			return revision;
+			return state.revision();
 		},
 		subscribe: (listener) => {
 			owner.check();
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
+			state.subscribe(listener);
+			return () => state.unsubscribe(listener);
 		}
 	};
 	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
+		};
+		Object.defineProperty(output, "fault", {
+			configurable: false,
+			enumerable: true,
+			get: () => node.fault,
+			set: (value) => {
+				node.fault = value;
+			}
+		});
+		return output;
+	});
+	const check = () => {
+		if (node.disposed || !scheduler.active) throw new require_advanced.ProjectionDisposedError();
+		if (node.fault) throw node.fault;
+	};
+	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)
+			};
+		};
+		let input = makeInput(build);
+		if (build || !instance) {
+			require_issue.profile.materialized.rebuilt();
+			instance = void 0;
+			const built = spec.build(input);
+			require_advanced.assertSynchronous(built);
+			instance = built;
+		} else {
+			require_issue.profile.materialized.updated();
+			const result = instance.update(input);
+			require_advanced.assertSynchronous(result);
+			if (result?.kind === "rebuild") {
+				input = makeInput(true);
+				instance = void 0;
+				const built = spec.build(input);
+				require_advanced.assertSynchronous(built);
+				instance = built;
+				build = true;
+			}
+		}
+		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) => {
+			require_advanced.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;
+			}
+		},
+		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();
+			});
+			instance = void 0;
+		}
+	};
+	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 require_advanced.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);
+			}
+		};
+		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 scheduler = require_advanced.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);
+			require_advanced.assertSynchronous(value);
 			return value;
 		};
 		return createCollection(scheduler, {
@@ -2497,11 +2528,16 @@ const createProjectionGraph = (options) => {
 		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: () => {
 			try {
 				scheduler.dispose();
@@ -2671,16 +2707,52 @@ const sourceOf = (instance) => instance;
 const createProjectionRuntime = (options) => {
 	const runtime = createProjectionGraph({ onError: options?.onError ?? (() => void 0) });
 	const materialized = /* @__PURE__ */ new WeakMap();
-	const materialize = (projection) => {
+	const groups = /* @__PURE__ */ new WeakMap();
+	let disposed = false;
+	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) => require_advanced.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;
+	};
+	materialize = (projection, requester) => {
+		const owner = require_advanced.ownerOf(projection);
+		if (owner) {
+			if (owner !== requester) throw new TypeError("Projection belongs to another scope.");
+			if (!requester.active) throw new require_advanced.ProjectionDisposedError();
+		}
 		const old = materialized.get(projection);
 		if (old) return old.node;
-		const definition = require_definition.definitionOf(projection);
+		const definition = require_advanced.definitionOf(projection);
+		if (definition.kind === "incremental-group-output") return materializeGroup(definition.group, requester).nodes[definition.output];
 		let instance;
-		let setter;
+		let write;
 		switch (definition.kind) {
 			case "input": {
 				const input = runtime.input(definition.initial, { isEqual: definition.isEqual });
-				setter = input.set;
+				write = {
+					kind: "value-input",
+					source: input.source,
+					set: input.set
+				};
 				instance = runtime.value({
 					sources: { input: input.source },
 					build: (values) => ({
@@ -2693,6 +2765,16 @@ const createProjectionRuntime = (options) => {
 				});
 				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({
@@ -2764,7 +2846,7 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 			case "derive": {
-				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency))]));
+				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency, owner))]));
 				instance = runtime.value({
 					sources,
 					build: (values) => ({
@@ -2778,7 +2860,7 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 			case "incremental-value": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
+				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency, owner))]));
 				instance = runtime.value({
 					sources,
 					build: definition.build
@@ -2786,7 +2868,7 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 			case "incremental-collection": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
+				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency, owner))]));
 				instance = runtime.collection({
 					sources,
 					build: definition.build,
@@ -2796,14 +2878,19 @@ const createProjectionRuntime = (options) => {
 				break;
 			}
 		}
-		materialized.set(projection, {
+		const record = write ? {
 			node: instance,
-			set: setter
-		});
+			...write
+		} : {
+			kind: "projection",
+			node: instance
+		};
+		materialized.set(projection, record);
+		if (owner) owner.materialized.push(projection);
 		return instance;
 	};
-	const get = (projection) => {
-		const instance = materialize(projection);
+	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);
@@ -2831,11 +2918,11 @@ const createProjectionRuntime = (options) => {
 		}
 		return current;
 	};
-	function readable(projection, selector, equality = Object.is) {
+	const makeReadable = (projection, selector, equality = Object.is, requester) => {
 		if (!selector) return Object.freeze({
-			current: () => get(projection),
-			revision: () => materialize(projection).revision(),
-			subscribe: (listener) => materialize(projection).subscribe(listener)
+			current: () => get(projection, requester),
+			revision: () => materialize(projection, requester).revision(),
+			subscribe: (listener) => materialize(projection, requester).subscribe(listener)
 		});
 		let initialized = false;
 		let value;
@@ -2850,7 +2937,7 @@ const createProjectionRuntime = (options) => {
 		let unsubscribeSource;
 		const listeners = /* @__PURE__ */ new Set();
 		const updateCollectionSnapshot = () => {
-			const current = get(projection);
+			const current = get(projection, requester);
 			previousCollection = isMapLike(current) ? current : void 0;
 		};
 		const evaluate = () => {
@@ -2864,7 +2951,7 @@ const createProjectionRuntime = (options) => {
 			let source;
 			let next;
 			try {
-				source = get(projection);
+				source = get(projection, requester);
 				next = selector(source);
 			} finally {
 				activeTracker = previousTracker;
@@ -2881,30 +2968,30 @@ const createProjectionRuntime = (options) => {
 			}
 			selection = nextSelection;
 			initialized = true;
-			sourceRevision = materialize(projection).revision();
+			sourceRevision = materialize(projection, requester).revision();
 			updateCollectionSnapshot();
 			return changed;
 		};
 		const ensureCurrent = () => {
-			const revision = materialize(projection).revision();
+			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);
+				const current = get(projection, requester);
 				if (isMapLike(current)) {
 					change = mapChange(previousCollection, current);
 					previousCollection = current;
 					if (!change) {
-						sourceRevision = materialize(projection).revision();
+						sourceRevision = materialize(projection, requester).revision();
 						return;
 					}
 				} else previousCollection = void 0;
 			}
 			if (!selectionAffects(selection, change)) {
-				sourceRevision = materialize(projection).revision();
+				sourceRevision = materialize(projection, requester).revision();
 				updateCollectionSnapshot();
 				return;
 			}
@@ -2912,12 +2999,12 @@ const createProjectionRuntime = (options) => {
 			const changed = evaluate();
 			if (unsubscribeSource && !sameSelection(previousSelection, selection)) {
 				unsubscribeSource();
-				unsubscribeSource = materialize(projection).subscribe(onProjectionChange);
+				unsubscribeSource = materialize(projection, requester).subscribe(onProjectionChange);
 			}
 			if (changed) Array.from(listeners).forEach((listener) => listener());
 		};
 		const installSource = () => {
-			if (!unsubscribeSource) unsubscribeSource = materialize(projection).subscribe(onProjectionChange);
+			if (!unsubscribeSource) unsubscribeSource = materialize(projection, requester).subscribe(onProjectionChange);
 		};
 		return Object.freeze({
 			current: ensureCurrent,
@@ -2938,18 +3025,150 @@ const createProjectionRuntime = (options) => {
 				};
 			}
 		});
+	};
+	function readable(projection, selector, equality) {
+		return makeReadable(projection, selector, equality);
 	}
+	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 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 createScope = () => {
+		runtime.assertIdle();
+		const state = {
+			active: true,
+			materialized: [],
+			subscriptions: /* @__PURE__ */ new Set()
+		};
+		scopes.add(state);
+		const assertActive = () => {
+			if (!state.active) throw new require_advanced.ProjectionDisposedError();
+		};
+		const own = (projection) => {
+			assertActive();
+			const definition = require_advanced.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 = require_advanced.ownerOf(dependency);
+				if (dependencyOwner && dependencyOwner !== state) throw new TypeError("A scope cannot depend on another scope.");
+			}
+			require_advanced.ownDefinition(projection, state);
+			return projection;
+		};
+		const scopedInput = Object.assign((initial, equality) => own(require_advanced.input(initial, equality)), { collection: (initial) => own(require_advanced.input.collection(initial)) });
+		const scopedDerive = (dependencies, compute, equality) => own(require_advanced.derive(dependencies, compute, equality));
+		const ownOutputTree = (tree) => {
+			if (require_advanced.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 scopedIncremental = Object.assign((dependencies, processor) => own(require_advanced.incremental(dependencies, processor)), {
+			collection: (dependencies, processor) => own(require_advanced.incremental.collection(dependencies, processor)),
+			group: (dependencies, defineOutputs, processor) => ownOutputTree(require_advanced.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: () => {
+					assertActive();
+					return source.current();
+				},
+				revision: () => {
+					assertActive();
+					return source.revision();
+				},
+				subscribe: (listener) => {
+					assertActive();
+					const stop = source.subscribe(listener);
+					let subscribed = true;
+					const unsubscribe = () => {
+						if (!subscribed) return;
+						subscribed = false;
+						state.subscriptions.delete(unsubscribe);
+						stop();
+					};
+					state.subscriptions.add(unsubscribe);
+					return unsubscribe;
+				}
+			});
+		}
+		function scopeBatch(optionsOrCallback, maybeCallback) {
+			assertActive();
+			return typeof optionsOrCallback === "function" ? runtime.batch(optionsOrCallback) : runtime.batch(optionsOrCallback, maybeCallback);
+		}
+		return Object.freeze({
+			input: scopedInput,
+			derive: scopedDerive,
+			incremental: scopedIncremental,
+			get: (projection) => {
+				assertActive();
+				return get(projection, state);
+			},
+			readable: scopeReadable,
+			set: (target, value) => {
+				assertActive();
+				setInput(target, value, state);
+			},
+			update: (target, run) => {
+				assertActive();
+				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);
+			}
+		});
+	};
 	const store = {
 		get,
 		readable,
-		set: ((input, value) => {
-			materialize(input);
-			const target = materialized.get(input);
-			if (!target?.set) throw new TypeError("Projection is not an input.");
-			target.set(value);
-		}),
+		set: setInput,
+		update: updateInput,
 		batch: runtime.batch,
-		dispose: runtime.dispose
+		scope: createScope,
+		dispose: () => {
+			if (disposed) return;
+			runtime.assertIdle();
+			disposed = true;
+			for (const scope of scopes) {
+				scope.active = false;
+				scope.subscriptions.forEach((unsubscribe) => unsubscribe());
+				scope.subscriptions.clear();
+				scope.materialized.length = 0;
+			}
+			scopes.clear();
+			runtime.dispose();
+		}
 	};
 	return Object.freeze(store);
 };
@@ -2957,19 +3176,19 @@ const createProjectionRuntime = (options) => {
 exports.DocumentDisposedError = require_notification.DocumentDisposedError;
 exports.DocumentReentrancyError = require_notification.DocumentReentrancyError;
 exports.ParseError = require_scope.ParseError;
-exports.ProjectionDisposedError = ProjectionDisposedError;
-exports.ProjectionError = ProjectionError;
+exports.ProjectionDisposedError = require_advanced.ProjectionDisposedError;
+exports.ProjectionError = require_advanced.ProjectionError;
 exports.TransactionRejected = require_notification.TransactionRejected;
 exports.asReadable = asReadable;
 exports.createDocument = createDocument;
 exports.createProjectionRuntime = createProjectionRuntime;
-exports.derive = require_definition.derive;
+exports.derive = require_advanced.derive;
 exports.field = field;
-exports.input = require_definition.input;
+exports.input = require_advanced.input;
 exports.list = list;
 exports.map = map;
 exports.object = object;
-exports.observe = require_definition.observe;
+exports.observe = require_advanced.observe;
 exports.optional = optional;
 exports.parse = require_scope.parse;
 exports.read = read;