doxum 0.1.32 → 0.1.34

package/dist/{transform-CENhTaVN.cjs → transform-Bt1Mwgrj.cjs}

@@ -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: () => {
@@ -1083,6 +1113,12 @@ Object.defineProperty(exports, "assertSynchronous", {
 		return assertSynchronous;
 	}
 });
+Object.defineProperty(exports, "collectKeyedInvalidation", {
+	enumerable: true,
+	get: function() {
+		return collectKeyedInvalidation;
+	}
+});
 Object.defineProperty(exports, "collectionChange", {
 	enumerable: true,
 	get: function() {
@@ -1167,12 +1203,6 @@ Object.defineProperty(exports, "defineSource", {
 		return defineSource;
 	}
 });
-Object.defineProperty(exports, "diffCollection", {
-	enumerable: true,
-	get: function() {
-		return diffCollection;
-	}
-});
 Object.defineProperty(exports, "isProjection", {
 	enumerable: true,
 	get: function() {
@@ -1252,4 +1282,4 @@ Object.defineProperty(exports, "snapshotDependencyValue", {
 	}
 });
 
-//# sourceMappingURL=transform-CENhTaVN.cjs.map
+//# sourceMappingURL=transform-Bt1Mwgrj.cjs.map