doxum 0.1.25 → 0.1.27

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_scheduler = require("./scheduler-D4VthaaK.cjs");
+const require_scheduler = require("./scheduler-k1ZGR1PG.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 const require_driver = require("./driver-BL91gn7_.cjs");
 //#region core/src/schema/model.ts
@@ -10,7 +10,7 @@ const field = (validator) => node$2({
 	kind: "field",
 	...validator ? { validator } : {}
 });
-const optional = (value) => {
+function optional(value) {
 	const concrete = schemaNodeOf(value);
 	if (![
 		"field",
@@ -23,7 +23,7 @@ const optional = (value) => {
 		...concrete,
 		optional: true
 	});
-};
+}
 const object = (shape) => node$2({
 	kind: "object",
 	shape: Object.freeze(Object.fromEntries(Object.entries(shape).map(([key, value]) => [key, schemaNodeOf(value)])))
@@ -2735,14 +2735,9 @@ 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/derive.ts
-const sourceValue = (source) => source.kind === "value" ? source.value : require_scheduler.snapshotCollectionView(source.read);
+//#region core/src/projection/derive/keyed.ts
 const outputKind = (projection) => {
-	const ref = require_scheduler.projectionRef(projection);
-	const definition = ref.producer;
-	const output = definition.kind === "source" ? definition.output : definition.outputs[ref.output];
-	if (!output) throw new TypeError("Projection output does not exist.");
-	return output.kind;
+	return require_scheduler.outputDefinitionOf(projection).kind;
 };
 const assertKeyedProjection = (projection, role) => {
 	if (outputKind(projection) !== "collection") throw new TypeError(`${role} must be a keyed collection projection.`);
@@ -2768,41 +2763,29 @@ const bindKey = (index, outputKey, sourceKey) => {
 	else index.reverse.set(sourceKey, new Set([outputKey]));
 };
 const unbindKey = (indexes, outputKey) => {
-	for (const index of indexes) bindKey(index, outputKey, void 0);
+	for (const index of indexes) if (index) bindKey(index, outputKey, void 0);
 };
 const createBindingIndex = () => ({
 	forward: /* @__PURE__ */ new Map(),
 	reverse: /* @__PURE__ */ new Map()
 });
-function createValueDerive(dependencies, compute, equality = Object.is) {
-	if (!require_record.isPlainObject(dependencies) || require_scheduler.isProjection(dependencies)) throw new TypeError("Derive dependencies must be a plain object.");
-	const names = Object.keys(dependencies);
-	const ordered = names.map((name) => dependencies[name]);
-	ordered.forEach(require_scheduler.projectionRef);
-	const [projection] = require_scheduler.defineProcessor({
-		dependencies: ordered,
-		outputs: [{
-			kind: "value",
-			equality
-		}],
-		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]] = sourceValue(evaluation.sources[index]);
-			const next = compute(Object.freeze(values));
-			require_scheduler.assertSynchronous(next);
-			output.output.set(next);
-		} })
-	});
-	return projection;
-}
-function createKeyedDerive(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
+const emptyKeyedDependencies = Object.freeze(Object.create(null));
+const absent = Symbol("keyed-transform-absent");
+const compileOrderedKeys = (value, role) => {
+	if (!Array.isArray(value)) throw new TypeError(`${role} must be an array of string keys.`);
+	const seen = /* @__PURE__ */ new Set();
+	for (const key of value) {
+		if (typeof key !== "string") throw new TypeError(`${role} must contain only string keys.`);
+		if (seen.has(key)) throw new TypeError(`${role} must not contain duplicate keys.`);
+		seen.add(key);
+	}
+	return {
+		keys: value,
+		requested: seen
+	};
+};
+const createKeyedTransform = (source, dependencySpecs, select, equality, name) => {
 	assertKeyedProjection(source, "Keyed derive source");
-	const dependencySpecs = typeof dependenciesOrSelect === "function" ? void 0 : dependenciesOrSelect;
-	const select = dependencySpecs === void 0 ? dependenciesOrSelect : selectOrEquality;
-	const equality = dependencySpecs === void 0 ? selectOrEquality : maybeEquality;
-	if (typeof select !== "function") throw new TypeError("Keyed derive requires a selector.");
 	const dependencies = [source];
 	const dependencyNames = [];
 	const keyed = [];
@@ -2833,81 +2816,91 @@ function createKeyedDerive(source, dependenciesOrSelect, selectOrEquality, maybe
 		}],
 		create: () => {
 			const bindings = keyed.map((dependency) => dependency ? createBindingIndex() : void 0);
-			const bindingIndexes = bindings.filter((index) => index !== void 0);
 			const globalValues = keyed.map(() => void 0);
-			let revisions = Object.freeze([]);
+			const revisions = [];
 			const clearBindings = () => {
 				for (const index of bindings) {
 					index?.forward.clear();
 					index?.reverse.clear();
 				}
 			};
+			const rememberRevisions = (sources) => {
+				revisions.length = sources.length;
+				for (let index = 0; index < sources.length; index++) revisions[index] = sources[index].revision;
+			};
 			return {
 				evaluate: (evaluation) => {
 					const driver = evaluation.sources[0];
 					const output = evaluation.outputs[0];
 					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error("Keyed derive requires collection input and output.");
-					const currentRevisions = evaluation.sources.map((current) => current.revision);
 					for (let index = 0; index < keyed.length; index++) {
 						if (keyed[index]) continue;
-						if (evaluation.reset || revisions[index + 1] !== currentRevisions[index + 1]) globalValues[index] = sourceValue(evaluation.sources[index + 1]);
+						const dependencySource = evaluation.sources[index + 1];
+						if (evaluation.reset || revisions[index + 1] !== dependencySource.revision) globalValues[index] = require_scheduler.snapshotDependencyValue(dependencySource);
 					}
 					const project = (key) => {
 						if (!driver.read.has(key)) return;
 						const value = driver.read.get(key);
-						const dependencyValues = Object.create(null);
-						for (let index = 0; index < keyed.length; index++) {
-							const dependency = keyed[index];
-							if (!dependency) {
-								dependencyValues[dependencyNames[index]] = globalValues[index];
-								continue;
+						let dependencyValues = emptyKeyedDependencies;
+						if (keyed.length) {
+							const values = Object.create(null);
+							for (let index = 0; index < keyed.length; index++) {
+								const dependency = keyed[index];
+								if (!dependency) {
+									values[dependencyNames[index]] = globalValues[index];
+									continue;
+								}
+								const sourceContext = evaluation.sources[index + 1];
+								if (sourceContext.kind !== "collection") throw new TypeError("Dynamic keyed dependency resolved to a non-collection source.");
+								const selectedKey = dependency.key(value, key);
+								require_scheduler.assertSynchronous(selectedKey);
+								if (selectedKey !== void 0 && typeof selectedKey !== "string") throw new TypeError("Dynamic keyed dependency keys must be strings or undefined.");
+								bindKey(bindings[index], key, selectedKey);
+								values[dependencyNames[index]] = selectedKey === void 0 ? void 0 : sourceContext.read.get(selectedKey);
 							}
-							const sourceContext = evaluation.sources[index + 1];
-							if (sourceContext.kind !== "collection") throw new TypeError("Dynamic keyed dependency resolved to a non-collection source.");
-							const selectedKey = dependency.key(value, key);
-							require_scheduler.assertSynchronous(selectedKey);
-							if (selectedKey !== void 0 && typeof selectedKey !== "string") throw new TypeError("Dynamic keyed dependency keys must be strings or undefined.");
-							bindKey(bindings[index], key, selectedKey);
-							dependencyValues[dependencyNames[index]] = selectedKey === void 0 ? void 0 : sourceContext.read.get(selectedKey);
+							dependencyValues = Object.freeze(values);
 						}
-						const next = dependencySpecs === void 0 ? select(value, key) : select(value, key, Object.freeze(dependencyValues));
+						const next = select(value, key, dependencyValues);
 						require_scheduler.assertSynchronous(next);
-						output.output.set(key, next);
+						if (next === absent) output.output.remove(key);
+						else output.output.set(key, next);
 					};
 					if (evaluation.reset) {
 						clearBindings();
 						const ids = driver.read.ids();
 						for (const key of ids) project(key);
-						output.output.order(ids);
-						revisions = Object.freeze(currentRevisions);
+						output.output.order(ids.filter((key) => output.next.has(key)));
+						rememberRevisions(evaluation.sources);
 						return;
 					}
 					const dirty = /* @__PURE__ */ new Set();
 					let all = false;
 					let updateOrder = false;
-					if (revisions[0] !== currentRevisions[0]) {
+					let membershipChanged = false;
+					if (revisions[0] !== driver.revision) {
 						const change = driver.change;
 						if (!change || change.kind === "reset") {
 							all = true;
 							updateOrder = true;
 						} else {
 							for (const entry of change.removed) {
+								membershipChanged ||= output.previous.has(entry.key);
 								output.output.remove(entry.key);
-								unbindKey(bindingIndexes, entry.key);
+								unbindKey(bindings, 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.added.length || change.removed.length || change.order);
+							updateOrder = Boolean(change.order);
 						}
 					}
 					for (let index = 0; index < keyed.length; index++) {
-						if (revisions[index + 1] === currentRevisions[index + 1]) continue;
+						const sourceContext = evaluation.sources[index + 1];
+						if (revisions[index + 1] === sourceContext.revision) continue;
 						if (!keyed[index]) {
 							all = true;
 							continue;
 						}
-						const sourceContext = evaluation.sources[index + 1];
 						if (sourceContext.kind !== "collection" || !sourceContext.change) {
 							all = true;
 							continue;
@@ -2917,86 +2910,274 @@ function createKeyedDerive(source, dependenciesOrSelect, selectOrEquality, maybe
 							continue;
 						}
 						const reverse = bindings[index].reverse;
-						for (const transition of sourceContext.change.added) for (const outputKey of reverse.get(transition.key) ?? []) dirty.add(outputKey);
-						for (const transition of sourceContext.change.updated) for (const outputKey of reverse.get(transition.key) ?? []) dirty.add(outputKey);
-						for (const transition of sourceContext.change.removed) for (const outputKey of reverse.get(transition.key) ?? []) dirty.add(outputKey);
+						for (const sourceKey of require_scheduler.collectionChange.keys(sourceContext.change)) for (const outputKey of reverse.get(sourceKey) ?? []) dirty.add(outputKey);
 					}
 					if (all) for (const key of driver.read.ids()) dirty.add(key);
-					for (const key of dirty) if (driver.read.has(key)) project(key);
-					if (updateOrder) output.output.order(driver.read.ids());
-					revisions = Object.freeze(currentRevisions);
+					for (const key of dirty) {
+						if (!driver.read.has(key)) continue;
+						const beforePresent = output.previous.has(key);
+						project(key);
+						membershipChanged ||= beforePresent !== output.next.has(key);
+					}
+					if (updateOrder || membershipChanged) output.output.order(driver.read.ids().filter((key) => output.next.has(key)));
+					rememberRevisions(evaluation.sources);
 				},
 				release: () => {
 					clearBindings();
-					revisions = Object.freeze([]);
+					revisions.length = 0;
 				}
 			};
 		},
-		name: "derive.keyed"
+		name
 	});
 	return projection;
+};
+function createKeyedDerive(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
+	const dependencySpecs = typeof dependenciesOrSelect === "function" ? void 0 : dependenciesOrSelect;
+	const select = dependencySpecs === void 0 ? dependenciesOrSelect : selectOrEquality;
+	const equality = dependencySpecs === void 0 ? selectOrEquality : maybeEquality;
+	if (typeof select !== "function") throw new TypeError("Keyed derive requires a selector.");
+	return createKeyedTransform(source, dependencySpecs, (value, key, dependencies) => dependencySpecs === void 0 ? select(value, key) : select(value, key, dependencies), equality, "derive.keyed");
 }
-const derive = Object.assign(createValueDerive, { keyed: createKeyedDerive });
-//#endregion
-//#region core/src/projection/collection/change.ts
-const commonOrderChanged = (before, after, added, removed) => {
-	const beforeCommon = before.filter((key) => !removed.has(key));
-	const afterCommon = after.filter((key) => !added.has(key));
-	return beforeCommon.some((key, index) => afterCommon[index] !== key);
-};
-/** Builds the canonical incremental CollectionChange from already-known net transitions. */
-const createCollectionChange = (input) => {
-	const addedKeys = new Set(input.added.map((entry) => entry.key));
-	const removedKeys = new Set(input.removed.map((entry) => entry.key));
-	const orderChanged = input.beforeOrder !== input.afterOrder && commonOrderChanged(input.beforeOrder, input.afterOrder, addedKeys, removedKeys);
-	if (!input.added.length && !input.updated.length && !input.removed.length && !orderChanged) return void 0;
-	return Object.freeze({
-		kind: "incremental",
-		added: Object.freeze([...input.added]),
-		updated: Object.freeze([...input.updated]),
-		removed: Object.freeze([...input.removed]),
-		...orderChanged ? { order: Object.freeze({
-			before: Object.freeze([...input.beforeOrder]),
-			after: Object.freeze([...input.afterOrder])
-		}) } : {}
+const createKeyedKeys = (source) => {
+	assertKeyedProjection(source, "Keyed keys source");
+	const [projection] = require_scheduler.defineProcessor({
+		dependencies: [source],
+		outputs: [{
+			kind: "value",
+			equality: Object.is
+		}],
+		create: () => ({ evaluate: (evaluation) => {
+			const driver = evaluation.sources[0];
+			const output = evaluation.outputs[0];
+			if (driver.kind !== "collection" || output.kind !== "value") throw new Error("derive.keyed.keys requires collection input and value output.");
+			if (evaluation.reset || !driver.change || require_scheduler.collectionHasStructuralChange(driver.change)) output.output.set(driver.read.ids());
+		} }),
+		name: "derive.keyed.keys"
 	});
+	return projection;
 };
-/** 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
+const createKeyedValues = (source) => {
+	assertKeyedProjection(source, "Keyed values source");
+	const [projection] = require_scheduler.defineProcessor({
+		dependencies: [source],
+		outputs: [{
+			kind: "value",
+			equality: Object.is
+		}],
+		create: () => {
+			let indexes = /* @__PURE__ */ new Map();
+			const rebuild = (driver) => {
+				const nextIndexes = /* @__PURE__ */ new Map();
+				const ids = driver.read.ids();
+				const values = Object.freeze(ids.map((key, index) => {
+					nextIndexes.set(key, index);
+					return driver.read.get(key);
+				}));
+				indexes = nextIndexes;
+				return values;
+			};
+			const rebuildIncremental = (driver, change, previous) => {
+				const changedValues = /* @__PURE__ */ new Map();
+				for (const entry of change.added) changedValues.set(entry.key, entry.after);
+				for (const entry of change.updated) changedValues.set(entry.key, entry.after);
+				const nextIndexes = /* @__PURE__ */ new Map();
+				const values = Object.freeze(driver.read.ids().map((key, index) => {
+					nextIndexes.set(key, index);
+					if (changedValues.has(key)) return changedValues.get(key);
+					const previousIndex = indexes.get(key);
+					return previousIndex === void 0 ? driver.read.get(key) : previous[previousIndex];
+				}));
+				indexes = nextIndexes;
+				return values;
+			};
+			return {
+				evaluate: (evaluation) => {
+					const driver = evaluation.sources[0];
+					const output = evaluation.outputs[0];
+					if (driver.kind !== "collection" || output.kind !== "value") throw new Error("derive.keyed.values requires collection input and value output.");
+					const change = driver.change;
+					if (evaluation.reset || !change || change.kind === "reset") {
+						output.output.set(rebuild(driver));
+						return;
+					}
+					const previous = output.previous;
+					if (!previous) {
+						output.output.set(rebuild(driver));
+						return;
+					}
+					if (require_scheduler.collectionHasStructuralChange(change)) {
+						output.output.set(rebuildIncremental(driver, change, previous));
+						return;
+					}
+					if (!change.updated.length) return;
+					const next = [...previous];
+					for (const entry of change.updated) {
+						const index = indexes.get(entry.key);
+						if (index === void 0) {
+							output.output.set(rebuild(driver));
+							return;
+						}
+						next[index] = entry.after;
+					}
+					output.output.set(Object.freeze(next));
+				},
+				release: () => indexes.clear()
+			};
+		},
+		name: "derive.keyed.values"
 	});
-	return createCollectionChange({
-		added,
-		updated,
-		removed,
-		beforeOrder: [...previous.keys()],
-		afterOrder: [...current.keys()]
+	return projection;
+};
+function createKeyedFilter(source, dependenciesOrPredicate, maybePredicate) {
+	const dependencySpecs = typeof dependenciesOrPredicate === "function" ? void 0 : dependenciesOrPredicate;
+	const predicate = dependencySpecs === void 0 ? dependenciesOrPredicate : maybePredicate;
+	if (typeof predicate !== "function") throw new TypeError("Keyed filter requires a predicate.");
+	return createKeyedTransform(source, dependencySpecs, (value, key, dependencies) => {
+		const included = dependencySpecs === void 0 ? predicate(value, key) : predicate(value, key, dependencies);
+		require_scheduler.assertSynchronous(included);
+		if (typeof included !== "boolean") throw new TypeError("Keyed filter predicate must return boolean.");
+		return included ? value : absent;
+	}, Object.is, "derive.keyed.filter");
+}
+function createKeyedCompact(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
+	const dependencySpecs = typeof dependenciesOrSelect === "function" ? void 0 : dependenciesOrSelect;
+	const select = dependencySpecs === void 0 ? dependenciesOrSelect : selectOrEquality;
+	const equality = dependencySpecs === void 0 ? selectOrEquality : maybeEquality;
+	if (typeof select !== "function") throw new TypeError("Keyed compact requires a selector.");
+	return createKeyedTransform(source, dependencySpecs, (value, key, dependencies) => {
+		const next = dependencySpecs === void 0 ? select(value, key) : select(value, key, dependencies);
+		require_scheduler.assertSynchronous(next);
+		return next === void 0 ? absent : next;
+	}, equality, "derive.keyed.compact");
+}
+const createKeyedSubset = (source, orderedKeys) => {
+	assertKeyedProjection(source, "Keyed subset source");
+	const keyProjection = require_scheduler.isProjection(orderedKeys) ? orderedKeys : void 0;
+	if (keyProjection && outputKind(keyProjection) !== "value") throw new TypeError("Keyed subset ordered keys must be a value projection.");
+	const staticSelection = keyProjection ? void 0 : (() => {
+		const compiled = compileOrderedKeys(orderedKeys, "Keyed subset ordered keys");
+		return {
+			keys: Object.freeze([...compiled.keys]),
+			requested: compiled.requested
+		};
+	})();
+	const [projection] = require_scheduler.defineProcessor({
+		dependencies: keyProjection ? [source, keyProjection] : [source],
+		outputs: [{
+			kind: "collection",
+			equality: Object.is
+		}],
+		create: () => {
+			let keys = staticSelection?.keys;
+			let requested = staticSelection?.requested;
+			let keyRevision = -1;
+			return {
+				evaluate: (evaluation) => {
+					const driver = evaluation.sources[0];
+					const output = evaluation.outputs[0];
+					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error("derive.keyed.subset requires collection input and output.");
+					let keysChanged = false;
+					if (keyProjection) {
+						const sourceContext = evaluation.sources[1];
+						if (sourceContext?.kind !== "value") throw new TypeError("Keyed subset ordered keys resolved to a collection.");
+						if (keys === void 0 || sourceContext.reset || keyRevision !== sourceContext.revision) {
+							const compiled = compileOrderedKeys(sourceContext.value, "Keyed subset ordered keys");
+							keys = compiled.keys;
+							requested = compiled.requested;
+							keyRevision = sourceContext.revision;
+							keysChanged = true;
+						}
+					}
+					if (!keys || !requested) throw new Error("Keyed subset keys were not initialized.");
+					const activeKeys = keys;
+					const activeRequested = requested;
+					const orderedPresentKeys = () => activeKeys.filter((key) => driver.read.has(key));
+					const rebuild = () => {
+						const nextKeys = orderedPresentKeys();
+						for (const key of nextKeys) output.output.set(key, driver.read.get(key));
+						output.output.order(nextKeys);
+					};
+					const reconcileKeys = () => {
+						const nextKeys = orderedPresentKeys();
+						for (const key of output.previous.ids()) if (!activeRequested.has(key) || !driver.read.has(key)) output.output.remove(key);
+						for (const key of nextKeys) if (!output.previous.has(key)) output.output.set(key, driver.read.get(key));
+						output.output.order(nextKeys);
+					};
+					const change = driver.change;
+					if (evaluation.reset || change?.kind === "reset") rebuild();
+					else if (keysChanged) {
+						reconcileKeys();
+						if (change) for (const entry of change.updated) {
+							const key = entry.key;
+							if (activeRequested.has(key) && output.previous.has(key)) output.output.set(key, entry.after);
+						}
+					} else if (change) {
+						let updateOrder = false;
+						for (const entry of change.removed) {
+							const key = entry.key;
+							if (!activeRequested.has(key)) continue;
+							output.output.remove(key);
+							updateOrder = true;
+						}
+						for (const entry of change.added) {
+							const key = entry.key;
+							if (!activeRequested.has(key)) continue;
+							output.output.set(key, entry.after);
+							updateOrder = true;
+						}
+						for (const entry of change.updated) {
+							const key = entry.key;
+							if (activeRequested.has(key)) output.output.set(key, entry.after);
+						}
+						if (updateOrder) output.output.order(orderedPresentKeys());
+					}
+				},
+				release: () => {
+					if (keyProjection) {
+						keys = void 0;
+						requested = void 0;
+						keyRevision = -1;
+					}
+				}
+			};
+		},
+		name: "derive.keyed.subset"
 	});
+	return projection;
 };
-const collectionChangedKeys = (change) => change.kind === "reset" ? /* @__PURE__ */ new Set() : new Set([
-	...change.added.map((entry) => entry.key),
-	...change.updated.map((entry) => entry.key),
-	...change.removed.map((entry) => entry.key)
-]);
-const collectionHasStructuralChange = (change) => change.kind === "reset" || Boolean(change.added.length || change.removed.length || change.order);
-const collectionHasAnyChange = (change) => change.kind === "reset" || Boolean(change.added.length || change.updated.length || change.removed.length || change.order);
+const keyedDerive = Object.assign(createKeyedDerive, {
+	keys: createKeyedKeys,
+	values: createKeyedValues,
+	subset: createKeyedSubset,
+	filter: createKeyedFilter,
+	compact: createKeyedCompact
+});
+//#endregion
+//#region core/src/projection/derive.ts
+function createValueDerive(dependencies, compute, equality = Object.is) {
+	const compiled = require_scheduler.compileProjectionDependencies(dependencies, "Derive");
+	const names = compiled.names;
+	const ordered = compiled.projections;
+	const [projection] = require_scheduler.defineProcessor({
+		dependencies: ordered,
+		outputs: [{
+			kind: "value",
+			equality
+		}],
+		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_scheduler.snapshotDependencyValue(evaluation.sources[index]);
+			const next = compute(Object.freeze(values));
+			require_scheduler.assertSynchronous(next);
+			output.output.set(next);
+		} })
+	});
+	return projection;
+}
+const derive = Object.assign(createValueDerive, { keyed: keyedDerive });
 //#endregion
 //#region core/src/projection/collection/index.ts
 const height = (node) => node?.height ?? 0;
@@ -3209,15 +3390,36 @@ const createCollectionOutput = (binding) => {
 		require_scheduler.profile.projection("touchedKeys", staged.size);
 		const added = /* @__PURE__ */ new Set();
 		const removed = /* @__PURE__ */ new Set();
-		const updated = /* @__PURE__ */ new Set();
+		const addedEntries = [];
+		const updatedEntries = [];
+		const removedEntries = [];
 		for (const [key, entry] of staged) {
 			const existed = published.has(key);
 			if (entry.present) {
-				if (!existed) added.add(key);
-				else if (!isEqual(published.get(key), entry.value)) updated.add(key);
+				if (!existed) {
+					added.add(key);
+					addedEntries.push({
+						key,
+						after: entry.value
+					});
+					continue;
+				}
+				const before = published.get(key);
+				if (!isEqual(before, entry.value)) updatedEntries.push({
+					key,
+					before,
+					after: entry.value
+				});
 				else if (!nextReset) staged.delete(key);
-			} else if (existed) removed.add(key);
-			else staged.delete(key);
+				continue;
+			}
+			if (existed) {
+				removed.add(key);
+				removedEntries.push({
+					key,
+					before: published.get(key)
+				});
+			} else staged.delete(key);
 		}
 		const ids = published.ids();
 		if (explicitOrder || added.size || removed.size) {
@@ -3225,36 +3427,8 @@ const createCollectionOutput = (binding) => {
 			if (new Set(order).size !== order.length || order.length !== published.size() + added.size - removed.size || order.some((key) => !hasNext(key))) throw new TypeError("Projection order must contain every key exactly once.");
 			nextIds = ids.length === order.length && ids.every((key, index) => key === order[index]) ? ids : Object.freeze([...order]);
 		} else nextIds = ids;
-		const changedKeys = /* @__PURE__ */ new Set();
-		added.forEach((key) => changedKeys.add(key));
-		removed.forEach((key) => changedKeys.add(key));
-		updated.forEach((key) => changedKeys.add(key));
-		require_scheduler.profile.projection("changedKeys", changedKeys.size);
-		const addedEntries = [];
-		const updatedEntries = [];
-		const removedEntries = [];
-		for (const key of changedKeys) {
-			const beforePresent = published.has(key);
-			const afterPresent = hasNext(key);
-			if (beforePresent === afterPresent) {
-				if (!beforePresent) continue;
-				if (isEqual !== Object.is && isEqual(published.get(key), getNext(key))) continue;
-			}
-			if (!beforePresent) addedEntries.push({
-				key,
-				after: getNext(key)
-			});
-			else if (!afterPresent) removedEntries.push({
-				key,
-				before: published.get(key)
-			});
-			else updatedEntries.push({
-				key,
-				before: published.get(key),
-				after: getNext(key)
-			});
-		}
-		change = nextReset ? Object.freeze({ kind: "reset" }) : createCollectionChange({
+		require_scheduler.profile.projection("changedKeys", addedEntries.length + updatedEntries.length + removedEntries.length);
+		change = nextReset ? Object.freeze({ kind: "reset" }) : require_scheduler.createCollectionChange({
 			added: addedEntries,
 			updated: updatedEntries,
 			removed: removedEntries,
@@ -3618,10 +3792,9 @@ const trackedMap = (source) => {
 };
 const selectionAffects = (selection, change) => {
 	if (!change || change.kind === "reset") return true;
-	if (selection.all && collectionHasAnyChange(change)) return true;
-	if (selection.structure && collectionHasStructuralChange(change)) return true;
-	const changedKeys = collectionChangedKeys(change);
-	for (const key of selection.keys) if (changedKeys.has(key)) return true;
+	if (selection.all) return true;
+	if (selection.structure && require_scheduler.collectionHasStructuralChange(change)) return true;
+	for (const key of require_scheduler.collectionChange.keys(change)) if (selection.keys.has(key)) return true;
 	return false;
 };
 const createDirectReadable = (source) => Object.freeze({
@@ -3689,7 +3862,7 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 		if (!change && previousCollection) {
 			const current = source.current();
 			if (isMapLike(current)) {
-				change = diffCollection(previousCollection, current);
+				change = require_scheduler.diffCollection(previousCollection, current);
 				previousCollection = current;
 				if (!change) {
 					sourceRevision = source.revision();
@@ -4163,7 +4336,7 @@ const stageCollectionRead = (state, read, active, options) => {
 		evaluation.output.order(ids);
 	} else {
 		const previous = state.current();
-		const keys = options.candidates ? [...new Set(options.candidates)] : [...new Set([...previous.ids(), ...read.ids()])];
+		const keys = options.candidates ? [...options.candidates] : [...new Set([...previous.ids(), ...read.ids()])];
 		if (!options.candidates) require_scheduler.profile.collectionView.idsScanned(keys.length);
 		for (const key of keys) if (read.has(key)) {
 			require_scheduler.profile.collectionView.mapped();
@@ -4852,6 +5025,7 @@ const materializeInputSource = (scheduler, definition) => {
 				scheduler.assertIdle();
 				const staged = /* @__PURE__ */ new Map();
 				const operations = [];
+				let structural = false;
 				let active = true;
 				const draft = Object.freeze({
 					get: (key) => {
@@ -4867,6 +5041,8 @@ const materializeInputSource = (scheduler, definition) => {
 					set: (key, value) => {
 						require_scheduler.assertScope(() => active);
 						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						const previous = staged.get(key);
+						structural ||= previous ? !previous.present : !values.has(key);
 						staged.set(key, {
 							present: true,
 							value
@@ -4880,8 +5056,11 @@ const materializeInputSource = (scheduler, definition) => {
 					remove: (key) => {
 						require_scheduler.assertScope(() => active);
 						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						const previous = staged.get(key);
+						const present = previous ? previous.present : values.has(key);
+						structural ||= present;
 						staged.set(key, { present: false });
-						operations.push({
+						if (present) operations.push({
 							kind: "remove",
 							key
 						});
@@ -4892,32 +5071,25 @@ const materializeInputSource = (scheduler, definition) => {
 				} finally {
 					active = false;
 				}
+				if (!operations.length) return;
 				const candidates = /* @__PURE__ */ new Set();
-				let structural = false;
-				const accepted = [];
-				const overlay = /* @__PURE__ */ new Map();
-				for (const operation of operations) {
-					const overlayValue = overlay.get(operation.key);
-					const present = overlayValue ? overlayValue.present : values.has(operation.key);
-					if (operation.kind === "set") {
-						const previous = overlayValue ? overlayValue.present ? overlayValue.value : void 0 : values.get(operation.key);
-						if (present && source.equality(previous, operation.value)) continue;
-						structural ||= !present;
-						overlay.set(operation.key, {
-							present: true,
-							value: operation.value
-						});
-					} else {
-						if (!present) continue;
-						structural = true;
-						overlay.set(operation.key, { present: false });
-					}
-					accepted.push(operation);
-					candidates.add(operation.key);
+				const retained = /* @__PURE__ */ new Map();
+				for (const [key, entry] of staged) {
+					const existed = values.has(key);
+					if (entry.present) {
+						if (!existed) {
+							candidates.add(key);
+							continue;
+						}
+						const previous = values.get(key);
+						if (source.equality(previous, entry.value)) retained.set(key, previous);
+						else candidates.add(key);
+					} else if (existed) candidates.add(key);
 				}
-				if (!accepted.length) return;
-				for (const operation of accepted) if (operation.kind === "set") values.set(operation.key, operation.value);
+				if (!candidates.size && !structural) return;
+				for (const operation of operations) if (operation.kind === "set") values.set(operation.key, operation.value);
 				else values.delete(operation.key);
+				for (const [key, value] of retained) if (values.has(key)) values.set(key, value);
 				boundary.mark({
 					candidates,
 					orderMayChange: structural