doxum 0.1.32 → 0.1.34

package/dist/{transform-gOtqcdHe.js → transform-RghG_Qxs.js}

@@ -119,22 +119,40 @@ const mapRead = (value) => {
 /** Immutable map-like view over a CollectionRead. */
 const collectionView = (read, knownIds) => {
 	const ids = knownIds ?? 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 iterate = (select) => {
+		read.ids();
+		let index = 0;
+		return {
+			next() {
+				read.ids();
+				if (index === ids.length) return {
+					done: true,
+					value: void 0
+				};
+				return {
+					done: false,
+					value: select(ids[index++])
+				};
+			},
+			[Symbol.iterator]() {
+				return this;
+			}
+		};
 	};
+	const entries = () => iterate((key) => [key, read.get(key)]);
+	const values = () => iterate((key) => read.get(key));
 	const view = {
 		get: (key) => read.get(key),
 		has: (key) => read.has(key),
 		get size() {
+			read.ids();
 			return ids.length;
 		},
-		keys: () => ids[Symbol.iterator](),
+		keys: () => iterate((key) => key),
 		values,
 		entries,
 		forEach: (callback, thisArg) => {
+			read.ids();
 			for (const key of ids) callback.call(thisArg, read.get(key), key, view);
 		},
 		[Symbol.iterator]: entries
@@ -183,141 +201,36 @@ const compileProjectionDependencies = (dependencies, label) => {
 	});
 };
 //#endregion
-//#region core/src/value/array.ts
-/** Allocation-free strict equality for ordered readonly arrays. */
-const sameArray = (left, right) => {
-	if (left === right) return true;
-	if (left.length !== right.length) return false;
-	for (let index = 0; index < left.length; index++) if (left[index] !== right[index]) return false;
-	return true;
-};
-/** Owns an immutable shallow snapshot while reusing arrays that are already frozen. */
-const snapshotArray = (values) => Object.isFrozen(values) ? values : Object.freeze([...values]);
-/** Compares an iterable with an ordered array without materializing the iterable. */
-const iterableMatchesArray = (values, expected) => {
-	let index = 0;
-	for (const value of values) {
-		if (index >= expected.length || value !== expected[index]) return false;
-		index++;
-	}
-	return index === expected.length;
-};
-//#endregion
-//#region core/src/projection/collection/change.ts
-const transitionContains = (entries, key) => {
-	for (const entry of entries) if (entry.key === key) return true;
-	return false;
-};
-const transitionSet = (entries) => {
-	if (entries.length <= 4) return void 0;
-	const keys = /* @__PURE__ */ new Set();
-	for (const entry of entries) keys.add(entry.key);
-	return keys;
-};
-const nextExcluding = (iterator, excluded, index) => {
-	while (true) {
-		const next = iterator.next();
-		if (next.done || !(index ? index.has(next.value) : transitionContains(excluded, next.value))) return next;
-	}
-};
-/** Compares common-member order from known transitions without materializing common arrays. */
-const transitionOrderChanged = (before, after, removed, added) => {
-	const removedKeys = transitionSet(removed);
-	const addedKeys = transitionSet(added);
-	const beforeIterator = before[Symbol.iterator]();
-	const afterIterator = after[Symbol.iterator]();
-	while (true) {
-		const left = nextExcluding(beforeIterator, removed, removedKeys);
-		const right = nextExcluding(afterIterator, added, addedKeys);
-		if (left.done || right.done) return left.done !== right.done;
-		if (left.value !== right.value) return true;
-	}
-};
-const nextPresentIn = (iterator, membership) => {
-	while (true) {
-		const next = iterator.next();
-		if (next.done || membership.has(next.value)) return next;
+//#region core/src/projection/keyed/invalidation.ts
+/** Shared driver/dependency invalidation policy; owns no revisions or member cache. */
+const collectKeyedInvalidation = (driver, sources, dependencies, reset) => {
+	const changed = dependencies.driverChanged(driver);
+	const change = changed ? driver.change : void 0;
+	if (reset || changed && (!change || change.kind === "reset")) return {
+		rebuild: true,
+		keys: driver.read.ids(),
+		removed: [],
+		structural: true
+	};
+	const dirty = /* @__PURE__ */ new Set();
+	let removed = [];
+	let structural = false;
+	if (change?.kind === "incremental") {
+		removed = change.removed;
+		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);
 	}
-};
-/** Compares common-member order between two map snapshots without key snapshots or closures. */
-const mapOrderChanged = (before, after) => {
-	const beforeIterator = before.keys();
-	const afterIterator = after.keys();
-	while (true) {
-		const left = nextPresentIn(beforeIterator, after);
-		const right = nextPresentIn(afterIterator, before);
-		if (left.done || right.done) return left.done !== right.done;
-		if (left.value !== right.value) return true;
+	const all = dependencies.collectInvalidated(sources, dirty);
+	if (!all) {
+		for (const key of dirty) if (!driver.read.has(key)) dirty.delete(key);
 	}
-};
-const sealIncrementalChange = (added, updated, removed, order) => {
-	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: Object.freeze({
-			before: snapshotArray(order.before),
-			after: snapshotArray(order.after)
-		}) } : {}
-	});
-};
-/** Builds the canonical incremental CollectionChange from already-known net transitions. */
-const createCollectionChange = (input) => {
-	let orderChanged = false;
-	if (input.beforeOrder !== input.afterOrder) if (!input.added.length && !input.removed.length) orderChanged = !sameArray(input.beforeOrder, input.afterOrder);
-	else orderChanged = transitionOrderChanged(input.beforeOrder, input.afterOrder, input.removed, input.added);
-	return sealIncrementalChange(input.added, input.updated, input.removed, orderChanged ? {
-		before: input.beforeOrder,
-		after: input.afterOrder
-	} : void 0);
-};
-/** Exact fallback diff between two published map-like snapshots. */
-const diffCollection = (previous, current, isEqual = Object.is) => {
-	const added = [];
-	const updated = [];
-	const removed = [];
-	for (const [key, before] of previous) if (!current.has(key)) removed.push({
-		key,
-		before
-	});
-	else {
-		const after = current.get(key);
-		if (!isEqual(before, after)) updated.push({
-			key,
-			before,
-			after
-		});
-	}
-	for (const [key, after] of current) if (!previous.has(key)) added.push({
-		key,
-		after
-	});
-	return sealIncrementalChange(added, updated, removed, mapOrderChanged(previous, current) ? {
-		before: Object.freeze([...previous.keys()]),
-		after: Object.freeze([...current.keys()])
-	} : void 0);
-};
-const changedKeys = function* (change) {
-	if (change.kind !== "incremental") throw new TypeError("collectionChange.keys requires an incremental CollectionChange.");
-	for (const entry of change.added) yield entry.key;
-	for (const entry of change.updated) yield entry.key;
-	for (const entry of change.removed) yield entry.key;
-};
-const collectionChange = Object.freeze({ keys: changedKeys });
-const collectionHasStructuralChange = (change) => change.kind === "reset" || Boolean(change.added.length || change.removed.length || change.order);
-const collectionChangeTouchesKey = (change, key) => {
-	for (const entry of change.added) if (entry.key === key) return true;
-	for (const entry of change.updated) if (entry.key === key) return true;
-	for (const entry of change.removed) if (entry.key === key) return true;
-	return false;
-};
-const collectionChangeIntersects = (change, keys) => {
-	for (const entry of change.added) if (keys.has(entry.key)) return true;
-	for (const entry of change.updated) if (keys.has(entry.key)) return true;
-	for (const entry of change.removed) if (keys.has(entry.key)) return true;
-	return false;
+	return {
+		rebuild: false,
+		keys: all ? driver.read.ids() : dirty,
+		removed,
+		structural
+	};
 };
 //#endregion
 //#region core/src/projection/contract.ts
@@ -348,10 +261,11 @@ const createScheduler = (onError) => {
 	const sources = /* @__PURE__ */ new Set();
 	const processors = /* @__PURE__ */ new Set();
 	const pendingSources = /* @__PURE__ */ new Set();
-	const heap = [];
+	const dirty = /* @__PURE__ */ new Set();
 	const queued = /* @__PURE__ */ new Set();
 	const completed = /* @__PURE__ */ new Set();
 	const emissions = /* @__PURE__ */ new Set();
+	const forced = /* @__PURE__ */ new Set();
 	const errors = [];
 	let reportingFailures = [];
 	const guards = /* @__PURE__ */ new Set();
@@ -360,38 +274,22 @@ const createScheduler = (onError) => {
 	};
 	const assertIdle = () => {
 		assertActive();
-		if (phase !== "idle") throw new Error("Projection cannot be re-entered during processing or notification.");
+		if (phase !== "idle") throw new Error("Projection cannot be re-entered during input callbacks, processing or notification.");
 	};
 	const lock = (value) => guards.forEach((guard) => guard(value));
+	const markDirty = (producer) => {
+		const pending = [producer];
+		for (let index = 0; index < pending.length; index++) {
+			const current = pending[index];
+			if (current.disposed || dirty.has(current)) continue;
+			dirty.add(current);
+			for (const output of current.outputs) output.forEachConsumer((consumer) => pending.push(consumer));
+		}
+	};
 	const enqueue = (processor) => {
 		if (processor.disposed || queued.has(processor)) return;
 		queued.add(processor);
 		profile.projection("scheduledNodes");
-		let index = heap.length;
-		heap.push(processor);
-		while (index > 0) {
-			const parent = index - 1 >> 1;
-			if (heap[parent].order < processor.order) break;
-			heap[index] = heap[parent];
-			index = parent;
-		}
-		heap[index] = processor;
-	};
-	const pop = () => {
-		const first = heap[0];
-		const last = heap.pop();
-		if (heap.length) {
-			let index = 0;
-			while (index * 2 + 1 < heap.length) {
-				let child = index * 2 + 1;
-				if (child + 1 < heap.length && heap[child + 1].order < heap[child].order) child++;
-				if (last.order < heap[child].order) break;
-				heap[index] = heap[child];
-				index = child;
-			}
-			heap[index] = last;
-		}
-		return first;
 	};
 	const errorFor = (producer, cause, kind = producer.kind === "source" ? "source" : "processor") => new ProjectionError(kind, cause);
 	const capture = (source) => {
@@ -402,6 +300,7 @@ const createScheduler = (onError) => {
 			throw source.fault;
 		}
 		pendingSources.add(source);
+		markDirty(source);
 		profile.projection("sourceEvents");
 		if (source.fault) errors.push(source.fault);
 	};
@@ -412,88 +311,137 @@ const createScheduler = (onError) => {
 			if (cause !== void 0) return cause;
 		}
 	};
-	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
-		phase = "compute";
-		lock(true);
-		const cause = settleCause();
-		try {
-			for (const source of pendingSources) {
-				if (source.disposed) continue;
-				const wasFaulted = source.fault !== void 0;
-				let changed = false;
-				let force = false;
-				if (!source.fault || source.recovering()) try {
-					const prepared = source.prepare(cause);
-					changed = prepared.changed;
-					force = prepared.force;
-					source.fault = void 0;
-				} catch (failure) {
-					source.fault = errorFor(source, failure, "source");
-					errors.push(source.fault);
-				}
-				const recovered = wasFaulted && !source.fault;
-				if (changed) source.publish();
-				if (source.fault || changed || force || recovered) {
-					const output = source.outputs[0];
-					emissions.add(output);
-					output.forEachConsumer(enqueue);
+	const propagate = (output, force = false) => {
+		emissions.add(output);
+		if (force) forced.add(output);
+		output.forEachConsumer(enqueue);
+	};
+	const advanceSource = (source, cause) => {
+		pendingSources.delete(source);
+		const wasFaulted = source.fault !== void 0;
+		let changed = false;
+		let force = false;
+		if (!source.fault || source.recovering()) try {
+			source.fault = void 0;
+			const prepared = source.prepare(cause);
+			changed = prepared.changed;
+			force = prepared.force;
+			source.fault = void 0;
+		} catch (failure) {
+			source.fault = errorFor(source, failure, "source");
+			errors.push(source.fault);
+		}
+		if (changed || force) source.publish();
+		if (source.fault || changed || force || wasFaulted) propagate(source.outputs[0], force);
+		source.clear();
+	};
+	const advanceProcessor = (processor, cause) => {
+		queued.delete(processor);
+		const wasFaulted = processor.fault !== void 0;
+		profile.projection("processedNodes");
+		let changedOutputs = [];
+		const blocked = processor.dependencies.find((output) => output.owner.fault || output.owner.disposed);
+		if (blocked) processor.fault = errorFor(processor, blocked.owner.fault ?? new ProjectionDisposedError(), "blocked");
+		else {
+			const reset = wasFaulted || processor.dependencies.some((output) => output.reset(processor));
+			try {
+				changedOutputs = processor.evaluate(reset, cause, wasFaulted);
+				const failure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
+				if (failure) throw failure;
+				processor.fault = void 0;
+			} catch (failure) {
+				const error = errorFor(processor, failure);
+				processor.fault = error;
+				if (!reset) try {
+					changedOutputs = processor.evaluate(true, cause, true);
+					const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
+					if (dependencyFailure) throw dependencyFailure;
+					processor.fault = void 0;
+					errors.push(error);
+				} catch (rebuildFailure) {
+					processor.fault = errorFor(processor, rebuildFailure);
+					errors.push(processor.fault);
 				}
+				else errors.push(error);
 			}
-			while (heap.length) {
-				const processor = pop();
-				if (processor.disposed) continue;
-				const wasFaulted = processor.fault !== void 0;
-				profile.projection("processedNodes");
-				let changedOutputs = Object.freeze([]);
-				const blocked = processor.dependencies.find((output) => output.owner.fault || output.owner.disposed);
-				if (blocked) processor.fault = errorFor(processor, blocked.owner.fault ?? new ProjectionDisposedError(), "blocked");
-				else {
-					const reset = wasFaulted || processor.dependencies.some((output) => output.reset());
-					try {
-						changedOutputs = processor.evaluate(reset, cause, wasFaulted);
-						const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
-						if (dependencyFailure) throw dependencyFailure;
-						processor.fault = void 0;
-					} catch (failure) {
-						const error = errorFor(processor, failure);
-						processor.fault = error;
-						if (!reset) try {
-							changedOutputs = processor.evaluate(true, cause, true);
-							const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
-							if (dependencyFailure) throw dependencyFailure;
-							processor.fault = void 0;
-							errors.push(error);
-						} catch (rebuildFailure) {
-							processor.fault = errorFor(processor, rebuildFailure);
-							errors.push(processor.fault);
-						}
-						else errors.push(error);
+		}
+		completed.add(processor);
+		if (processor.fault) processor.outputs.forEach((output) => propagate(output));
+		else {
+			if (changedOutputs.length) processor.publish();
+			(wasFaulted && !processor.fault ? processor.outputs : changedOutputs).forEach((output) => propagate(output));
+		}
+		if (processor.fault || changedOutputs.length) profile.projection("publishedNodes");
+	};
+	const advance = (target, cause) => {
+		const stack = [{
+			producer: target,
+			dependency: 0
+		}];
+		while (stack.length) {
+			const frame = stack[stack.length - 1];
+			const { producer } = frame;
+			if (producer.disposed || !dirty.has(producer)) {
+				dirty.delete(producer);
+				stack.pop();
+				continue;
+			}
+			if (producer.kind === "processor") {
+				let dependency;
+				while (frame.dependency < producer.dependencies.length) {
+					const candidate = producer.dependencies[frame.dependency++].owner;
+					if (dirty.has(candidate)) {
+						dependency = candidate;
+						break;
 					}
 				}
-				completed.add(processor);
-				const recovered = wasFaulted && !processor.fault;
-				if (processor.fault) processor.outputs.forEach((output) => {
-					emissions.add(output);
-					output.forEachConsumer(enqueue);
-				});
-				else {
-					if (changedOutputs.length) {
-						processor.publish();
-						changedOutputs.forEach((output) => emissions.add(output));
-					}
-					(recovered ? processor.outputs : changedOutputs).forEach((output) => output.forEachConsumer(enqueue));
+				if (dependency) {
+					stack.push({
+						producer: dependency,
+						dependency: 0
+					});
+					continue;
 				}
-				if (processor.fault || changedOutputs.length) profile.projection("publishedNodes");
 			}
+			stack.pop();
+			dirty.delete(producer);
+			if (producer.kind === "source") advanceSource(producer, cause);
+			else if (queued.has(producer)) if (producer.fault || producer.dependencies.some((output) => output.owner.fault || output.pending(producer))) advanceProcessor(producer, cause);
+			else {
+				queued.delete(producer);
+				producer.dependencies.forEach((output) => output.acknowledge(producer));
+			}
+		}
+	};
+	const compute = (run) => {
+		phase = "compute";
+		lock(true);
+		try {
+			return run();
 		} finally {
 			lock(false);
 			phase = "idle";
 		}
 	};
+	const settle = () => {
+		if (disposed || depth || phase !== "idle") return;
+		const cause = settleCause();
+		compute(() => {
+			for (const producer of dirty) advance(producer, cause);
+		});
+	};
+	const ensureCurrent = (output) => {
+		assertActive();
+		if (phase === "notify") return;
+		assertIdle();
+		if (dirty.has(output.owner)) {
+			const cause = settleCause();
+			compute(() => advance(output.owner, cause));
+		}
+	};
 	const flush = () => {
 		if (disposed || depth) return [];
-		if (pendingSources.size || completed.size) profile.projection("flushes");
+		if (emissions.size || completed.size) profile.projection("flushes");
 		phase = "notify";
 		lock(true);
 		const reportFailures = [];
@@ -504,7 +452,7 @@ const createScheduler = (onError) => {
 				} catch (cause) {
 					errors.push(errorFor(output.owner, cause, "listener"));
 				}
-			}));
+			}, forced.has(output) || Boolean(output.owner.fault)));
 			for (const error of errors.slice()) try {
 				onError(error);
 			} catch (cause) {
@@ -518,12 +466,13 @@ const createScheduler = (onError) => {
 				error
 			}))]);
 		} finally {
-			pendingSources.forEach((source) => source.clear());
+			emissions.forEach((output) => output.finish());
 			completed.forEach((processor) => processor.clear());
 			pendingSources.clear();
 			queued.clear();
 			completed.clear();
 			emissions.clear();
+			forced.clear();
 			errors.length = 0;
 			reportingFailures = reportFailures;
 			lock(false);
@@ -569,6 +518,7 @@ const createScheduler = (onError) => {
 		assertIdle();
 		if (producer.outputs.some((output) => output.hasConsumers())) throw new Error("Projection producer is still used by another processor.");
 		producer.disposed = true;
+		dirty.delete(producer);
 		if (producer.kind === "processor") {
 			producer.dependencies.forEach((output) => output.detachConsumer(producer));
 			processors.delete(producer);
@@ -597,6 +547,7 @@ const createScheduler = (onError) => {
 		assertIdle,
 		capture,
 		settle,
+		ensureCurrent,
 		flush,
 		run,
 		registerGuard(guard) {
@@ -622,10 +573,10 @@ const createScheduler = (onError) => {
 			processor.dependencies.forEach((output) => output.attachConsumer(processor));
 		},
 		releaseProducer,
-		order: () => sequence++,
-		initialize(callback) {
+		nextId: () => sequence++,
+		acceptInput(callback) {
 			assertIdle();
-			phase = "compute";
+			phase = "input";
 			lock(true);
 			try {
 				return callback();
@@ -634,6 +585,10 @@ const createScheduler = (onError) => {
 				phase = "idle";
 			}
 		},
+		initialize(callback) {
+			assertIdle();
+			return compute(callback);
+		},
 		batch,
 		batchContext: () => activeBatch,
 		dispose() {
@@ -660,10 +615,11 @@ const createScheduler = (onError) => {
 			processors.clear();
 			sources.clear();
 			pendingSources.clear();
-			heap.length = 0;
+			dirty.clear();
 			queued.clear();
 			completed.clear();
 			emissions.clear();
+			forced.clear();
 			guards.clear();
 			errors.length = 0;
 			reportingFailures = [];
@@ -678,6 +634,26 @@ const assertScope = (active) => {
 	if (!active()) throw new Error("Projection reader or writer is no longer active.");
 };
 //#endregion
+//#region core/src/value/array.ts
+/** Allocation-free strict equality for ordered readonly arrays. */
+const sameArray = (left, right) => {
+	if (left === right) return true;
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index++) if (left[index] !== right[index]) return false;
+	return true;
+};
+/** Owns an immutable shallow snapshot while reusing arrays that are already frozen. */
+const snapshotArray = (values) => Object.isFrozen(values) ? values : Object.freeze([...values]);
+/** Compares an iterable with an ordered array without materializing the iterable. */
+const iterableMatchesArray = (values, expected) => {
+	let index = 0;
+	for (const value of values) {
+		if (index >= expected.length || value !== expected[index]) return false;
+		index++;
+	}
+	return index === expected.length;
+};
+//#endregion
 //#region core/src/projection/keyed/relation.ts
 /** Runtime-local domain-neutral many-to-many keyed relation. */
 const createKeyRelation = () => {
@@ -906,7 +882,6 @@ const createKeyedDependencyRuntime = (compiled) => {
 			for (const state of states) {
 				const source = sources[state.sourceIndex];
 				if (state.revision === source.revision) continue;
-				state.entry;
 				if (state.kind === "global") {
 					all = true;
 					continue;
@@ -948,6 +923,80 @@ const createKeyedDependencyRuntime = (compiled) => {
 	};
 };
 //#endregion
+//#region core/src/projection/collection/change.ts
+const transitionContains = (entries, key) => {
+	for (const entry of entries) if (entry.key === key) return true;
+	return false;
+};
+const transitionSet = (entries) => {
+	if (entries.length <= 4) return void 0;
+	const keys = /* @__PURE__ */ new Set();
+	for (const entry of entries) keys.add(entry.key);
+	return keys;
+};
+const nextExcluding = (iterator, excluded, index) => {
+	while (true) {
+		const next = iterator.next();
+		if (next.done || !(index ? index.has(next.value) : transitionContains(excluded, next.value))) return next;
+	}
+};
+/** Compares common-member order from known transitions without materializing common arrays. */
+const transitionOrderChanged = (before, after, removed, added) => {
+	const removedKeys = transitionSet(removed);
+	const addedKeys = transitionSet(added);
+	const beforeIterator = before[Symbol.iterator]();
+	const afterIterator = after[Symbol.iterator]();
+	while (true) {
+		const left = nextExcluding(beforeIterator, removed, removedKeys);
+		const right = nextExcluding(afterIterator, added, addedKeys);
+		if (left.done || right.done) return left.done !== right.done;
+		if (left.value !== right.value) return true;
+	}
+};
+const sealIncrementalChange = (added, updated, removed, order) => {
+	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: Object.freeze({
+			before: snapshotArray(order.before),
+			after: snapshotArray(order.after)
+		}) } : {}
+	});
+};
+/** Builds the canonical incremental CollectionChange from already-known net transitions. */
+const createCollectionChange = (input) => {
+	let orderChanged = false;
+	if (input.beforeOrder !== input.afterOrder) if (!input.added.length && !input.removed.length) orderChanged = !sameArray(input.beforeOrder, input.afterOrder);
+	else orderChanged = transitionOrderChanged(input.beforeOrder, input.afterOrder, input.removed, input.added);
+	return sealIncrementalChange(input.added, input.updated, input.removed, orderChanged ? {
+		before: input.beforeOrder,
+		after: input.afterOrder
+	} : void 0);
+};
+const changedKeys = function* (change) {
+	if (change.kind !== "incremental") throw new TypeError("collectionChange.keys requires an incremental CollectionChange.");
+	for (const entry of change.added) yield entry.key;
+	for (const entry of change.updated) yield entry.key;
+	for (const entry of change.removed) yield entry.key;
+};
+const collectionChange = Object.freeze({ keys: changedKeys });
+const collectionHasStructuralChange = (change) => change.kind === "reset" || Boolean(change.added.length || change.removed.length || change.order);
+const collectionChangeTouchesKey = (change, key) => {
+	for (const entry of change.added) if (entry.key === key) return true;
+	for (const entry of change.updated) if (entry.key === key) return true;
+	for (const entry of change.removed) if (entry.key === key) return true;
+	return false;
+};
+const collectionChangeIntersects = (change, keys) => {
+	for (const entry of change.added) if (keys.has(entry.key)) return true;
+	for (const entry of change.updated) if (keys.has(entry.key)) return true;
+	for (const entry of change.removed) if (keys.has(entry.key)) return true;
+	return false;
+};
+//#endregion
 //#region core/src/projection/keyed/transform.ts
 const keyedAbsent = Symbol("keyed-transform-absent");
 /** Shared driver-keyed lifecycle for pure and retained keyed transforms. */
@@ -972,7 +1021,8 @@ const createKeyedTransform = (definition) => {
 					const driver = evaluation.sources[0];
 					const output = evaluation.outputs[0];
 					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error(`${definition.name} requires collection input and output.`);
-					dependencies.prepare(evaluation.sources, evaluation.reset);
+					const invalidation = collectKeyedInvalidation(driver, evaluation.sources, dependencies, evaluation.reset);
+					dependencies.prepare(evaluation.sources, invalidation.rebuild);
 					const stateFor = (key, value) => {
 						if (states.has(key)) return states.get(key);
 						const state = definition.state ? definition.state(value, key) : void 0;
@@ -997,49 +1047,29 @@ const createKeyedTransform = (definition) => {
 						else output.output.set(key, next);
 						return beforePresent !== output.next.has(key);
 					};
-					if (evaluation.reset) {
+					if (invalidation.rebuild) {
 						dependencies.clearBindings();
 						const ids = driver.read.ids();
 						for (const key of states.keys()) if (!driver.read.has(key)) states.delete(key);
+						if (!evaluation.reset) {
+							for (const key of output.previous.ids()) if (!driver.read.has(key)) output.output.remove(key);
+						}
 						for (const key of ids) project(key);
 						output.output.order(ids.filter((key) => output.next.has(key)));
 						dependencies.remember(evaluation.sources);
 						return;
 					}
-					const dirty = /* @__PURE__ */ new Set();
-					let all = false;
-					let updateOrder = false;
 					let membershipChanged = false;
-					if (dependencies.driverChanged(driver)) {
-						const change = driver.change;
-						if (!change || change.kind === "reset") {
-							all = true;
-							updateOrder = true;
-							for (const key of output.previous.ids()) {
-								if (driver.read.has(key)) continue;
-								output.output.remove(key);
-								dropState(key);
-								membershipChanged = true;
-							}
-						} else {
-							for (const entry of change.removed) {
-								membershipChanged ||= output.previous.has(entry.key);
-								output.output.remove(entry.key);
-								dropState(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);
-							updateOrder = Boolean(change.order);
-						}
+					for (const entry of invalidation.removed) {
+						membershipChanged ||= output.previous.has(entry.key);
+						output.output.remove(entry.key);
+						dropState(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) {
+					for (const key of invalidation.keys) {
 						const changedMembership = project(key);
 						membershipChanged ||= changedMembership;
 					}
-					if (updateOrder || membershipChanged) output.output.order(driver.read.ids().filter((key) => output.next.has(key)));
+					if (invalidation.structural || membershipChanged) output.output.order(driver.read.ids().filter((key) => output.next.has(key)));
 					dependencies.remember(evaluation.sources);
 				},
 				release: () => {
@@ -1053,6 +1083,6 @@ const createKeyedTransform = (definition) => {
 	return projection;
 };
 //#endregion
-export { ownProjections as A, snapshotDependencyValue as C, defineProcessor as D, snapshotCollectionView as E, projectionRef as M, profile as N, defineSource as O, compileProjectionDependencies as S, mapRead as T, createCollectionChange as _, createKeyedDependencyRuntime as a, sameArray as b, assertScope as c, ProjectionDisposedError as d, ProjectionError as f, collectionHasStructuralChange as g, collectionChangeTouchesKey as h, compileKeyedDependencies as i, producerOf as j, isProjection as k, assertSynchronous as l, collectionChangeIntersects as m, keyedAbsent as n, outputKind as o, collectionChange as p, assertKeyedProjection as r, createKeyRelation as s, createKeyedTransform as t, createScheduler as u, diffCollection as v, collectionView as w, snapshotArray as x, iterableMatchesArray as y };
+export { ownProjections as A, snapshotDependencyValue as C, defineProcessor as D, snapshotCollectionView as E, projectionRef as M, profile as N, defineSource as O, compileProjectionDependencies as S, mapRead as T, assertSynchronous as _, collectionChangeTouchesKey as a, ProjectionError as b, assertKeyedProjection as c, outputKind as d, createKeyRelation as f, assertScope as g, snapshotArray as h, collectionChangeIntersects as i, producerOf as j, isProjection as k, compileKeyedDependencies as l, sameArray as m, keyedAbsent as n, collectionHasStructuralChange as o, iterableMatchesArray as p, collectionChange as r, createCollectionChange as s, createKeyedTransform as t, createKeyedDependencyRuntime as u, createScheduler as v, collectionView as w, collectKeyedInvalidation as x, ProjectionDisposedError as y };
 
-//# sourceMappingURL=transform-gOtqcdHe.js.map
+//# sourceMappingURL=transform-RghG_Qxs.js.map