doxum 0.1.32 → 0.1.34

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as ownProjections, C as snapshotDependencyValue, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as createCollectionChange, a as createKeyedDependencyRuntime, b as sameArray, c as assertScope, d as ProjectionDisposedError, f as ProjectionError, g as collectionHasStructuralChange, h as collectionChangeTouchesKey, i as compileKeyedDependencies, j as producerOf, k as isProjection, l as assertSynchronous, m as collectionChangeIntersects, n as keyedAbsent, o as outputKind, r as assertKeyedProjection, s as createKeyRelation, t as createKeyedTransform, u as createScheduler, v as diffCollection, w as collectionView, x as snapshotArray, y as iterableMatchesArray } from "./transform-gOtqcdHe.js";
+import { A as ownProjections, C as snapshotDependencyValue, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform-RghG_Qxs.js";
 import { n as isPlainObject, r as isRecord, t as installOwn } from "./record-B2yRhYsc.js";
 import { c as AddressIndex, d as invalidValue, f as children, g as validate, h as parent, i as contextOf, l as MutationRejected, m as is, o as decodeChanges, p as contains$1, r as bindContext, s as sealChanges, t as assertRuntimeWritable, u as fail } from "./driver-B7RR-VfX.js";
 //#region core/src/schema/model.ts
@@ -2774,6 +2774,108 @@ const isExternalSource = (source) => {
 	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
 };
 //#endregion
+//#region core/src/projection/keyed/flat-map.ts
+function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
+	const name = "derive.keyed.flatMap";
+	assertKeyedProjection(source, `${name} source`);
+	const specs = typeof dependenciesOrSelect === "function" ? void 0 : dependenciesOrSelect;
+	const select = specs === void 0 ? dependenciesOrSelect : selectOrEquality;
+	const equality = specs === void 0 ? selectOrEquality : maybeEquality;
+	if (typeof select !== "function") throw new TypeError(`${name} requires a selector.`);
+	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${name} equality must be a function.`);
+	const compiled = compileKeyedDependencies(source, specs, name);
+	const [projection] = defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: equality ?? Object.is
+		}],
+		name,
+		create: () => {
+			const dependencies = createKeyedDependencyRuntime(compiled);
+			const childrenByParent = /* @__PURE__ */ new Map();
+			const ownerByOutput = /* @__PURE__ */ new Map();
+			return {
+				evaluate: (evaluation) => {
+					const driver = evaluation.sources[0];
+					const output = evaluation.outputs[0];
+					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error(`${name} requires collection input and output.`);
+					const plan = collectKeyedInvalidation(driver, evaluation.sources, dependencies, evaluation.reset);
+					dependencies.prepare(evaluation.sources, plan.rebuild);
+					if (plan.rebuild) {
+						dependencies.clearBindings();
+						childrenByParent.clear();
+						ownerByOutput.clear();
+					}
+					const replaced = new Set(plan.keys);
+					for (const entry of plan.removed) replaced.add(entry.key);
+					const proposals = /* @__PURE__ */ new Map();
+					const segments = /* @__PURE__ */ new Map();
+					let orderDirty = plan.structural;
+					for (const parent of replaced) {
+						if (!driver.read.has(parent)) continue;
+						const value = driver.read.get(parent);
+						const entries = select(value, parent, dependencies.resolve(value, parent, evaluation.sources));
+						assertSynchronous(entries);
+						if (!Array.isArray(entries)) throw new TypeError(`${name} selector must return an array of entries.`);
+						const keys = [];
+						for (const entry of entries) {
+							if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError(`${name} entries must be [string key, value] tuples.`);
+							const [key, child] = entry;
+							const owner = ownerByOutput.get(key);
+							if (proposals.has(key) || owner !== void 0 && !replaced.has(owner)) throw new TypeError(`${name} duplicate key ${JSON.stringify(key)}.`);
+							proposals.set(key, {
+								parent,
+								value: child
+							});
+							keys.push(key);
+						}
+						const previous = childrenByParent.get(parent);
+						const unchanged = previous ? sameArray(previous, keys) : keys.length === 0;
+						if (!unchanged) orderDirty = true;
+						if (keys.length) segments.set(parent, unchanged && previous ? previous : Object.freeze(keys));
+					}
+					if (plan.rebuild) {
+						if (!evaluation.reset) {
+							for (const key of output.previous.ids()) if (!proposals.has(key)) output.output.remove(key);
+						}
+					} else for (const parent of replaced) {
+						const previous = childrenByParent.get(parent);
+						if (previous) for (const key of previous) {
+							if (!proposals.has(key)) output.output.remove(key);
+							ownerByOutput.delete(key);
+						}
+						childrenByParent.delete(parent);
+					}
+					for (const entry of plan.removed) dependencies.remove(entry.key);
+					for (const [parent, keys] of segments) childrenByParent.set(parent, keys);
+					for (const [key, entry] of proposals) {
+						ownerByOutput.set(key, entry.parent);
+						output.output.set(key, entry.value);
+					}
+					if (orderDirty) {
+						const order = [];
+						const parents = driver.read.ids();
+						for (const parent of parents) {
+							const keys = childrenByParent.get(parent);
+							if (keys) for (const key of keys) order.push(key);
+						}
+						profile.collectionView.idsScanned(parents.length + order.length);
+						output.output.order(order);
+					}
+					dependencies.remember(evaluation.sources);
+				},
+				release: () => {
+					childrenByParent.clear();
+					ownerByOutput.clear();
+					dependencies.release();
+				}
+			};
+		}
+	});
+	return projection;
+}
+//#endregion
 //#region core/src/projection/keyed/composition.ts
 const assertEquality = (equality, role) => {
 	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${role} equality must be a function.`);
@@ -3440,44 +3542,26 @@ function createKeyedGroupBy(source, dependenciesOrSelector, maybeSelector) {
 					const driver = evaluation.sources[0];
 					const output = evaluation.outputs[0];
 					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error("derive.keyed.groupBy requires collection input and output.");
-					dependencies.prepare(evaluation.sources, evaluation.reset);
-					if (evaluation.reset) {
+					const invalidation = collectKeyedInvalidation(driver, evaluation.sources, dependencies, evaluation.reset);
+					dependencies.prepare(evaluation.sources, invalidation.rebuild);
+					if (invalidation.rebuild) {
 						rebuild(driver, evaluation.sources, output);
 						dependencies.remember(evaluation.sources);
 						return;
 					}
-					const dirty = /* @__PURE__ */ new Set();
 					const affected = /* @__PURE__ */ new Set();
-					let all = false;
-					let structural = false;
-					let orderDirty = false;
-					if (dependencies.driverChanged(driver)) {
-						const change = driver.change;
-						if (!change || change.kind === "reset") {
-							rebuild(driver, evaluation.sources, output);
-							dependencies.remember(evaluation.sources);
-							return;
-						} else {
-							for (const entry of change.removed) {
-								const changed = removeSourceKey(entry.key, affected);
-								orderDirty ||= changed;
-								dependencies.remove(entry.key);
-								dirty.delete(entry.key);
-							}
-							for (const entry of change.added) dirty.add(entry.key);
-							for (const entry of change.updated) dirty.add(entry.key);
-							structural = Boolean(change.added.length || change.removed.length || change.order);
-							orderDirty ||= structural;
-							if (structural) refreshOrderIndex(driver);
-						}
+					let orderDirty = invalidation.structural;
+					for (const entry of invalidation.removed) {
+						const changed = removeSourceKey(entry.key, affected);
+						orderDirty ||= changed;
+						dependencies.remove(entry.key);
 					}
-					all ||= dependencies.collectInvalidated(evaluation.sources, dirty);
-					if (all) for (const key of driver.read.ids()) dirty.add(key);
-					for (const key of dirty) {
+					if (invalidation.structural) refreshOrderIndex(driver);
+					for (const key of invalidation.keys) {
 						const changed = selectGroups(driver, evaluation.sources, key, affected);
 						orderDirty ||= changed;
 					}
-					if (structural) markAllGroups(output, affected);
+					if (invalidation.structural) markAllGroups(output, affected);
 					publishAffected(affected, output, orderDirty);
 					dependencies.remember(evaluation.sources);
 				},
@@ -3501,6 +3585,7 @@ const keyedDerive = Object.assign(createKeyedDerive, {
 	from: createKeyedFrom,
 	merge: createKeyedMerge,
 	groupBy: createKeyedGroupBy,
+	flatMap: createKeyedFlatMap,
 	singleton: createKeyedSingleton,
 	subset: createKeyedSubset,
 	filter: createKeyedFilter,
@@ -3532,6 +3617,104 @@ function createValueDerive(dependencies, compute, equality = Object.is) {
 }
 const derive = Object.assign(createValueDerive, { keyed: keyedDerive });
 //#endregion
+//#region core/src/projection/collection/changes.ts
+/** Net transitions for one consumer's unconsumed interval; bounded by touched keys. */
+const createCollectionChanges = () => {
+	let first;
+	let beforeOrder = [];
+	let afterOrder = [];
+	let cached;
+	let valid = false;
+	let transitions;
+	const merge = (change) => {
+		const write = (key, before, after) => {
+			const previous = transitions.get(key);
+			const initial = previous?.before ?? before;
+			if (initial.present === after.present && (!initial.present || after.present && Object.is(initial.value, after.value))) transitions.delete(key);
+			else if (previous) previous.after = after;
+			else transitions.set(key, {
+				before,
+				after
+			});
+		};
+		for (const entry of change.added) write(entry.key, { present: false }, {
+			present: true,
+			value: entry.after
+		});
+		for (const entry of change.updated) write(entry.key, {
+			present: true,
+			value: entry.before
+		}, {
+			present: true,
+			value: entry.after
+		});
+		for (const entry of change.removed) write(entry.key, {
+			present: true,
+			value: entry.before
+		}, { present: false });
+	};
+	return {
+		add(change, before, after) {
+			valid = false;
+			afterOrder = after;
+			if (!first) {
+				first = change;
+				beforeOrder = before;
+				return;
+			}
+			if (first.kind === "reset") return;
+			if (change.kind === "reset") {
+				first = change;
+				transitions = void 0;
+				return;
+			}
+			if (!transitions) {
+				transitions = /* @__PURE__ */ new Map();
+				merge(first);
+			}
+			merge(change);
+		},
+		current() {
+			if (!transitions) return first;
+			if (valid) return cached;
+			const added = [];
+			const updated = [];
+			const removed = [];
+			for (const [key, { before, after }] of transitions) if (!before.present) {
+				if (after.present) added.push({
+					key,
+					after: after.value
+				});
+			} else if (!after.present) removed.push({
+				key,
+				before: before.value
+			});
+			else if (!Object.is(before.value, after.value)) updated.push({
+				key,
+				before: before.value,
+				after: after.value
+			});
+			cached = createCollectionChange({
+				added,
+				updated,
+				removed,
+				beforeOrder,
+				afterOrder
+			});
+			valid = true;
+			return cached;
+		},
+		reset: () => first?.kind === "reset",
+		clear() {
+			first = void 0;
+			cached = void 0;
+			valid = false;
+			transitions = void 0;
+			beforeOrder = afterOrder = [];
+		}
+	};
+};
+//#endregion
 //#region core/src/projection/collection/index.ts
 const height = (node) => node?.height ?? 0;
 const node = (key, value, left, right) => {
@@ -3622,11 +3805,11 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 	}
 };
 //#endregion
-//#region core/src/projection/output/collection.ts
-const createPublishedCollection = () => {
-	const values = /* @__PURE__ */ new Map();
-	let ids = Object.freeze([]);
-	let index = PersistentKeyedIndex.empty();
+//#region core/src/projection/collection/state.ts
+const createCollectionState = (initial) => {
+	const values = new Map(initial);
+	let ids = Object.freeze([...values.keys()]);
+	let index;
 	return {
 		get: (key) => values.get(key),
 		has: (key) => values.has(key),
@@ -3634,7 +3817,7 @@ const createPublishedCollection = () => {
 		size: () => values.size,
 		ids: () => ids,
 		read: (check) => {
-			const snapshotIndex = index;
+			const snapshotIndex = index ??= PersistentKeyedIndex.from(values);
 			const snapshotIds = ids;
 			return Object.freeze({
 				get: (key) => {
@@ -3651,13 +3834,13 @@ const createPublishedCollection = () => {
 				}
 			});
 		},
-		publish: (staged, nextIds, reset) => {
+		install: (staged, nextIds, reset) => {
 			if (reset) {
 				values.clear();
 				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
-				index = PersistentKeyedIndex.from(values);
+				if (index) index = PersistentKeyedIndex.from(values);
 			} else for (const [key, entry] of staged) {
-				index = entry.present ? index.set(key, entry.value) : index.remove(key);
+				if (index) index = entry.present ? index.set(key, entry.value) : index.remove(key);
 				if (entry.present) values.set(key, entry.value);
 				else values.delete(key);
 			}
@@ -3666,15 +3849,17 @@ const createPublishedCollection = () => {
 		release: () => {
 			values.clear();
 			ids = Object.freeze([]);
-			index = PersistentKeyedIndex.empty();
+			index = void 0;
 		}
 	};
 };
-/** Owns staged keyed intent, exact transitions and published collection state. */
+//#endregion
+//#region core/src/projection/output/collection.ts
+/** Owns staged keyed intent, exact transitions and current collection state. */
 const createCollectionOutput = (binding) => {
-	const published = createPublishedCollection();
+	const currentState = createCollectionState();
 	const staged = /* @__PURE__ */ new Map();
-	let nextIds = published.ids();
+	let nextIds = currentState.ids();
 	let change;
 	let initialized = false;
 	let reset = false;
@@ -3682,23 +3867,26 @@ const createCollectionOutput = (binding) => {
 	let explicitOrder;
 	let cleared = false;
 	const listeners = /* @__PURE__ */ new Set();
-	const consumers = /* @__PURE__ */ new Set();
-	const hasNext = (key) => staged.has(key) ? staged.get(key).present : !cleared && published.has(key);
+	const consumers = /* @__PURE__ */ new Map();
+	const notifications = createCollectionChanges();
+	const observers = /* @__PURE__ */ new Set();
+	let baseline;
+	const hasNext = (key) => staged.has(key) ? staged.get(key).present : !cleared && currentState.has(key);
 	const getNext = (key) => {
 		const entry = staged.get(key);
-		return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : published.get(key);
+		return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : currentState.get(key);
 	};
 	const deriveIds = () => {
 		const result = [];
 		if (!cleared) {
-			for (const key of published.ids()) if (hasNext(key)) result.push(key);
+			for (const key of currentState.ids()) if (hasNext(key)) result.push(key);
 		}
-		for (const [key, entry] of staged) if (entry.present && (cleared || !published.has(key))) result.push(key);
+		for (const [key, entry] of staged) if (entry.present && (cleared || !currentState.has(key))) result.push(key);
 		return result;
 	};
 	const begin = (active, initialize) => {
 		staged.clear();
-		nextIds = published.ids();
+		nextIds = currentState.ids();
 		change = void 0;
 		explicitOrder = void 0;
 		cleared = initialize;
@@ -3706,15 +3894,15 @@ const createCollectionOutput = (binding) => {
 		const read = (next) => ({
 			get: (key) => {
 				assertScope(active);
-				return next ? getNext(key) : published.get(key);
+				return next ? getNext(key) : currentState.get(key);
 			},
 			has: (key) => {
 				assertScope(active);
-				return next ? hasNext(key) : published.has(key);
+				return next ? hasNext(key) : currentState.has(key);
 			},
 			ids: () => {
 				assertScope(active);
-				if (!next) return published.ids();
+				if (!next) return currentState.ids();
 				if (explicitOrder) return explicitOrder;
 				return Object.freeze(deriveIds());
 			}
@@ -3744,15 +3932,28 @@ const createCollectionOutput = (binding) => {
 	};
 	const seal = (nextReset, isEqual) => {
 		if (cleared) {
-			for (const key of published.keys()) if (!staged.has(key)) staged.set(key, { present: false });
+			for (const key of currentState.keys()) if (!staged.has(key)) staged.set(key, { present: false });
 		}
 		profile.projection("touchedKeys", staged.size);
 		const addedEntries = [];
 		const updatedEntries = [];
 		const removedEntries = [];
-		for (const [key, entry] of staged) {
-			const existed = published.has(key);
+		for (const [key, original] of staged) {
+			let entry = original;
+			const existed = currentState.has(key);
 			if (entry.present) {
+				if (baseline?.has(key) && (!existed || !Object.is(currentState.get(key), baseline.get(key)))) {
+					const before = baseline.get(key);
+					const equivalent = isEqual(before, entry.value);
+					assertSynchronous(equivalent);
+					if (equivalent) {
+						entry = {
+							present: true,
+							value: before
+						};
+						staged.set(key, entry);
+					}
+				}
 				if (!existed) {
 					addedEntries.push({
 						key,
@@ -3760,24 +3961,30 @@ const createCollectionOutput = (binding) => {
 					});
 					continue;
 				}
-				const before = published.get(key);
-				if (!isEqual(before, entry.value)) updatedEntries.push({
+				const before = currentState.get(key);
+				const equal = isEqual(before, entry.value);
+				assertSynchronous(equal);
+				if (!equal) updatedEntries.push({
 					key,
 					before,
 					after: entry.value
 				});
-				else if (!nextReset) staged.delete(key);
+				else if (nextReset) staged.set(key, {
+					present: true,
+					value: before
+				});
+				else staged.delete(key);
 				continue;
 			}
 			if (existed) removedEntries.push({
 				key,
-				before: published.get(key)
+				before: currentState.get(key)
 			});
 			else staged.delete(key);
 		}
-		const ids = published.ids();
+		const ids = currentState.ids();
 		if (explicitOrder) {
-			const expectedLength = published.size() + addedEntries.length - removedEntries.length;
+			const expectedLength = currentState.size() + addedEntries.length - removedEntries.length;
 			const seen = /* @__PURE__ */ new Set();
 			for (const key of explicitOrder) {
 				if (seen.has(key) || !hasNext(key)) throw new TypeError("Projection order must contain every key exactly once.");
@@ -3786,7 +3993,7 @@ const createCollectionOutput = (binding) => {
 			if (seen.size !== expectedLength) throw new TypeError("Projection order must contain every key exactly once.");
 			nextIds = sameArray(ids, explicitOrder) ? ids : explicitOrder;
 		} else if (addedEntries.length || removedEntries.length) {
-			const order = new Array(published.size() + addedEntries.length - removedEntries.length);
+			const order = new Array(currentState.size() + addedEntries.length - removedEntries.length);
 			let index = 0;
 			for (const key of ids) if (hasNext(key)) order[index++] = key;
 			for (const entry of addedEntries) order[index++] = entry.key;
@@ -3803,7 +4010,7 @@ const createCollectionOutput = (binding) => {
 		reset = nextReset;
 		return change !== void 0;
 	};
-	const context = (active, cause) => Object.freeze({
+	const context = (active, cause, consumer) => Object.freeze({
 		kind: "collection",
 		read: {
 			get: (key) => {
@@ -3819,9 +4026,9 @@ const createCollectionOutput = (binding) => {
 				return nextIds;
 			}
 		},
-		change,
+		change: consumer ? consumers.get(consumer)?.current() : change,
 		revision,
-		reset,
+		reset: consumer ? consumers.get(consumer)?.reset() ?? false : reset,
 		cause
 	});
 	return {
@@ -3831,35 +4038,59 @@ const createCollectionOutput = (binding) => {
 		},
 		begin,
 		seal,
-		context: (active) => context(active, binding.cause()),
-		current: () => published.read(binding.check),
+		context: (active, consumer) => context(active, binding.cause(), consumer),
+		acknowledge: (consumer) => consumers.get(consumer)?.clear(),
+		pending: (consumer) => consumers.get(consumer)?.current() !== void 0,
+		baseline: () => baseline ?? currentState.read(binding.check),
+		current: () => currentState.read(binding.check),
 		revision: () => revision,
-		reset: () => reset,
+		reset: (consumer) => consumer ? consumers.get(consumer)?.reset() ?? false : reset,
 		publish: () => {
-			if (change) published.publish(staged, nextIds, change.kind === "reset");
-			if (change && initialized) revision++;
+			if (change) {
+				if (initialized) {
+					baseline ??= currentState.read(() => void 0);
+					notifications.add(change, currentState.ids(), nextIds);
+					for (const pending of consumers.values()) pending.add(change, currentState.ids(), nextIds);
+					revision++;
+				}
+				currentState.install(staged, nextIds, change.kind === "reset");
+			}
 			initialized = true;
 		},
-		emit: (call) => {
-			Array.from(listeners).forEach((listener) => call(listener, change));
+		emit: (call, force) => {
+			const net = notifications.current();
+			for (const listener of [...observers]) call(listener, net);
+			if (net || force) for (const listener of [...listeners]) call(listener, net);
+		},
+		finish: () => {
+			baseline = void 0;
+			notifications.clear();
+		},
+		observe: (listener) => {
+			binding.check();
+			observers.add(listener);
+			return () => observers.delete(listener);
 		},
 		hasConsumers: () => consumers.size > 0,
-		forEachConsumer: (run) => consumers.forEach(run),
-		attachConsumer: (consumer) => consumers.add(consumer),
+		forEachConsumer: (run) => consumers.forEach((_pending, consumer) => run(consumer)),
+		attachConsumer: (consumer) => consumers.set(consumer, createCollectionChanges()),
 		detachConsumer: (consumer) => consumers.delete(consumer),
 		clear: () => {
 			staged.clear();
-			nextIds = published.ids();
+			nextIds = currentState.ids();
 			change = void 0;
 			reset = false;
 			explicitOrder = void 0;
 			cleared = false;
 		},
 		release: () => {
-			published.release();
+			currentState.release();
 			staged.clear();
 			listeners.clear();
 			consumers.clear();
+			observers.clear();
+			baseline = void 0;
+			notifications.clear();
 			nextIds = Object.freeze([]);
 			change = void 0;
 			initialized = false;
@@ -3878,7 +4109,7 @@ const createCollectionOutput = (binding) => {
 //#endregion
 //#region core/src/projection/output/value.ts
 const unset = Symbol("projection-value-unset");
-/** Owns staged and published state for one scalar Projection output. */
+/** Owns staged and current state for one scalar Projection output. */
 const createValueOutput = (binding) => {
 	let value;
 	let staged = unset;
@@ -3888,7 +4119,10 @@ const createValueOutput = (binding) => {
 	let changed = false;
 	let reset = false;
 	const listeners = /* @__PURE__ */ new Set();
-	const consumers = /* @__PURE__ */ new Set();
+	const consumers = /* @__PURE__ */ new Map();
+	const observers = /* @__PURE__ */ new Set();
+	let baseline = unset;
+	let resetRevision = -1;
 	const begin = (active, initialize) => {
 		staged = unset;
 		next = value;
@@ -3915,8 +4149,15 @@ const createValueOutput = (binding) => {
 			next = value;
 			return false;
 		}
-		const candidate = staged;
-		changed = !initialized || !isEqual(value, candidate);
+		let candidate = staged;
+		if (baseline !== unset && !Object.is(value, baseline)) {
+			const equivalent = isEqual(baseline, candidate);
+			assertSynchronous(equivalent);
+			if (equivalent) candidate = baseline;
+		}
+		const equal = initialized ? isEqual(value, candidate) : false;
+		assertSynchronous(equal);
+		changed = !equal;
 		next = changed ? candidate : value;
 		reset = nextReset;
 		return changed;
@@ -3928,13 +4169,13 @@ const createValueOutput = (binding) => {
 		},
 		begin,
 		seal,
-		context: (active) => {
+		context: (active, consumer) => {
 			assertScope(active);
 			return Object.freeze({
 				kind: "value",
 				value: next,
 				revision,
-				reset,
+				reset: consumer ? (consumers.get(consumer)?.revision ?? -1) < resetRevision : reset,
 				cause: binding.cause()
 			});
 		},
@@ -3943,19 +4184,48 @@ const createValueOutput = (binding) => {
 			return value;
 		},
 		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			if (changed && initialized) revision++;
+		reset: (consumer) => consumer ? (consumers.get(consumer)?.revision ?? -1) < resetRevision : reset,
+		acknowledge: (consumer) => {
+			if (consumers.has(consumer)) consumers.set(consumer, {
+				revision,
+				value
+			});
+		},
+		pending: (consumer) => {
+			const previous = consumers.get(consumer);
+			return !previous || previous.revision < resetRevision || !Object.is(previous.value, value);
+		},
+		baseline: () => baseline === unset ? value : baseline,
+		publish: (forceReset) => {
+			if (initialized && (changed || forceReset)) {
+				if (baseline === unset) baseline = value;
+				revision++;
+				if (reset) resetRevision = revision;
+			}
 			if (changed) value = next;
 			initialized = true;
 		},
-		emit: (call) => {
-			profile.materialized.notification();
-			Array.from(listeners).forEach((listener) => call(listener, void 0));
+		emit: (call, force) => {
+			for (const listener of [...observers]) call(listener, void 0);
+			if (force || baseline !== unset && !Object.is(baseline, value)) {
+				profile.materialized.notification();
+				for (const listener of [...listeners]) call(listener, void 0);
+			}
+		},
+		finish: () => {
+			baseline = unset;
+		},
+		observe: (listener) => {
+			binding.check();
+			observers.add(listener);
+			return () => observers.delete(listener);
 		},
 		hasConsumers: () => consumers.size > 0,
-		forEachConsumer: (run) => consumers.forEach(run),
-		attachConsumer: (consumer) => consumers.add(consumer),
+		forEachConsumer: (run) => consumers.forEach((_revision, consumer) => run(consumer)),
+		attachConsumer: (consumer) => consumers.set(consumer, {
+			revision,
+			value
+		}),
 		detachConsumer: (consumer) => consumers.delete(consumer),
 		clear: () => {
 			staged = unset;
@@ -3966,6 +4236,8 @@ const createValueOutput = (binding) => {
 		release: () => {
 			listeners.clear();
 			consumers.clear();
+			observers.clear();
+			baseline = unset;
 			staged = unset;
 			value = next = void 0;
 			initialized = false;
@@ -4036,7 +4308,7 @@ const createProcessor = (scheduler, definition, dependencies) => {
 		let active = true;
 		try {
 			const scopeActive = () => active;
-			const sources = Object.freeze(dependencies.map((output) => output.context(scopeActive)));
+			const sources = Object.freeze(dependencies.map((output) => output.context(scopeActive, processor)));
 			const outputs = begin(scopeActive, reset);
 			if (recreate && instance) {
 				instance.release?.();
@@ -4050,16 +4322,17 @@ const createProcessor = (scheduler, definition, dependencies) => {
 				sources,
 				outputs
 			}));
-			return seal(reset);
+			const changed = seal(reset);
+			dependencies.forEach((output) => output.acknowledge(processor));
+			return changed;
 		} finally {
 			active = false;
 		}
 	};
-	const order = scheduler.order();
+	const id = scheduler.nextId();
 	processor = {
 		kind: "processor",
-		order,
-		name: definition.name ? `${definition.name} (${order})` : `projection-${order}`,
+		name: definition.name ? `${definition.name} (${id})` : `projection-${id}`,
 		dependencies: Object.freeze([...dependencies]),
 		outputs: Object.freeze(bound.map((entry) => entry.state)),
 		fault: void 0,
@@ -4186,7 +4459,9 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 	let initialized = false;
 	let value;
 	let selectedRevision = 0;
+	let notified;
 	let sourceRevision = -1;
+	let notificationRevision = -1;
 	let selection = Object.freeze({
 		keys: /* @__PURE__ */ new Set(),
 		all: true,
@@ -4222,8 +4497,9 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 		});
 		const changed = !initialized || !equality(value, next);
 		if (changed) {
+			const candidate = unsubscribeSource && equality(notified, next) ? notified : next;
 			if (initialized) selectedRevision++;
-			value = next;
+			value = candidate;
 		}
 		selection = nextSelection;
 		initialized = true;
@@ -4233,31 +4509,44 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 	};
 	const ensureCurrent = () => {
 		const revision = source.revision();
-		if (!initialized || !unsubscribeSource && sourceRevision !== revision) evaluate();
-		return value;
-	};
-	const onProjectionChange = (incoming) => {
-		let change = incoming;
-		if (!change && previousCollection) {
+		if (!initialized) evaluate();
+		else if (sourceRevision !== revision) {
 			const current = source.current();
-			if (isMapLike(current)) {
-				change = diffCollection(previousCollection, current);
-				previousCollection = current;
-				if (!change) {
-					sourceRevision = source.revision();
-					return;
+			let affected = true;
+			if (previousCollection && isMapLike(current) && !selection.all) {
+				affected = selection.structure && !iterableMatchesArray(current.keys(), [...previousCollection.keys()]);
+				if (!affected) {
+					for (const key of selection.keys) if (previousCollection.has(key) !== current.has(key) || !Object.is(previousCollection.get(key), current.get(key))) {
+						affected = true;
+						break;
+					}
 				}
-			} else previousCollection = void 0;
+			}
+			if (affected) evaluate();
+			else {
+				sourceRevision = revision;
+				updateCollectionSnapshot(current);
+			}
 		}
-		if (!selectionAffects(selection, change)) {
+		return value;
+	};
+	const onProjectionChange = (incoming) => {
+		if (sourceRevision === notificationRevision && sourceRevision !== source.revision() && incoming && !selectionAffects(selection, incoming)) {
 			sourceRevision = source.revision();
 			updateCollectionSnapshot();
-			return;
+		} else ensureCurrent();
+		notificationRevision = sourceRevision;
+		if (!equality(notified, value)) {
+			notified = value;
+			notifyProjectionListeners(listeners, "Projection selector listeners failed.");
 		}
-		if (evaluate()) notifyProjectionListeners(listeners, "Projection selector listeners failed.");
 	};
 	const installSource = () => {
-		if (!unsubscribeSource) unsubscribeSource = source.subscribe(onProjectionChange);
+		if (!unsubscribeSource) {
+			notified = value;
+			notificationRevision = sourceRevision;
+			unsubscribeSource = source.observe(onProjectionChange);
+		}
 	};
 	return Object.freeze({
 		current: ensureCurrent,
@@ -4639,13 +4928,12 @@ const createValueBoundary = (scheduler, name, initial, equality, prepare, clearS
 				active = false;
 			}
 		},
-		publish: state.publish,
+		publish: () => state.publish(pendingReset),
 		clear: () => {
 			const failed = boundary.fault !== void 0;
 			state.clear();
 			pendingReset = false;
 			pendingCause = void 0;
-			contextCause = void 0;
 			recovering = false;
 			clearSource(failed);
 		},
@@ -4701,6 +4989,7 @@ const createValueBoundary = (scheduler, name, initial, equality, prepare, clearS
 	return {
 		producer: boundary,
 		output,
+		baseline: state.baseline,
 		mark,
 		fail,
 		detach: (next) => {
@@ -4720,7 +5009,7 @@ const stageCollectionRead = (state, read, active, options) => {
 		}
 		evaluation.output.order(ids);
 	} else {
-		const previous = state.current();
+		const previous = evaluation.previous;
 		let currentIds;
 		const ids = () => currentIds ??= read.ids();
 		if (options.candidates) for (const key of options.candidates) if (read.has(key)) {
@@ -4801,7 +5090,6 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 			state.clear();
 			pendingReset = false;
 			pendingCause = void 0;
-			contextCause = void 0;
 			recovering = false;
 			fullScan = false;
 			orderMayChange = false;
@@ -4854,7 +5142,11 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 		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;
+		if (boundary.fault) {
+			recovering = true;
+			fullScan = true;
+			orderMayChange = true;
+		}
 		scheduler.capture(boundary);
 	};
 	const fail = (cause) => {
@@ -4865,6 +5157,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 	return {
 		producer: boundary,
 		output,
+		baseline: state.baseline,
 		mark,
 		fail,
 		detach: (next) => {
@@ -5398,101 +5691,136 @@ const createExternalSourceRegistry = (scheduler, documents) => {
 //#region core/src/projection/source/input.ts
 const materializeInputSource = (scheduler, definition) => {
 	const source = definition.source;
+	if (source.kind !== "value-input" && source.kind !== "collection-input") throw new Error("Invalid projection input source.");
+	const equal = (previous, next) => {
+		const result = source.equality(previous, next);
+		assertSynchronous(result);
+		return result;
+	};
 	if (source.kind === "value-input") {
 		let latest = source.initial;
-		const boundary = createValueBoundary(scheduler, "projection input", source.initial, source.equality, () => latest, () => void 0);
+		const boundary = createValueBoundary(scheduler, "projection input", source.initial, Object.is, () => latest, () => void 0);
+		boundary.detach(() => {
+			latest = void 0;
+		});
 		return {
 			...boundary,
-			write: {
+			input: {
 				kind: "value",
 				set(value) {
-					scheduler.assertIdle();
-					latest = value;
+					const next = scheduler.acceptInput(() => {
+						if (equal(latest, value)) return latest;
+						if (source.equality === Object.is) return value;
+						const baseline = boundary.baseline();
+						return !Object.is(latest, baseline) && equal(baseline, value) ? baseline : value;
+					});
+					if (Object.is(latest, next)) return;
+					latest = next;
 					boundary.mark();
 					scheduler.run();
 				}
 			}
 		};
 	}
-	if (source.kind !== "collection-input") throw new Error("Invalid projection input source.");
-	const values = new Map(source.initial);
-	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => mapRead(values), definition.output.equality, () => void 0);
+	const values = createCollectionState(source.initial);
+	const latest = {
+		get: values.get,
+		has: values.has,
+		ids: values.ids
+	};
+	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => latest, Object.is, () => void 0);
+	boundary.detach(() => {
+		values.release();
+	});
 	return {
 		...boundary,
-		write: {
+		input: {
 			kind: "collection",
 			update(run) {
-				scheduler.assertIdle();
-				const staged = /* @__PURE__ */ new Map();
-				const operations = [];
-				let structural = false;
-				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 accepted = scheduler.acceptInput(() => {
+					const staged = /* @__PURE__ */ new Map();
+					const appended = /* @__PURE__ */ new Set();
+					let structural = false;
+					let active = true;
+					const has = (key) => {
 						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.");
-						const previous = staged.get(key);
-						structural ||= previous ? !previous.present : !values.has(key);
-						staged.set(key, {
-							present: true,
-							value
-						});
-						operations.push({
-							kind: "set",
-							key,
-							value
-						});
-					},
-					remove: (key) => {
-						assertScope(() => active);
-						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-						const previous = staged.get(key);
-						const present = previous ? previous.present : values.has(key);
-						structural ||= present;
-						staged.set(key, { present: false });
-						if (present) operations.push({
-							kind: "remove",
-							key
-						});
+					};
+					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);
+							return has(key);
+						},
+						set: (key, value) => {
+							assertScope(() => active);
+							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+							if (!has(key)) {
+								appended.add(key);
+								structural = true;
+							}
+							staged.set(key, {
+								present: true,
+								value
+							});
+						},
+						remove: (key) => {
+							assertScope(() => active);
+							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+							if (!has(key)) return;
+							appended.delete(key);
+							structural = true;
+							staged.set(key, { present: false });
+						}
+					});
+					try {
+						assertSynchronous(run(draft));
+					} finally {
+						active = false;
 					}
-				});
-				try {
-					assertSynchronous(run(draft));
-				} finally {
-					active = false;
-				}
-				if (!operations.length) return;
-				const candidates = /* @__PURE__ */ new Set();
-				const retained = /* @__PURE__ */ new Map();
-				for (const [key, entry] of staged) {
-					const existed = values.has(key);
-					if (entry.present) {
-						if (!existed) {
-							candidates.add(key);
+					const baseline = source.equality === Object.is ? void 0 : boundary.baseline();
+					for (const [key, entry] of staged) {
+						const existed = values.has(key);
+						if (!entry.present) {
+							if (!existed) staged.delete(key);
 							continue;
 						}
 						const previous = values.get(key);
-						if (source.equality(previous, entry.value)) retained.set(key, previous);
-						else candidates.add(key);
-					} else if (existed) candidates.add(key);
-				}
-				if (!candidates.size && !structural) return;
-				for (const operation of operations) if (operation.kind === "set") values.set(operation.key, operation.value);
-				else values.delete(operation.key);
-				for (const [key, value] of retained) if (values.has(key)) values.set(key, value);
+						let next = entry.value;
+						if (existed && equal(previous, next)) next = previous;
+						else if (baseline?.has(key)) {
+							const before = baseline.get(key);
+							if ((!existed || !Object.is(previous, before)) && equal(before, next)) next = before;
+						}
+						if (existed && Object.is(previous, next)) staged.delete(key);
+						else if (!Object.is(entry.value, next)) staged.set(key, {
+							present: true,
+							value: next
+						});
+					}
+					const beforeOrder = values.ids();
+					let order = beforeOrder;
+					if (structural) {
+						const next = [];
+						for (const key of beforeOrder) if (has(key) && !appended.has(key)) next.push(key);
+						for (const key of appended) next.push(key);
+						if (!sameArray(beforeOrder, next)) order = Object.freeze(next);
+					}
+					return {
+						staged,
+						order,
+						structural: order !== beforeOrder
+					};
+				});
+				if (!accepted.staged.size && !accepted.structural) return;
+				values.install(accepted.staged, accepted.order, false);
 				boundary.mark({
-					candidates,
-					orderMayChange: structural
+					candidates: accepted.staged.keys(),
+					orderMayChange: accepted.structural
 				});
 				scheduler.run();
 			}
@@ -5542,6 +5870,11 @@ const createProjectionItems = (source, checkOwner) => {
 	const waiting = /* @__PURE__ */ new Map();
 	let keysValue = Object.freeze([...source.current().keys()]);
 	let keysRevision = 0;
+	let notifiedKeys = keysValue;
+	let settledRevision = source.revision();
+	let keysSourceRevision = settledRevision;
+	const pendingKeys = /* @__PURE__ */ new Set();
+	const changedStates = /* @__PURE__ */ new Set();
 	const keyListeners = /* @__PURE__ */ new Set();
 	const check = () => {
 		if (disposed) throw new ProjectionDisposedError();
@@ -5577,7 +5910,7 @@ const createProjectionItems = (source, checkOwner) => {
 		}
 		state.value = value;
 		state.revision++;
-		notify(state.listeners);
+		changedStates.add(state);
 	};
 	const attachActive = (state, value) => {
 		if (state.ended) return;
@@ -5620,10 +5953,12 @@ const createProjectionItems = (source, checkOwner) => {
 		if (extra) for (const state of extra) publishState(state, value);
 	};
 	const updateKeys = (current) => {
+		const revision = source.revision();
+		if (keysSourceRevision === revision) return;
+		keysSourceRevision = revision;
 		if (iterableMatchesArray(current.keys(), keysValue)) return;
-		keysValue = Object.freeze([...current.keys()]);
+		keysValue = iterableMatchesArray(current.keys(), notifiedKeys) ? notifiedKeys : Object.freeze([...current.keys()]);
 		keysRevision++;
-		notify(keyListeners);
 	};
 	const createItem = (key, initial) => {
 		const state = {
@@ -5632,12 +5967,15 @@ const createProjectionItems = (source, checkOwner) => {
 			tracked: initial !== void 0,
 			ended: false,
 			value: initial?.value,
+			notified: initial?.value,
 			revision: 0
 		};
 		const ensureObserved = () => {
-			if (state.ended || state.tracked) return;
+			if (state.ended) return;
 			const current = source.current();
-			if (current.has(key)) attachActive(state, current.get(key));
+			if (source.revision() !== settledRevision) pendingKeys.add(key);
+			if (!state.tracked && current.has(key)) attachActive(state, current.get(key));
+			else if (state.tracked) publishState(state, current.get(key));
 		};
 		state.readable = Object.freeze({
 			current: () => {
@@ -5672,25 +6010,45 @@ const createProjectionItems = (source, checkOwner) => {
 	const onChange = (change) => {
 		check();
 		const current = source.current();
-		if (!change || change.kind === "reset") {
-			reconcile(current);
-			flushNotifications();
-			return;
+		if (change?.kind === "reset") reconcile(current);
+		else {
+			if (change) {
+				for (const entry of change.removed) terminateKey(entry.key);
+				for (const entry of change.added) activateWaiting(entry.key, entry.after);
+				for (const entry of change.updated) updateKey(entry.key, entry.after);
+				if (change.added.length || change.removed.length || change.order) updateKeys(current);
+			}
+			for (const key of pendingKeys) if (!current.has(key)) terminateKey(key);
+			else {
+				updateKey(key, current.get(key));
+				activateWaiting(key, current.get(key));
+			}
+		}
+		pendingKeys.clear();
+		settledRevision = source.revision();
+		for (const state of changedStates) if (!Object.is(state.notified, state.value)) {
+			state.notified = state.value;
+			notify(state.listeners);
+		}
+		changedStates.clear();
+		if (keysValue !== notifiedKeys) updateKeys(current);
+		else keysSourceRevision = settledRevision;
+		if (keysValue !== notifiedKeys) {
+			notifiedKeys = keysValue;
+			notify(keyListeners);
 		}
-		for (const entry of change.removed) terminateKey(entry.key);
-		for (const entry of change.added) activateWaiting(entry.key, entry.after);
-		for (const entry of change.updated) updateKey(entry.key, entry.after);
-		if (change.added.length || change.removed.length || change.order) updateKeys(current);
 		flushNotifications();
 	};
-	const stop = source.subscribe(onChange);
+	const stop = source.observe(onChange);
 	const keys = Object.freeze({
 		current: () => {
 			check();
+			updateKeys(source.current());
 			return keysValue;
 		},
 		revision: () => {
 			check();
+			updateKeys(source.current());
 			return keysRevision;
 		},
 		subscribe: (listener) => {
@@ -5704,11 +6062,12 @@ const createProjectionItems = (source, checkOwner) => {
 			keys,
 			get: (key) => {
 				check();
+				const current = source.current();
+				if (source.revision() !== settledRevision) pendingKeys.add(key);
 				const canonical = active.get(key);
 				if (canonical) return canonical.readable;
 				const pending = waiting.get(key)?.values().next().value;
 				if (pending) return pending.readable;
-				const current = source.current();
 				if (current.has(key)) {
 					const state = createItem(key, {
 						present: true,
@@ -5734,6 +6093,8 @@ const createProjectionItems = (source, checkOwner) => {
 			followers.clear();
 			waiting.clear();
 			notifications.length = 0;
+			pendingKeys.clear();
+			changedStates.clear();
 		}
 	};
 };
@@ -5789,11 +6150,12 @@ const createProjectionRuntime = (options) => {
 			result = Object.freeze({
 				record: source.producer,
 				outputs: Object.freeze([source.output]),
-				...source.write ? { write: source.write } : {}
+				...source.input ? { input: source.input } : {}
 			});
 		} else {
 			if (definition.owner === void 0 && definition.dependencies.some((dependency) => producerOf(dependency).owner !== void 0)) throw new TypeError("A root projection cannot depend on a scoped projection.");
 			const dependencies = definition.dependencies.map((dependency) => resolveOutput(dependency, requester));
+			dependencies.forEach((output) => scheduler.ensureCurrent(output));
 			const processor = createProcessor(scheduler, definition, Object.freeze(dependencies));
 			result = Object.freeze({
 				record: processor,
@@ -5817,6 +6179,7 @@ const createProjectionRuntime = (options) => {
 		if (output.owner.fault) throw output.owner.fault;
 	};
 	const publicCurrent = (output) => {
+		scheduler.ensureCurrent(output);
 		assertOutput(output);
 		const current = output.current();
 		const revision = output.revision();
@@ -5848,10 +6211,12 @@ const createProjectionRuntime = (options) => {
 			kind: output.kind,
 			current: () => readProjection(projection, requester),
 			revision: () => {
+				scheduler.ensureCurrent(output);
 				assertOutput(output);
 				return output.revision();
 			},
-			subscribe: output.subscribe
+			subscribe: output.subscribe,
+			observe: output.observe
 		});
 	};
 	const projectionItems = (projection, requester) => {
@@ -5862,6 +6227,7 @@ const createProjectionRuntime = (options) => {
 		if (existing) return existing.items;
 		const controller = createProjectionItems(readableSource(projection, requester), () => {
 			if (requester && !requester.active) throw new ProjectionDisposedError();
+			scheduler.ensureCurrent(output);
 			assertOutput(output);
 		});
 		registry.set(output, controller);
@@ -5874,16 +6240,18 @@ const createProjectionRuntime = (options) => {
 	function selectProjection(projection, selector, equality) {
 		return makeReadable(projection, selector, equality);
 	}
-	const inputWrite = (target, requester) => {
+	const inputAccess = (target, requester) => {
+		scheduler.assertIdle();
+		if (requester && !requester.active) throw new ProjectionDisposedError();
 		const ref = projectionRef(target);
 		if (ref.output !== 0 || ref.producer.kind !== "source") throw new TypeError("Projection is not an input.");
 		if (ref.producer.source.kind !== "value-input" && ref.producer.source.kind !== "collection-input") throw new TypeError("Projection is not an input.");
-		const write = materializeProducer(ref.producer, requester).write;
-		if (!write) throw new TypeError("Projection input is not writable.");
-		return write;
+		const access = materializeProducer(ref.producer, requester).input;
+		if (!access) throw new TypeError("Projection input is not writable.");
+		return access;
 	};
 	const updateInput = (target, valueOrRun, requester) => {
-		const write = inputWrite(target, requester);
+		const write = inputAccess(target, requester);
 		if (write.kind === "value") {
 			write.set(valueOrRun);
 			return;