doxum 0.1.18 → 0.1.20

package/dist/index.cjs

@@ -1,97 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 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_advanced = require("./advanced-Dgu8-bPS.cjs");
-//#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 = require_scope.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
+const require_access = require("./access-EQ-XiFyl.cjs");
+const require_advanced = require("./advanced-BIGP86NL.cjs");
+const require_notification = require("./notification-DGv-_G9t.cjs");
+const require_driver = require("./driver-DRoWiadc.cjs");
 //#region core/src/impact.ts
 const queries = /* @__PURE__ */ new WeakMap();
 const affectsTarget = (impact, value) => queries.get(impact).affects(value);
@@ -183,8 +95,8 @@ const createImpact = (schema, changes) => {
 	};
 	const impact = Object.freeze({
 		kind: reset ? "reset" : "incremental",
-		affects: (pick) => implementation.affects(compilePath(schema, "value", pick)),
-		collection: (pick) => implementation.collection(compilePath(schema, "collection", pick))
+		affects: (pick) => implementation.affects(require_advanced.compilePath(schema, "value", pick)),
+		collection: (pick) => implementation.collection(require_advanced.compilePath(schema, "collection", pick))
 	});
 	queries.set(impact, implementation);
 	return impact;
@@ -278,7 +190,7 @@ const createHistory = (input) => {
 			current: () => state,
 			revision: () => revision,
 			subscribe: (listener) => {
-				if (disposed) throw new require_notification.DocumentDisposedError();
+				if (disposed) throw new require_access.DocumentDisposedError();
 				listeners.add(listener);
 				return () => {
 					listeners.delete(listener);
@@ -403,8 +315,8 @@ const copyNode = (node) => ({
 });
 const transition = (node, key, beforePresent, before, afterPresent, after) => {
 	if (beforePresent === afterPresent && (!beforePresent || Object.is(before, after))) return;
-	if (node.kind !== "field" && beforePresent === afterPresent && require_scope.equalValue(node, before, after)) return;
-	const value = afterPresent ? node.kind === "field" ? after : require_scope.copyValue(node, after) : void 0;
+	if (node.kind !== "field" && beforePresent === afterPresent && require_access.equalValue(node, before, after)) return;
+	const value = afterPresent ? node.kind === "field" ? after : require_access.copyValue(node, after) : void 0;
 	require_issue.profile.recorder("transitions");
 	return !beforePresent ? {
 		key,
@@ -477,7 +389,7 @@ const restore = (fact, schema, root, skip = 0) => {
 	const at = skip ? fact.at.slice(skip) : fact.at;
 	if (fact.kind === "member") {
 		const member = fact.member;
-		const value = member.present ? require_scope.copyValue(member.node, member.value) : void 0;
+		const value = member.present ? require_access.copyValue(member.node, member.value) : void 0;
 		if (!at.length) return value;
 		const location = require_issue.resolveLocated(schema, root, at);
 		if (!location) throw new Error("Cannot restore an unresolved member.");
@@ -496,7 +408,7 @@ const restore = (fact, schema, root, skip = 0) => {
 	return root;
 };
 const reconstructBefore = (node, current, records, offset) => {
-	let before = require_scope.copyValue(node, current);
+	let before = require_access.copyValue(node, current);
 	for (let i = records.length - 1; i >= 0; i--) if (records[i].kind !== "order") before = restore(records[i], node, before, offset);
 	for (const record of records) if (record.kind === "order") before = restore(record, node, before, offset);
 	return before;
@@ -536,7 +448,7 @@ const sealTree = (fact, state, changes) => {
 	for (const [id, before] of fact.nodes) {
 		const after = Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
 		if (!before && !after) continue;
-		if (before && after && before.parentId === after.parentId && require_issue.equal(before.children, after.children) && Object.hasOwn(before, "value") === Object.hasOwn(after, "value") && require_scope.equalValue(node.value, before.value, after.value)) continue;
+		if (before && after && before.parentId === after.parentId && require_issue.equal(before.children, after.children) && Object.hasOwn(before, "value") === Object.hasOwn(after, "value") && require_access.equalValue(node.value, before.value, after.value)) continue;
 		nodes.push(!before ? {
 			id,
 			kind: "added",
@@ -744,7 +656,7 @@ var ChangeRecorder = class {
 			const fact = facts[i];
 			if (fact.kind === "members") for (const member of fact.members?.values() ?? []) {
 				if (!member) continue;
-				installMember(fact.parent, require_issue.memberKey(fact, member.key), member.present, member.present ? require_scope.copyValue(member.node, member.value) : void 0);
+				installMember(fact.parent, require_issue.memberKey(fact, member.key), member.present, member.present ? require_access.copyValue(member.node, member.value) : void 0);
 			}
 			else if (fact.kind === "tree") restore(fact, this.state.schema, this.state.document);
 		}
@@ -752,12 +664,12 @@ var ChangeRecorder = class {
 	}
 	seal() {
 		if (this.resetBefore) {
-			if (require_scope.equalValue(this.state.schema, this.resetBefore.value, this.state.document)) return require_driver.sealChanges([]);
+			if (require_access.equalValue(this.state.schema, this.resetBefore.value, this.state.document)) return require_driver.sealChanges([]);
 			require_issue.profile.recorder("sealed");
 			return require_driver.sealChanges([{
 				kind: "reset",
 				before: this.resetBefore.value,
-				after: require_scope.copyValue(this.state.schema, this.state.document)
+				after: require_access.copyValue(this.state.schema, this.state.document)
 			}]);
 		}
 		const changes = [];
@@ -784,7 +696,7 @@ var MutationSession = class {
 		this.resolvedRoot = state.document;
 	}
 	validate(node, value, at) {
-		const issue = require_scope.checkValue(node, value, at);
+		const issue = require_access.checkValue(node, value, at);
 		if (issue) require_issue.invalidValue(issue);
 	}
 	resolveContainer(at) {
@@ -806,7 +718,7 @@ var MutationSession = class {
 			this.validate(this.state.schema, value, at);
 			if (Object.is(this.state.document, value)) return;
 			this.recorder.reset();
-			this.state.document = require_scope.copyValue(this.state.schema, value);
+			this.state.document = require_access.copyValue(this.state.schema, value);
 			this.invalidate();
 			return;
 		}
@@ -848,12 +760,12 @@ var MutationSession = class {
 		const previous = container.parent[physicalKey];
 		if (existed === present && (!present || Object.is(previous, value))) return false;
 		if (parentNode.kind === "map" || parentNode.kind === "table") {
-			const issue = require_scope.checkKey(parentNode.key, key, []);
+			const issue = require_access.checkKey(parentNode.key, key, []);
 			if (issue) return require_issue.fail(container.at.concat(key, ...issue.address), "invalid-key", issue.message);
 		}
 		if (present) {
 			if (node.kind === "field") {
-				const issue = require_scope.checkValue(node, value, []);
+				const issue = require_access.checkValue(node, value, []);
 				if (issue) return require_issue.invalidValue(issue, container.at.concat(key, ...issue.address));
 			} else this.validate(node, value, container.at.concat(key));
 			if (parentNode.kind === "list" && parentNode.keyOf(value) !== key) return require_issue.fail(container.at.concat(key), "invalid-list-key", "Replacing an item must retain its addressed key.");
@@ -861,7 +773,7 @@ var MutationSession = class {
 		const membershipChanged = entry && existed !== present;
 		if (membershipChanged && (parentNode.kind === "list" || parentNode.kind === "table")) this.recorder.order(container);
 		this.recorder.member(container, key, member, physicalKey);
-		const next = present ? node.kind === "field" ? value : require_scope.copyValue(node, value) : void 0;
+		const next = present ? node.kind === "field" ? value : require_access.copyValue(node, value) : void 0;
 		installMember(container.parent, physicalKey, present, next);
 		if (node.kind !== "field" || membershipChanged) this.invalidate();
 		return membershipChanged;
@@ -931,18 +843,18 @@ function apply(session, changes, direction) {
 //#region core/src/runtime.ts
 const createDocument = (input) => {
 	if (input.schema.kind !== "object") throw new TypeError("Document schema must be a root object node.");
-	const invalid = require_scope.checkValue(input.schema, input.initial);
-	if (invalid) throw new require_scope.ParseError(invalid);
+	const invalid = require_access.checkValue(input.schema, input.initial);
+	if (invalid) throw new require_access.ParseError(invalid);
 	const state = {
 		schema: input.schema,
-		document: require_scope.copyValue(input.schema, input.initial),
+		document: require_access.copyValue(input.schema, input.initial),
 		disposed: false
 	};
 	let revision = 0, busy = false;
 	let runtime, notification;
 	const idle = () => {
-		if (state.disposed) throw new require_notification.DocumentDisposedError();
-		if (busy || require_notification.accessOf(runtime).projectionLocks) throw new require_notification.DocumentReentrancyError();
+		if (state.disposed) throw new require_access.DocumentDisposedError();
+		if (busy || require_access.accessOf(runtime).projectionLocks) throw new require_access.DocumentReentrancyError();
 	};
 	const writable = (intent) => {
 		idle();
@@ -1000,7 +912,7 @@ const createDocument = (input) => {
 					issues: [error.issue],
 					revision
 				};
-				if (intent.kind === "update" && error instanceof require_notification.TransactionRejected) return {
+				if (intent.kind === "update" && error instanceof require_access.TransactionRejected) return {
 					status: "rejected",
 					issues: error.issues,
 					revision
@@ -1033,7 +945,7 @@ const createDocument = (input) => {
 				kind: "update",
 				source
 			}, options?.history ?? true, (session) => {
-				value = run(require_scope.createAccess({
+				value = run(require_access.createAccess({
 					state,
 					session
 				}));
@@ -1059,15 +971,15 @@ const createDocument = (input) => {
 			}, source !== "remote", (session) => session.replace([], value));
 		},
 		snapshot: () => {
-			if (state.disposed) throw new require_notification.DocumentDisposedError();
-			return require_scope.copyValue(input.schema, state.document);
+			if (state.disposed) throw new require_access.DocumentDisposedError();
+			return require_access.copyValue(input.schema, state.document);
 		},
 		subscribe: ((pick, listener) => {
-			if (state.disposed) throw new require_notification.DocumentDisposedError();
+			if (state.disposed) throw new require_access.DocumentDisposedError();
 			if (!listener) return require_notification.subscribeRoot(notification, pick);
 			const picks = Array.isArray(pick) ? pick : [pick];
 			if (!picks.length) throw new TypeError("Expected at least one subscription path.");
-			return require_notification.subscribeTargets(notification, picks.map((p) => compilePath(input.schema, "value", p)), listener);
+			return require_notification.subscribeTargets(notification, picks.map((p) => require_advanced.compilePath(input.schema, "value", p)), listener);
 		}),
 		history: history.api,
 		dispose: () => {
@@ -1082,7 +994,7 @@ const createDocument = (input) => {
 			}
 		}
 	};
-	require_notification.bindRuntimeAccess(runtime, state);
+	require_access.bindRuntimeAccess(runtime, state);
 	require_driver.bindRuntimeDriver(runtime);
 	notification = require_notification.createNotification(runtime);
 	require_notification.bindDocumentReadable(history.api, runtime);
@@ -1096,2059 +1008,1227 @@ const asReadable = (runtime) => {
 		revision: runtime.revision,
 		subscribe: runtime.subscribe
 	};
-	require_notification.bindRuntimeAccess(readable, require_notification.accessOf(runtime));
+	require_access.bindRuntimeAccess(readable, require_access.accessOf(runtime));
 	require_notification.shareNotification(runtime, readable);
 	return Object.freeze(readable);
 };
 //#endregion
 //#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";
-	}
-};
+const read = (runtime, selector) => require_access.readWith(runtime, selector);
 //#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.");
+//#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: () => {
+				require_advanced.assertScope(active);
+				if (staged !== unset) return staged;
+				return initialize ? void 0 : initialized ? value : void 0;
+			},
+			output: Object.freeze({ set: (candidate) => {
+				require_advanced.assertScope(active);
+				staged = candidate;
+			} })
+		};
 	};
-	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;
+	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;
 		}
-		heap[i] = node;
+		const candidate = staged;
+		changed = !initialized || !isEqual(value, candidate);
+		next = changed ? candidate : value;
+		reset = nextReset;
+		return changed;
 	};
-	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;
+	return {
+		begin,
+		seal,
+		context: (active, cause) => {
+			require_advanced.assertScope(active);
+			return Object.freeze({
+				kind: "value",
+				value: next,
+				revision,
+				reset,
+				cause
+			});
+		},
+		current: (check) => {
+			check();
+			return value;
+		},
+		revision: () => revision,
+		reset: () => reset,
+		publish: () => {
+			if (changed && initialized) revision++;
+			if (changed) value = next;
+			initialized = true;
+		},
+		emit: (call) => {
+			require_issue.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 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);
+};
+//#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 require_advanced.ProjectionDisposedError();
+		if (processor.fault) throw processor.fault;
 	};
-	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
-		phase = "compute";
-		lock(true);
-		try {
-			pending.forEach((source) => {
-				if (source.shouldSettle?.() ?? true) 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);
+	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;
+					},
+					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);
+					},
+					emit: state.emit,
+					clear: state.clear,
+					release: state.release
 				}
+			};
+		}
+		const state = require_advanced.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
 			}
-			completed.forEach((node) => node.publish());
-		} finally {
-			lock(false);
-			phase = "idle";
+		};
+	});
+	const begin = (active, initialize) => Object.freeze(bound.map((entry) => {
+		if (entry.kind === "value") {
+			const evaluation = entry.state.begin(active, initialize);
+			return Object.freeze({
+				kind: "value",
+				...evaluation
+			});
 		}
+		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);
 	};
-	const flush = () => {
-		if (disposed || depth) return [];
-		if (pending.size || completed.length) require_issue.profile.projection("flushes");
-		phase = "notify";
-		lock(true);
-		const reportFailures = [];
+	const run = (reset, runCause) => {
+		cause = runCause;
+		let active = true;
 		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);
+			const scopeActive = () => active;
+			const sources = Object.freeze(dependencies.map((output) => output.context(scopeActive)));
+			let outputs = begin(scopeActive, reset);
+			if (!instance) instance = definition.create();
+			require_issue.profile.materialized[reset ? "rebuilt" : "updated"]();
+			let result = instance.evaluate({
+				reset,
+				cause: runCause,
+				sources,
+				outputs
+			});
+			require_advanced.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
+				});
+				require_advanced.assertSynchronous(result);
+				if (result?.kind === "rebuild") throw new TypeError("Reset projection processor cannot rebuild again.");
+				return seal(true);
 			}
-			return Object.freeze([...errors.map((error) => Object.freeze({
-				phase: error.phase === "listener" ? "listener" : "processor",
-				error
-			})), ...reportFailures.map((error) => Object.freeze({
-				phase: "listener",
-				error
-			}))]);
+			return seal(reset);
 		} 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";
+			active = false;
 		}
 	};
-	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;
-			}
+	const order = scheduler.order();
+	processor = {
+		kind: "processor",
+		order,
+		name: definition.name ? `${definition.name} (${order})` : `projection-${order}`,
+		dependencies: Object.freeze([...dependencies]),
+		outputs: Object.freeze(bound.map((entry) => entry.output)),
+		fault: void 0,
+		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;
 		}
 	};
-	return {
-		assertActive,
-		assertIdle,
-		capture,
-		settle,
-		flush,
-		run,
-		records,
-		guards,
-		cleanups,
-		get active() {
-			return !disposed;
+	try {
+		scheduler.initialize(() => {
+			const invalid = dependencies.find((output) => output.owner.fault || output.owner.disposed);
+			if (invalid) throw invalid.owner.fault ?? new require_advanced.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/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);
 		},
-		register(handle, record) {
-			assertIdle();
-			records.set(handle, record);
-			projectionHandles.add(handle);
+		has: (key) => {
+			trackKey(key);
+			return source.has(key);
 		},
-		unregisterSource(handle) {
-			const record = records.get(handle);
-			if (record) {
-				assertIdle();
-				if (record.consumers.size) throw new Error("Projection source is still used by a node.");
-				record.disposed = true;
-				pending.delete(record);
-				record.clear();
-				records.delete(handle);
-			}
+		get size() {
+			trackStructure();
+			return source.size;
 		},
-		releaseNode(handle) {
-			assertIdle();
-			const node = records.get(handle);
-			if (!node || !nodes.has(node)) throw new Error("Unknown projection node.");
-			if (node.consumers.size) throw new Error("Projection node is still used by another node.");
-			node.disposed = true;
-			node.sources.forEach((source) => source.consumers.delete(node));
-			node.release();
-			node.clear();
-			nodes.delete(node);
-			records.delete(handle);
-			pending.delete(node);
-			queued.delete(node);
-			emissions.delete(node);
+		keys: () => {
+			trackStructure();
+			return source.keys();
 		},
-		source(handle) {
-			assertActive();
-			const source = records.get(handle);
-			if (!source || source.disposed) throw new Error("Unknown, disposed, or foreign projection source.");
-			return source;
+		values: () => {
+			trackAll();
+			return source.values();
 		},
-		addNode(node) {
-			nodes.add(node);
-			node.sources.forEach((source) => source.consumers.add(node));
+		entries: () => {
+			trackAll();
+			return source.entries();
 		},
-		order: () => sequence++,
-		initialize(run) {
-			assertIdle();
-			phase = "compute";
-			lock(true);
-			try {
-				return run();
-			} finally {
-				lock(false);
-				phase = "idle";
-			}
+		forEach: (callback, thisArg) => {
+			trackAll();
+			source.forEach((value, key) => callback.call(thisArg, value, key, view));
 		},
-		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.");
+		[Symbol.iterator]: () => {
+			trackAll();
+			return source[Symbol.iterator]();
 		}
 	};
+	return Object.freeze(view);
 };
-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 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 assertScope = (active) => {
-	if (!active()) throw new Error("Projection reader or writer is no longer active.");
+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 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 = (current) => {
+		const candidate = current ?? source.current();
+		previousCollection = isMapLike(candidate) ? candidate : void 0;
+	};
+	const evaluate = () => {
+		const tracker = {
+			keys: /* @__PURE__ */ new Set(),
+			all: false,
+			structure: false
+		};
+		const previousTracker = activeTracker;
+		activeTracker = tracker;
+		let current;
+		let next;
+		try {
+			current = source.current();
+			next = selector(isMapLike(current) ? trackedMap(current) : current);
+		} finally {
+			activeTracker = previousTracker;
+		}
+		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;
+		}
+		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 = require_advanced.collectionChangeBetween(previousCollection, current);
+				previousCollection = current;
+				if (!change) {
+					sourceRevision = source.revision();
+					return;
+				}
+			} else previousCollection = void 0;
+		}
+		if (!selectionAffects(selection, change)) {
+			sourceRevision = source.revision();
+			updateCollectionSnapshot();
+			return;
+		}
+		if (evaluate()) Array.from(listeners).forEach((listener) => listener());
+	};
+	const installSource = () => {
+		if (!unsubscribeSource) unsubscribeSource = source.subscribe(onProjectionChange);
+	};
+	return Object.freeze({
+		current: ensureCurrent,
+		revision: () => {
+			ensureCurrent();
+			return selectedRevision;
+		},
+		subscribe: (listener) => {
+			ensureCurrent();
+			listeners.add(listener);
+			installSource();
+			return () => {
+				listeners.delete(listener);
+				if (!listeners.size && unsubscribeSource) {
+					unsubscribeSource();
+					unsubscribeSource = void 0;
+				}
+			};
+		}
+	});
 };
 //#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 = require_notification.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 (!require_notification.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) => require_notification.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 ? require_issue.nodeAt(state.schema, collection.address, state.document) : void 0;
-			const entryNode = collectionNode && (collectionNode.kind === "map" || collectionNode.kind === "table") ? collectionNode.value : void 0;
-			const sameEntry = (left, right) => entryNode ? require_scope.equalValue(entryNode, left, right) : Object.is(left, right);
-			const record = {
-				consumers: /* @__PURE__ */ new Set(),
-				disposed: false,
-				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 ? require_scope.collectionAccess(context, collection.address) : void 0;
-					const snapshots = collection ? /* @__PURE__ */ new Map() : void 0;
-					const read = collection ? Object.freeze({
-						get: (key) => {
-							assertScope(active);
-							if (!snapshots.has(key)) snapshots.set(key, require_scope.snapshot(rawRead.get(key)));
-							return snapshots.get(key);
-						},
-						has: (key) => {
-							assertScope(active);
-							return rawRead.has(key);
-						},
-						ids: () => {
-							assertScope(active);
-							return rawRead.ids();
-						}
-					}) : require_scope.createAccess(context);
-					if (!collection) return Object.freeze({
-						kind: "document",
-						read,
-						revision: runtime.revision(),
-						reset: record.reset(),
-						cause: batch?.cause
-					});
-					if (!baseline) {
-						const collectionRead = read;
-						baseline = /* @__PURE__ */ new Map();
-						baselineIds = Object.freeze(require_scope.collectionAccess(context, collection.address).ids().slice());
-						for (const key of baselineIds) {
-							const value = collectionRead.get(key);
-							baseline.set(key, value);
-						}
-					}
-					const changed = [...keys];
-					const added = [];
-					const updated = [];
-					const removed = [];
-					const next = new Map(baseline);
-					const collectionRead = read;
-					for (const key of changed) {
-						const beforePresent = baseline.has(key);
-						const afterPresent = collectionRead.has(key);
-						const afterValue = afterPresent ? collectionRead.get(key) : void 0;
-						if (!beforePresent && afterPresent) {
-							added.push({
-								key,
-								after: afterValue
-							});
-							next.set(key, afterValue);
-						} else if (beforePresent && !afterPresent) {
-							removed.push({
-								key,
-								before: baseline.get(key)
-							});
-							next.delete(key);
-						} else if (beforePresent && afterPresent) {
-							const beforeValue = baseline.get(key);
-							if (!sameEntry(beforeValue, afterValue)) updated.push({
-								key,
-								before: beforeValue,
-								after: afterValue
-							});
-							next.set(key, afterValue);
-						}
-					}
-					const ids = record.reset() || orderChanged ? Object.freeze([...collectionRead.ids()]) : baselineIds;
-					if (record.reset()) {
-						next.clear();
-						for (const key of ids) {
-							const value = collectionRead.get(key);
-							next.set(key, value);
-						}
-					}
-					let order;
-					if (orderChanged) {
-						const beforeKeys = new Set(baselineIds);
-						const afterKeys = new Set(ids);
-						const beforeCommon = baselineIds.filter((key) => afterKeys.has(key));
-						const afterCommon = ids.filter((key) => beforeKeys.has(key));
-						if (beforeCommon.some((key, index) => afterCommon[index] !== key)) order = {
-							before: Object.freeze([...baselineIds]),
-							after: ids
-						};
-					}
-					const change = record.reset() ? Object.freeze({ kind: "reset" }) : added.length || updated.length || removed.length || order ? Object.freeze({
-						kind: "incremental",
-						added: Object.freeze(added),
-						updated: Object.freeze(updated),
-						removed: Object.freeze(removed),
-						...order ? { order: Object.freeze(order) } : {}
-					}) : void 0;
-					nextBaseline = next;
-					nextBaselineIds = ids;
-					return Object.freeze({
-						kind: "collection",
-						read,
-						change,
-						revision: runtime.revision(),
-						cause: batch?.cause
-					});
-				}
-			};
-			const handle = collection ? { 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 = require_notification.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;
-			},
-			context: (active) => {
-				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();
-			}
-		};
-	};
-	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) => {
-				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();
-			}
-		};
-	};
-	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;
-	};
-	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);
-					},
-					has: (key) => {
-						assertScope(active);
-						return read.has(key);
-					},
-					ids: () => {
-						assertScope(active);
-						return read.ids();
-					}
-				});
-				return Object.freeze({
-					kind: "collection",
-					read: currentRead,
-					change,
-					revision,
-					cause
-				});
-			}
-		};
-		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;
-			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();
-			});
-		} catch (error) {
-			unsubscribe?.();
-			scheduler.unregisterSource(handle);
-			throw error;
-		}
-		scheduler.cleanups.add(() => unsubscribe?.());
-		externalSources.set(port, handle);
-		return handle;
+const sourceError = (source, cause) => new require_advanced.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 require_advanced.ProjectionDisposedError();
+		if (boundary.fault) throw boundary.fault;
 	};
-	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 output = {
+		kind: "value",
+		get owner() {
+			return boundary;
 		},
-		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)
-				});
-				return input.source;
-			}
-			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 = require_notification.documentReadableOwner(readable);
-				if (owner) {
-					document(owner);
-					detach = require_notification.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;
+		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);
 		},
-		assertCollection: (handle) => {
-			scheduler.source(handle);
-			if (!isCollectionSource(handle)) throw new Error("map requires a collection source.");
-		}
+		emit: state.emit,
+		clear: state.clear,
+		release: state.release
 	};
-};
-//#endregion
-//#region core/src/projection/node.ts
-const createNode = (scheduler, spec, behavior) => {
-	scheduler.assertIdle();
-	const entries = Object.entries(spec.sources).map(([key, handle]) => [key, scheduler.source(handle)]);
-	const order = scheduler.order();
-	const node = {
-		...behavior,
-		publish: () => {
-			if (node.fault) behavior.clear();
-			else behavior.publish();
-		},
-		order,
-		name: spec.name ? `${spec.name} (${order})` : `projection-${order}`,
-		sources: entries.map(([, source]) => source),
-		consumers: /* @__PURE__ */ new Set(),
-		disposed: false,
+	boundary = {
+		kind: "source",
+		name,
+		outputs: Object.freeze([output]),
 		fault: void 0,
-		evaluate: (build) => {
+		disposed: false,
+		pendingCause: () => pendingCause,
+		recovering: () => recovering,
+		prepare: (cause) => {
+			contextCause = cause;
 			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);
+				state.begin(() => active, pendingReset).output.set(latest);
+				const changed = state.seal(pendingReset, equality);
+				recovering = false;
+				return {
+					changed,
+					force: pendingReset
+				};
 			} finally {
 				active = false;
 			}
-		}
-	};
-	scheduler.initialize(() => {
-		const invalid = node.sources.find((source) => source.fault || source.disposed);
-		if (invalid) throw invalid.fault ?? new ProjectionDisposedError();
-		node.evaluate(true);
-		node.publish();
-		node.clear();
-	});
-	const check = () => {
-		if (node.disposed || !scheduler.active) throw new ProjectionDisposedError();
-		if (node.fault) throw node.fault;
-	};
-	return {
-		node,
-		check,
-		install(handle) {
-			scheduler.register(handle, node);
-			scheduler.addNode(node);
-		}
-	};
-};
-//#endregion
-//#region core/src/projection/value.ts
-const createValue = (scheduler, spec, options) => {
-	let instance;
-	let value;
-	let next;
-	let initialized = false;
-	let revision = 0;
-	let changed = false;
-	let reset = false;
-	let cause;
-	const listeners = /* @__PURE__ */ new Set();
-	const owner = createNode(scheduler, spec, {
-		evaluate: (sources, build) => {
-			cause = Object.values(sources).find((value) => value && typeof value === "object" && "cause" in value && value.cause !== void 0)?.cause ?? scheduler.batchContext()?.cause;
-			let candidate;
-			if (build || !instance) {
-				require_issue.profile.materialized.rebuilt();
-				instance = void 0;
-				const built = spec.build(sources);
-				assertSynchronous(built);
-				instance = built;
-				candidate = built.value;
-			} else {
-				require_issue.profile.materialized.updated();
-				const result = instance.update(sources);
-				assertSynchronous(result);
-				if (result.kind === "rebuild") {
-					instance = void 0;
-					const built = spec.build(sources);
-					assertSynchronous(built);
-					instance = built;
-					candidate = built.value;
-					build = true;
-				} else candidate = result.kind === "changed" ? result.value : value;
-			}
-			changed = !initialized || !(options?.isEqual ?? Object.is)(value, candidate);
-			next = changed ? candidate : value;
-			reset = build;
-			return changed;
-		},
-		context: (active) => {
-			assertScope(active);
-			return Object.freeze({
-				kind: "value",
-				value: next,
-				revision: revision + (changed ? 1 : 0),
-				reset,
-				cause
-			});
-		},
-		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			if (changed && initialized) revision++;
-			value = next;
-			initialized = true;
-		},
-		emit: (call) => {
-			require_issue.profile.materialized.notification();
-			Array.from(listeners).forEach((listener) => call(listener));
 		},
+		publish: state.publish,
 		clear: () => {
-			next = value;
-			changed = false;
-			reset = false;
-			cause = void 0;
+			state.clear();
+			pendingReset = false;
+			pendingCause = void 0;
+			contextCause = void 0;
+			recovering = false;
 		},
 		release: () => {
-			listeners.clear();
-			instance = void 0;
-			value = next = void 0;
+			cleanup?.();
+			cleanup = void 0;
+			state.release();
+			output.consumers.clear();
 		}
-	});
-	const handle = Object.freeze({
-		kind: "value",
-		current: () => {
-			owner.check();
-			return value;
-		},
-		revision: () => {
-			owner.check();
-			return revision;
-		},
-		subscribe: (listener) => {
-			owner.check();
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		}
-	});
-	owner.install(handle);
-	return handle;
-};
-//#endregion
-//#region core/src/projection/collection.ts
-const height = (node) => node?.height ?? 0;
-const makeTreeNode = (key, value, left, right) => Object.freeze({
-	key,
-	value,
-	left,
-	right,
-	height: Math.max(height(left), height(right)) + 1
-});
-const rotateLeft = (node) => {
-	const right = node.right;
-	return makeTreeNode(right.key, right.value, makeTreeNode(node.key, node.value, node.left, right.left), right.right);
-};
-const rotateRight = (node) => {
-	const left = node.left;
-	return makeTreeNode(left.key, left.value, left.left, makeTreeNode(node.key, node.value, left.right, node.right));
-};
-const rebalance = (node) => {
-	const balance = height(node.left) - height(node.right);
-	if (balance > 1) {
-		if (height(node.left.left) < height(node.left.right)) return rotateRight(makeTreeNode(node.key, node.value, rotateLeft(node.left), node.right));
-		return rotateRight(node);
-	}
-	if (balance < -1) {
-		if (height(node.right.right) < height(node.right.left)) return rotateLeft(makeTreeNode(node.key, node.value, node.left, rotateRight(node.right)));
-		return rotateLeft(node);
-	}
-	return node;
-};
-const treeSet = (node, key, value) => {
-	if (!node) return makeTreeNode(key, value);
-	if (key === node.key) return makeTreeNode(key, value, node.left, node.right);
-	if (key < node.key) return rebalance(makeTreeNode(node.key, node.value, treeSet(node.left, key, value), node.right));
-	return rebalance(makeTreeNode(node.key, node.value, node.left, treeSet(node.right, key, value)));
-};
-const treeMin = (node) => node.left ? treeMin(node.left) : node;
-const treeRemove = (node, key) => {
-	if (!node) return void 0;
-	if (key < node.key) return rebalance(makeTreeNode(node.key, node.value, treeRemove(node.left, key), node.right));
-	if (key > node.key) return rebalance(makeTreeNode(node.key, node.value, node.left, treeRemove(node.right, key)));
-	if (!node.left) return node.right;
-	if (!node.right) return node.left;
-	const next = treeMin(node.right);
-	return rebalance(makeTreeNode(next.key, next.value, node.left, treeRemove(node.right, next.key)));
-};
-const treeGet = (node, key) => {
-	let current = node;
-	while (current) {
-		if (key === current.key) return current.value;
-		current = key < current.key ? current.left : current.right;
-	}
-};
-const treeHas = (node, key) => {
-	let current = node;
-	while (current) {
-		if (key === current.key) return true;
-		current = key < current.key ? current.left : current.right;
-	}
-	return false;
-};
-const treeFromSorted = (entries, start = 0, end = entries.length) => {
-	if (start >= end) return void 0;
-	const middle = start + end >> 1;
-	const [key, value] = entries[middle];
-	return makeTreeNode(key, value, treeFromSorted(entries, start, middle), treeFromSorted(entries, middle + 1, end));
-};
-const createCollection = (scheduler, spec) => {
-	const values = /* @__PURE__ */ new Map();
-	let ids = Object.freeze([]);
-	let staged = /* @__PURE__ */ new Map();
-	let nextIds = ids;
-	let change;
-	let instance;
-	let initialized = false;
-	let reset = false;
-	let revision = 0;
-	let publishedRoot;
-	let cause;
-	const listeners = /* @__PURE__ */ new Set();
-	const changedKeys = /* @__PURE__ */ new Set();
-	let orderChanged = false;
-	const readPublished = (root, publishedIds) => Object.freeze({
-		get: (key) => {
-			owner.check();
-			return treeGet(root, key);
-		},
-		has: (key) => {
-			owner.check();
-			return treeHas(root, key);
-		},
-		ids: () => {
-			owner.check();
-			return publishedIds;
-		}
-	});
-	const hasNext = (key) => staged.has(key) ? staged.get(key).present : values.has(key);
-	const getNext = (key) => {
-		const entry = staged.get(key);
-		return entry ? entry.present ? entry.value : void 0 : values.get(key);
 	};
-	const owner = createNode(scheduler, spec, {
-		evaluate: (sources, build, active) => {
-			cause = Object.values(sources).find((value) => value && typeof value === "object" && "cause" in value && value.cause !== void 0)?.cause ?? scheduler.batchContext()?.cause;
-			staged = /* @__PURE__ */ new Map();
-			nextIds = ids;
-			change = void 0;
-			changedKeys.clear();
-			let explicitOrder;
-			let cleared = false;
-			const nextHas = (key) => staged.has(key) ? staged.get(key).present : !cleared && values.has(key);
-			const nextGet = (key) => {
-				const entry = staged.get(key);
-				return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : values.get(key);
-			};
-			const deriveIds = () => {
-				const result = cleared ? [] : ids.filter(nextHas);
-				for (const [key, entry] of staged) if (entry.present && (cleared || !values.has(key))) result.push(key);
-				return result;
-			};
-			const read = (next) => ({
-				get: (key) => {
-					assertScope(active);
-					return next ? nextGet(key) : values.get(key);
-				},
-				has: (key) => {
-					assertScope(active);
-					return next ? nextHas(key) : values.has(key);
-				},
-				ids: () => {
-					assertScope(active);
-					return next ? Object.freeze(explicitOrder ? explicitOrder.slice() : deriveIds()) : ids;
-				}
-			});
-			const input = {
-				sources,
-				previous: read(false),
-				next: read(true),
-				output: {
-					set: (key, value) => {
-						assertScope(active);
-						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-						staged.set(key, {
-							present: true,
-							value
-						});
-					},
-					remove: (key) => {
-						assertScope(active);
-						staged.set(key, { present: false });
-					},
-					order: (order) => {
-						assertScope(active);
-						explicitOrder = order.slice();
-					}
-				}
-			};
-			if (build || !instance) {
-				require_issue.profile.materialized.rebuilt();
-				instance = void 0;
-				cleared = true;
-				const built = spec.build(input);
-				assertSynchronous(built);
-				instance = built;
-			} else {
-				require_issue.profile.materialized.updated();
-				const result = instance.update(input);
-				assertSynchronous(result);
-				if (result?.kind === "rebuild") {
-					staged.clear();
-					cleared = true;
-					explicitOrder = void 0;
-					instance = void 0;
-					const built = spec.build(input);
-					assertSynchronous(built);
-					instance = built;
-					build = true;
-				}
-			}
-			if (cleared) {
-				for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
-			}
-			const added = /* @__PURE__ */ new Set();
-			const removed = /* @__PURE__ */ new Set();
-			const updated = /* @__PURE__ */ new Set();
-			require_issue.profile.projection("touchedKeys", staged.size);
-			for (const [key, entry] of staged) {
-				const existed = values.has(key);
-				if (entry.present) if (!existed) added.add(key);
-				else if (!(spec.isEqual ?? Object.is)(values.get(key), entry.value)) updated.add(key);
-				else staged.delete(key);
-				else if (existed) removed.add(key);
-				else staged.delete(key);
-			}
-			if (explicitOrder || added.size || removed.size) {
-				const order = explicitOrder ?? [...ids.filter((key) => !removed.has(key)), ...added];
-				if (new Set(order).size !== order.length || order.length !== values.size + added.size - removed.size || order.some((key) => !hasNext(key))) throw new TypeError("Projection order must contain every key exactly once.");
-				nextIds = ids.length === order.length && ids.every((key, i) => key === order[i]) ? ids : Object.freeze(order.slice());
-			}
-			orderChanged = nextIds !== ids;
-			[
-				...added,
-				...removed,
-				...updated
-			].forEach((key) => changedKeys.add(key));
-			require_issue.profile.projection("changedKeys", changedKeys.size);
-			const addedEntries = [];
-			const updatedEntries = [];
-			const removedEntries = [];
-			for (const key of changedKeys) {
-				const beforePresent = values.has(key);
-				const afterPresent = hasNext(key);
-				if (beforePresent === afterPresent) {
-					if (!beforePresent) continue;
-					if ((spec.isEqual ?? Object.is)(values.get(key), getNext(key))) continue;
-				}
-				if (!beforePresent) addedEntries.push({
-					key,
-					after: getNext(key)
-				});
-				else if (!afterPresent) removedEntries.push({
-					key,
-					before: values.get(key)
-				});
-				else updatedEntries.push({
-					key,
-					before: values.get(key),
-					after: getNext(key)
-				});
-			}
-			if (build) change = Object.freeze({ kind: "reset" });
-			else if (addedEntries.length || updatedEntries.length || removedEntries.length || orderChanged) {
-				let commonOrderChanged = false;
-				if (orderChanged) {
-					const before = ids.filter((key) => !removed.has(key));
-					const after = nextIds.filter((key) => !added.has(key));
-					commonOrderChanged = before.some((key, i) => after[i] !== key);
-				}
-				change = Object.freeze({
-					kind: "incremental",
-					added: Object.freeze(addedEntries),
-					updated: Object.freeze(updatedEntries),
-					removed: Object.freeze(removedEntries),
-					...commonOrderChanged ? { order: Object.freeze({
-						before: Object.freeze([...ids]),
-						after: Object.freeze([...nextIds])
-					}) } : {}
-				});
-			}
-			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);
-		},
-		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) {
-				if (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)));
-		},
-		clear: () => {
-			staged.clear();
-			nextIds = ids;
-			change = void 0;
-			reset = false;
-			changedKeys.clear();
-			cause = void 0;
-			orderChanged = false;
-		},
-		release: () => {
-			values.clear();
-			staged.clear();
-			publishedRoot = void 0;
-			listeners.clear();
-			ids = nextIds = Object.freeze([]);
-			instance = void 0;
+	scheduler.initialize(() => {
+		let active = true;
+		try {
+			state.begin(() => active, true).output.set(initial);
+			state.seal(true, equality);
+			state.publish();
+			state.clear();
+		} finally {
+			active = false;
 		}
 	});
-	const handle = {
-		kind: "collection",
-		current: () => {
-			owner.check();
-			return readPublished(publishedRoot, ids);
-		},
-		revision: () => {
-			owner.check();
-			return revision;
-		},
-		subscribe: (listener) => {
-			owner.check();
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		}
-	};
-	owner.install(handle);
-	return Object.freeze(handle);
-};
-//#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();
-				require_issue.profile.collectionView.idsScanned(ids.length);
-				for (const id of ids) {
-					require_issue.profile.collectionView.mapped();
-					output.set(id, calculate(id, read.get(id)));
-				}
-				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) {
-						require_issue.profile.collectionView.mapped();
-						output.set(entry.key, calculate(entry.key, entry.after));
-					}
-					for (const entry of change.updated) {
-						require_issue.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();
-						require_issue.profile.collectionView.idsScanned(ids.length);
-						output.order(ids);
-					}
-				} };
-			}
-		});
+	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 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),
-		map,
-		batch: scheduler.batch,
-		assertIdle: scheduler.assertIdle,
-		releaseNode: scheduler.releaseNode,
-		releaseInput: scheduler.unregisterSource,
-		dispose: () => {
-			try {
-				scheduler.dispose();
-			} finally {
-				if (!scheduler.active) sources.dispose();
-			}
-		}
+	const fail = (cause) => {
+		boundary.fault = sourceError(boundary, cause);
+		recovering = false;
+		scheduler.capture(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));
+	return {
+		producer: boundary,
+		output,
+		setLatest: (value) => {
+			latest = value;
 		},
-		[Symbol.iterator]: () => {
-			trackAll();
-			return source[Symbol.iterator]();
+		mark,
+		fail,
+		detach: (next) => {
+			cleanup = next;
 		}
 	};
-	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 createCollectionBoundary = (scheduler, name, readLatest, equality) => {
+	const state = require_advanced.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 require_advanced.ProjectionDisposedError();
+		if (boundary.fault) throw boundary.fault;
 	};
-	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]();
+	const output = {
+		kind: "collection",
+		get owner() {
+			return boundary;
 		},
-		values: () => {
-			trackAll();
-			return values();
+		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 = (change) => listener(change);
+			state.subscribe(wrapped);
+			return () => state.unsubscribe(wrapped);
 		},
-		entries: () => {
-			trackAll();
-			return entries();
+		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 = require_advanced.stageCollectionRead(state, readLatest(() => active), () => active, {
+					reset: pendingReset,
+					...fullScan ? {} : { candidates },
+					orderMayChange,
+					isEqual: equality
+				});
+				recovering = false;
+				return {
+					changed,
+					force: pendingReset
+				};
+			} finally {
+				active = false;
+			}
 		},
-		forEach: (callback, thisArg) => {
-			trackAll();
-			for (const key of ids) callback.call(thisArg, read.get(key), key, view);
+		publish: state.publish,
+		clear: () => {
+			state.clear();
+			pendingReset = false;
+			pendingCause = void 0;
+			contextCause = void 0;
+			recovering = false;
+			fullScan = false;
+			orderMayChange = false;
+			candidates.clear();
 		},
-		[Symbol.iterator]: () => {
-			trackAll();
-			return entries();
+		release: () => {
+			cleanup?.();
+			cleanup = void 0;
+			state.release();
+			output.consumers.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)
+	scheduler.initialize(() => {
+		let active = true;
+		try {
+			require_advanced.stageCollectionRead(state, readLatest(() => active), () => active, {
+				reset: true,
+				isEqual: equality
+			});
+			state.publish();
+			state.clear();
+		} finally {
+			active = false;
+		}
 	});
-	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;
+	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 {
-		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()])
-		}) } : {}
+		producer: boundary,
+		output,
+		mark,
+		fail,
+		detach: (next) => {
+			cleanup = next;
+		}
 	};
 };
-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 require_scope.snapshot(event.read);
-	if ("kind" in event && event.kind === "collection") return mapView(event.read);
-	return event;
-};
-const sourceOf = (instance) => instance;
-const createProjectionRuntime = (options) => {
-	const runtime = createProjectionGraph({ onError: options?.onError ?? (() => void 0) });
-	const materialized = /* @__PURE__ */ new WeakMap();
-	let disposed = false;
-	const scopes = /* @__PURE__ */ new Set();
-	const 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 ProjectionDisposedError();
-		}
-		const old = materialized.get(projection);
-		if (old) return old.node;
-		const definition = require_advanced.definitionOf(projection);
-		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
+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 = require_access.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();
 				};
-				instance = runtime.map(source.source, (_key, value) => value);
-				break;
+			},
+			close() {
+				if (closed) return;
+				closed = true;
+				detach();
+				bindings.clear();
+				scheduler.guards.delete(guard);
+				documents.delete(state);
 			}
-			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;
+		};
+		detach = require_notification.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();
 			}
-			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
-							})
-						})
-					});
+		});
+		documents.set(state, connection);
+		return connection;
+	};
+	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();
 				}
-				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: require_scope.snapshot(values.document.read),
-							update: (next) => ({
-								kind: "changed",
-								value: require_scope.snapshot(next.document.read)
-							})
-						})
+		};
+	};
+	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", () => require_advanced.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) => {
+							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
+							});
+							operations.push({
+								kind: "set",
+								key,
+								value
+							});
+						},
+						remove: (key) => {
+							require_advanced.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 {
+						require_advanced.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
 					});
-					break;
+					scheduler.run();
 				}
-				const state = require_notification.accessOf(definition.document);
+			}
+		};
+	};
+	const documentValue = (definition) => {
+		if (definition.source.kind !== "document-value") throw new Error("Invalid document value source.");
+		const { document, selector } = definition.source;
+		const state = require_access.accessOf(document);
+		const address = selector?.address ?? Object.freeze([]);
+		const schemaNode = () => require_issue.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 require_access.copyValue(node, selector ? require_issue.read(state.document, address, state.schema) : state.document);
+		};
+		const boundary = createValueBoundary(scheduler, "document source", read(), (left, right) => {
+			const node = schemaNode();
+			return node ? require_access.equalValue(node, left, right) : Object.is(left, right);
+		});
+		const remove = documentConnection(document).add({
+			matches: (commit) => !selector || affectsTarget(commit.impact, selector),
+			capture: (commit) => {
 				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: require_issue.read(require_scope.snapshot(state.document), address, state.schema),
-							update: () => ({
-								kind: "changed",
-								value: require_issue.read(require_scope.snapshot(state.document), address, state.schema)
-							})
-						})
-					});
+					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 = require_access.accessOf(document);
+		const read = (active) => {
+			if (state.disposed) throw new Error("Document has been disposed.");
+			const raw = require_access.collectionAccess({
+				state,
+				active
+			}, selector.address);
+			const snapshots = /* @__PURE__ */ new Map();
+			return Object.freeze({
+				get: (key) => {
+					require_advanced.assertScope(active);
+					if (!snapshots.has(key)) snapshots.set(key, require_access.snapshot(raw.get(key)));
+					return snapshots.get(key);
+				},
+				has: (key) => {
+					require_advanced.assertScope(active);
+					return raw.has(key);
+				},
+				ids: () => {
+					require_advanced.assertScope(active);
+					return raw.ids();
 				}
-				break;
+			});
+		};
+		const collectionNode = () => require_issue.nodeAt(state.schema, selector.address, state.document);
+		const boundary = createCollectionBoundary(scheduler, "document collection source", read, (left, right) => {
+			const node = collectionNode();
+			const entry = node && require_advanced.collectionEntryNode(node);
+			return entry ? require_access.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);
 			}
-			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;
+		};
+		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 = require_notification.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.")));
+				}
+			});
+			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;
+	};
+	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);
 			}
-			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;
+		};
+		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);
+				}
+			};
+			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;
 			}
-			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
+			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 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 {
+				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();
 				});
-				break;
+			} catch (cause) {
+				created.close();
+				throw cause;
 			}
+			connection = created;
+			externalCollections.set(source, connection);
 		}
-		const record = write ? {
-			node: instance,
-			...write
-		} : {
-			kind: "projection",
-			node: instance
-		};
-		materialized.set(projection, record);
-		if (owner) owner.materialized.push(projection);
-		return instance;
+		connection.members.add(boundary);
+		boundary.detach(() => {
+			connection.members.delete(boundary);
+			if (!connection.members.size) connection.close();
+		});
+		return boundary;
+	};
+	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);
+			}
+		},
+		dispose() {
+			documents.forEach((connection) => connection.close());
+			readables.forEach((connection) => connection.close());
+			documents.clear();
+			readables.clear();
+		}
+	};
+};
+//#endregion
+//#region core/src/projection/runtime.ts
+const createProjectionRuntime = (options) => {
+	const scheduler = require_advanced.createScheduler(options?.onError ?? (() => void 0));
+	const sources = createSourceRegistry(scheduler);
+	const materialized = /* @__PURE__ */ new WeakMap();
+	const publicViews = /* @__PURE__ */ new WeakMap();
+	const scopes = /* @__PURE__ */ new Set();
+	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 require_advanced.ProjectionDisposedError();
+	};
+	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) => require_advanced.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
+			});
+		}
+		materialized.set(definition, result);
+		rememberScoped(definition, requester);
+		return result;
 	};
-	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 resolveOutput = (projection, requester) => {
+		const ref = require_advanced.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 require_advanced.ProjectionDisposedError();
+		if (output.owner.fault) throw output.owner.fault;
+	};
+	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 = require_advanced.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 = require_advanced.snapshotCollectionView(require_advanced.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 = require_advanced.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: [],
@@ -3156,25 +2236,27 @@ const createProjectionRuntime = (options) => {
 		};
 		scopes.add(state);
 		const assertActive = () => {
-			if (!state.active) throw new ProjectionDisposedError();
+			if (!state.active) throw new require_advanced.ProjectionDisposedError();
+			scheduler.assertActive();
 		};
 		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) : [];
-			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;
+			return require_advanced.ownProjection(projection, state);
+		};
+		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 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 scopedIncremental = Object.assign((dependencies, processor) => own(require_advanced.incremental(dependencies, processor)), { collection: (dependencies, processor) => own(require_advanced.incremental.collection(dependencies, processor)) });
+		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: () => {
@@ -3202,7 +2284,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,
@@ -3222,34 +2304,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 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());
@@ -3257,35 +2324,35 @@ const createProjectionRuntime = (options) => {
 				scope.materialized.length = 0;
 			}
 			scopes.clear();
-			runtime.dispose();
+			sources.dispose();
+			scheduler.dispose();
 		}
-	};
-	return Object.freeze(store);
+	});
 };
 //#endregion
-exports.DocumentDisposedError = require_notification.DocumentDisposedError;
-exports.DocumentReentrancyError = require_notification.DocumentReentrancyError;
-exports.ParseError = require_scope.ParseError;
-exports.ProjectionDisposedError = ProjectionDisposedError;
-exports.ProjectionError = ProjectionError;
-exports.TransactionRejected = require_notification.TransactionRejected;
+exports.DocumentDisposedError = require_access.DocumentDisposedError;
+exports.DocumentReentrancyError = require_access.DocumentReentrancyError;
+exports.ParseError = require_access.ParseError;
+exports.ProjectionDisposedError = require_advanced.ProjectionDisposedError;
+exports.ProjectionError = require_advanced.ProjectionError;
+exports.TransactionRejected = require_access.TransactionRejected;
 exports.asReadable = asReadable;
 exports.createDocument = createDocument;
 exports.createProjectionRuntime = createProjectionRuntime;
 exports.derive = require_advanced.derive;
-exports.field = field;
+exports.field = require_advanced.field;
 exports.input = require_advanced.input;
-exports.list = list;
-exports.map = map;
-exports.object = object;
+exports.list = require_advanced.list;
+exports.map = require_advanced.map;
+exports.object = require_advanced.object;
 exports.observe = require_advanced.observe;
-exports.optional = optional;
-exports.parse = require_scope.parse;
+exports.optional = require_advanced.optional;
+exports.parse = require_access.parse;
 exports.read = read;
-exports.replace = require_scope.replace;
-exports.snapshot = require_scope.snapshot;
-exports.table = table;
-exports.tree = tree;
-exports.variant = variant;
+exports.replace = require_access.replace;
+exports.snapshot = require_access.snapshot;
+exports.table = require_advanced.table;
+exports.tree = require_advanced.tree;
+exports.variant = require_advanced.variant;
 
 //# sourceMappingURL=index.cjs.map