doxum 0.1.33 → 0.1.35

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-CSPGdBe5.cjs");
+const require_transform = require("./transform-D45KWMzj.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 const require_driver = require("./driver-CN3dGxQI.cjs");
 //#region core/src/schema/model.ts
@@ -2775,6 +2775,12 @@ 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/entries.ts
+/** Shared entry boundary; membership and duplicate policy belong to each operation. */
+function assertKeyedEntry(entry, name) {
+	if (!Array.isArray(entry) || entry.length !== 2 || typeof entry[0] !== "string") throw new TypeError(`${name} entries must be [string key, value] tuples.`);
+}
+//#endregion
 //#region core/src/projection/keyed/flat-map.ts
 function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
 	const name = "derive.keyed.flatMap";
@@ -2821,7 +2827,7 @@ function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, mayb
 						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.`);
+							assertKeyedEntry(entry, name);
 							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)}.`);
@@ -2908,6 +2914,25 @@ const assertCollectionSources = (sources, expected) => {
 	if (sources.length !== expected) throw new Error("derive.keyed.merge resolved an invalid dependency count.");
 	for (const source of sources) if (source.kind !== "collection") throw new Error("derive.keyed.merge requires collection inputs.");
 };
+/** Complete ordered result reconciliation, without retaining a second member/value cache. */
+const stageKeyedSnapshot = (values, output, keyOf, valueOf, name) => {
+	const seen = /* @__PURE__ */ new Set();
+	const order = new Array(values.length);
+	const previous = output.previous.ids();
+	require_transform.profile.collectionView.idsScanned(values.length + previous.length);
+	for (let index = 0; index < values.length; index++) {
+		const value = values[index];
+		const key = keyOf(value);
+		require_transform.assertSynchronous(key);
+		if (typeof key !== "string") throw new TypeError(`${name} key selector must return a string.`);
+		if (seen.has(key)) throw new TypeError(`${name} duplicate key ${JSON.stringify(key)}.`);
+		seen.add(key);
+		order[index] = key;
+		output.output.set(key, valueOf(value));
+	}
+	for (const key of previous) if (!seen.has(key)) output.output.remove(key);
+	output.output.order(order);
+};
 function createKeyedFrom(source, keyOf, equality) {
 	if (typeof keyOf !== "function") throw new TypeError("derive.keyed.from requires a key selector.");
 	const outputEquality = assertEquality(equality, "derive.keyed.from");
@@ -2937,25 +2962,38 @@ function createKeyedFrom(source, keyOf, equality) {
 				values = scalar.value;
 			}
 			if (!values) throw new Error("derive.keyed.from has no source values.");
-			const seen = /* @__PURE__ */ new Set();
-			const order = new Array(values.length);
-			for (let index = 0; index < values.length; index++) {
-				const value = values[index];
-				const key = keyOf(value);
-				require_transform.assertSynchronous(key);
-				if (typeof key !== "string") throw new TypeError("derive.keyed.from key selector must return a string.");
-				if (seen.has(key)) throw new TypeError(`derive.keyed.from duplicate key ${JSON.stringify(key)}.`);
-				seen.add(key);
-				order[index] = key;
-				output.output.set(key, value);
-			}
-			for (const previousKey of output.previous.ids()) if (!seen.has(previousKey)) output.output.remove(previousKey);
-			output.output.order(order);
+			stageKeyedSnapshot(values, output, keyOf, (value) => value, "derive.keyed.from");
 		} }),
 		name: "derive.keyed.from"
 	});
 	return projection;
 }
+function createKeyedFromEntries(dependencies, compute, equality) {
+	const name = "derive.keyed.fromEntries";
+	const compiled = require_transform.compileProjectionDependencies(dependencies, name);
+	if (typeof compute !== "function") throw new TypeError(`${name} requires a compute callback.`);
+	const outputEquality = assertEquality(equality, name);
+	const [projection] = require_transform.defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: outputEquality
+		}],
+		name,
+		create: () => ({ evaluate: (evaluation) => {
+			const output = evaluation.outputs[0];
+			if (output.kind !== "collection") throw new Error(`${name} requires a collection output.`);
+			const entries = compute(require_transform.snapshotProjectionValues(compiled.names, evaluation.sources));
+			require_transform.assertSynchronous(entries);
+			if (!Array.isArray(entries)) throw new TypeError(`${name} compute must return an array of entries.`);
+			stageKeyedSnapshot(entries, output, (entry) => {
+				assertKeyedEntry(entry, name);
+				return entry[0];
+			}, (entry) => entry[1], name);
+		} })
+	});
+	return projection;
+}
 function createKeyedMerge(sources, options) {
 	if (!Array.isArray(sources)) throw new TypeError("derive.keyed.merge sources must be an array of keyed projections.");
 	const capturedSources = require_transform.snapshotArray(sources);
@@ -3584,6 +3622,7 @@ const keyedDerive = Object.assign(createKeyedDerive, {
 	entries: createKeyedEntries,
 	get: createKeyedGet,
 	from: createKeyedFrom,
+	fromEntries: createKeyedFromEntries,
 	merge: createKeyedMerge,
 	groupBy: createKeyedGroupBy,
 	flatMap: createKeyedFlatMap,
@@ -3607,9 +3646,7 @@ function createValueDerive(dependencies, compute, equality = Object.is) {
 		create: () => ({ evaluate: (evaluation) => {
 			const output = evaluation.outputs[0];
 			if (output.kind !== "value") throw new Error("derive requires a value output.");
-			const values = Object.create(null);
-			for (let index = 0; index < names.length; index++) values[names[index]] = require_transform.snapshotDependencyValue(evaluation.sources[index]);
-			const next = compute(Object.freeze(values));
+			const next = compute(require_transform.snapshotProjectionValues(names, evaluation.sources));
 			require_transform.assertSynchronous(next);
 			output.output.set(next);
 		} })
@@ -3618,6 +3655,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 = require_transform.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) => {
@@ -3712,7 +3847,7 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 const createCollectionState = (initial) => {
 	const values = new Map(initial);
 	let ids = Object.freeze([...values.keys()]);
-	let index = values.size ? PersistentKeyedIndex.from(values) : PersistentKeyedIndex.empty();
+	let index;
 	return {
 		get: (key) => values.get(key),
 		has: (key) => values.has(key),
@@ -3720,7 +3855,7 @@ const createCollectionState = (initial) => {
 		size: () => values.size,
 		ids: () => ids,
 		read: (check) => {
-			const snapshotIndex = index;
+			const snapshotIndex = index ??= PersistentKeyedIndex.from(values);
 			const snapshotIds = ids;
 			return Object.freeze({
 				get: (key) => {
@@ -3741,9 +3876,9 @@ const createCollectionState = (initial) => {
 			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);
 			}
@@ -3752,17 +3887,17 @@ const createCollectionState = (initial) => {
 		release: () => {
 			values.clear();
 			ids = Object.freeze([]);
-			index = PersistentKeyedIndex.empty();
+			index = void 0;
 		}
 	};
 };
 //#endregion
 //#region core/src/projection/output/collection.ts
-/** Owns staged keyed intent, exact transitions and published collection state. */
+/** Owns staged keyed intent, exact transitions and current collection state. */
 const createCollectionOutput = (binding) => {
-	const published = createCollectionState();
+	const currentState = createCollectionState();
 	const staged = /* @__PURE__ */ new Map();
-	let nextIds = published.ids();
+	let nextIds = currentState.ids();
 	let change;
 	let initialized = false;
 	let reset = false;
@@ -3770,23 +3905,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;
@@ -3794,15 +3932,15 @@ const createCollectionOutput = (binding) => {
 		const read = (next) => ({
 			get: (key) => {
 				require_transform.assertScope(active);
-				return next ? getNext(key) : published.get(key);
+				return next ? getNext(key) : currentState.get(key);
 			},
 			has: (key) => {
 				require_transform.assertScope(active);
-				return next ? hasNext(key) : published.has(key);
+				return next ? hasNext(key) : currentState.has(key);
 			},
 			ids: () => {
 				require_transform.assertScope(active);
-				if (!next) return published.ids();
+				if (!next) return currentState.ids();
 				if (explicitOrder) return explicitOrder;
 				return Object.freeze(deriveIds());
 			}
@@ -3832,15 +3970,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 });
 		}
 		require_transform.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);
+					require_transform.assertSynchronous(equivalent);
+					if (equivalent) {
+						entry = {
+							present: true,
+							value: before
+						};
+						staged.set(key, entry);
+					}
+				}
 				if (!existed) {
 					addedEntries.push({
 						key,
@@ -3848,7 +3999,7 @@ const createCollectionOutput = (binding) => {
 					});
 					continue;
 				}
-				const before = published.get(key);
+				const before = currentState.get(key);
 				const equal = isEqual(before, entry.value);
 				require_transform.assertSynchronous(equal);
 				if (!equal) updatedEntries.push({
@@ -3865,13 +4016,13 @@ const createCollectionOutput = (binding) => {
 			}
 			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.");
@@ -3880,7 +4031,7 @@ const createCollectionOutput = (binding) => {
 			if (seen.size !== expectedLength) throw new TypeError("Projection order must contain every key exactly once.");
 			nextIds = require_transform.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;
@@ -3897,7 +4048,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) => {
@@ -3913,9 +4064,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 {
@@ -3925,35 +4076,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.install(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;
@@ -3972,7 +4147,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;
@@ -3982,7 +4157,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;
@@ -4009,7 +4187,12 @@ const createValueOutput = (binding) => {
 			next = value;
 			return false;
 		}
-		const candidate = staged;
+		let candidate = staged;
+		if (baseline !== unset && !Object.is(value, baseline)) {
+			const equivalent = isEqual(baseline, candidate);
+			require_transform.assertSynchronous(equivalent);
+			if (equivalent) candidate = baseline;
+		}
 		const equal = initialized ? isEqual(value, candidate) : false;
 		require_transform.assertSynchronous(equal);
 		changed = !equal;
@@ -4024,13 +4207,13 @@ const createValueOutput = (binding) => {
 		},
 		begin,
 		seal,
-		context: (active) => {
+		context: (active, consumer) => {
 			require_transform.assertScope(active);
 			return Object.freeze({
 				kind: "value",
 				value: next,
 				revision,
-				reset,
+				reset: consumer ? (consumers.get(consumer)?.revision ?? -1) < resetRevision : reset,
 				cause: binding.cause()
 			});
 		},
@@ -4039,19 +4222,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) => {
-			require_transform.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)) {
+				require_transform.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;
@@ -4062,6 +4274,8 @@ const createValueOutput = (binding) => {
 		release: () => {
 			listeners.clear();
 			consumers.clear();
+			observers.clear();
+			baseline = unset;
 			staged = unset;
 			value = next = void 0;
 			initialized = false;
@@ -4132,7 +4346,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?.();
@@ -4146,16 +4360,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,
@@ -4282,7 +4497,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,
@@ -4318,8 +4535,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;
@@ -4329,31 +4547,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 = require_transform.diffCollection(previousCollection, current);
-				previousCollection = current;
-				if (!change) {
-					sourceRevision = source.revision();
-					return;
+			let affected = true;
+			if (previousCollection && isMapLike(current) && !selection.all) {
+				affected = selection.structure && !require_transform.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,
@@ -4735,13 +4966,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);
 		},
@@ -4797,6 +5027,7 @@ const createValueBoundary = (scheduler, name, initial, equality, prepare, clearS
 	return {
 		producer: boundary,
 		output,
+		baseline: state.baseline,
 		mark,
 		fail,
 		detach: (next) => {
@@ -4816,7 +5047,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)) {
@@ -4897,7 +5128,6 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 			state.clear();
 			pendingReset = false;
 			pendingCause = void 0;
-			contextCause = void 0;
 			recovering = false;
 			fullScan = false;
 			orderMayChange = false;
@@ -4950,7 +5180,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) => {
@@ -4961,6 +5195,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 	return {
 		producer: boundary,
 		output,
+		baseline: state.baseline,
 		mark,
 		fail,
 		detach: (next) => {
@@ -5510,13 +5745,12 @@ const materializeInputSource = (scheduler, definition) => {
 			...boundary,
 			input: {
 				kind: "value",
-				read: () => latest,
 				set(value) {
 					const next = scheduler.acceptInput(() => {
 						if (equal(latest, value)) return latest;
 						if (source.equality === Object.is) return value;
-						const published = boundary.output.current();
-						return !Object.is(latest, published) && equal(published, value) ? published : value;
+						const baseline = boundary.baseline();
+						return !Object.is(latest, baseline) && equal(baseline, value) ? baseline : value;
 					});
 					if (Object.is(latest, next)) return;
 					latest = next;
@@ -5527,7 +5761,6 @@ const materializeInputSource = (scheduler, definition) => {
 		};
 	}
 	const values = createCollectionState(source.initial);
-	let view;
 	const latest = {
 		get: values.get,
 		has: values.has,
@@ -5536,17 +5769,11 @@ const materializeInputSource = (scheduler, definition) => {
 	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => latest, Object.is, () => void 0);
 	boundary.detach(() => {
 		values.release();
-		view = void 0;
 	});
-	const check = () => {
-		scheduler.assertActive();
-		if (boundary.producer.disposed) throw new require_transform.ProjectionDisposedError();
-	};
 	return {
 		...boundary,
 		input: {
 			kind: "collection",
-			read: () => view ??= require_transform.collectionView(values.read(check)),
 			update(run) {
 				const accepted = scheduler.acceptInput(() => {
 					const staged = /* @__PURE__ */ new Map();
@@ -5593,7 +5820,7 @@ const materializeInputSource = (scheduler, definition) => {
 					} finally {
 						active = false;
 					}
-					const published = source.equality === Object.is ? void 0 : boundary.output.current();
+					const baseline = source.equality === Object.is ? void 0 : boundary.baseline();
 					for (const [key, entry] of staged) {
 						const existed = values.has(key);
 						if (!entry.present) {
@@ -5603,8 +5830,8 @@ const materializeInputSource = (scheduler, definition) => {
 						const previous = values.get(key);
 						let next = entry.value;
 						if (existed && equal(previous, next)) next = previous;
-						else if (published?.has(key)) {
-							const before = published.get(key);
+						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);
@@ -5629,7 +5856,6 @@ const materializeInputSource = (scheduler, definition) => {
 				});
 				if (!accepted.staged.size && !accepted.structural) return;
 				values.install(accepted.staged, accepted.order, false);
-				view = void 0;
 				boundary.mark({
 					candidates: accepted.staged.keys(),
 					orderMayChange: accepted.structural
@@ -5682,6 +5908,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 require_transform.ProjectionDisposedError();
@@ -5717,7 +5948,7 @@ const createProjectionItems = (source, checkOwner) => {
 		}
 		state.value = value;
 		state.revision++;
-		notify(state.listeners);
+		changedStates.add(state);
 	};
 	const attachActive = (state, value) => {
 		if (state.ended) return;
@@ -5760,10 +5991,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 (require_transform.iterableMatchesArray(current.keys(), keysValue)) return;
-		keysValue = Object.freeze([...current.keys()]);
+		keysValue = require_transform.iterableMatchesArray(current.keys(), notifiedKeys) ? notifiedKeys : Object.freeze([...current.keys()]);
 		keysRevision++;
-		notify(keyListeners);
 	};
 	const createItem = (key, initial) => {
 		const state = {
@@ -5772,12 +6005,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: () => {
@@ -5812,25 +6048,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) => {
@@ -5844,11 +6100,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,
@@ -5874,6 +6131,8 @@ const createProjectionItems = (source, checkOwner) => {
 			followers.clear();
 			waiting.clear();
 			notifications.length = 0;
+			pendingKeys.clear();
+			changedStates.clear();
 		}
 	};
 };
@@ -5934,6 +6193,7 @@ const createProjectionRuntime = (options) => {
 		} else {
 			if (definition.owner === void 0 && definition.dependencies.some((dependency) => require_transform.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,
@@ -5957,6 +6217,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();
@@ -5988,10 +6249,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) => {
@@ -6002,6 +6265,7 @@ const createProjectionRuntime = (options) => {
 		if (existing) return existing.items;
 		const controller = createProjectionItems(readableSource(projection, requester), () => {
 			if (requester && !requester.active) throw new require_transform.ProjectionDisposedError();
+			scheduler.ensureCurrent(output);
 			assertOutput(output);
 		});
 		registry.set(output, controller);
@@ -6036,18 +6300,7 @@ const createProjectionRuntime = (options) => {
 	function update(target, valueOrRun) {
 		updateInput(target, valueOrRun);
 	}
-	const batch = (run, options, requester) => scheduler.batch(() => {
-		let active = true;
-		const read = (target) => {
-			require_transform.assertScope(() => active);
-			return inputAccess(target, requester).read();
-		};
-		try {
-			return run(read);
-		} finally {
-			active = false;
-		}
-	}, options);
+	const batch = (run, options) => scheduler.batch(run, options);
 	const disposeScope = (state) => {
 		if (!state.active) return;
 		scheduler.assertIdle();
@@ -6139,7 +6392,7 @@ const createProjectionRuntime = (options) => {
 		}
 		function scopeBatch(run, options) {
 			assertActive();
-			return batch(run, options, state);
+			return batch(run, options);
 		}
 		return Object.freeze({
 			own,