doxum 0.1.38 → 0.1.40

package/README.md

@@ -322,6 +322,16 @@ const ids = derive.keyed.keys(records);
 const all = derive.keyed.values(records);
 const entries = derive.keyed.entries(records);
 const active = derive.keyed.get(records, activeRecordId);
+const selectedRecords = derive.keyed.subset(
+  records,
+  { selection },
+  ({ selection }) => selection.recordIds
+);
+const selectedRecord = derive.keyed.get(
+  records,
+  { selection },
+  ({ selection }) => selection.activeRecordId
+);
 const rowsFromArray = derive.keyed.from(rowArray, row => row.id);
 const effectiveRows = derive.keyed.merge([baseRows, rowOverrides], { conflict: 'last' });
 const visible = derive.keyed.filter(records, record => record.visible);
@@ -342,6 +352,15 @@ source-relative order. `compact` omits keys whose selected value is `undefined`
 uses its optional equality for present values. `filter` and `compact` support the same
 named global/dynamic keyed dependency object as ordinary `derive.keyed`.
 
+`get` accepts a static key, a key projection, or `(source, dependencies, selectKey, equality?)`.
+`subset` accepts a static ordered key array, a key-array projection, or
+`(source, dependencies, selectOrderedKeys)`. Named selectors run when their declared
+dependencies change; source-only updates use the selected keys to filter deltas.
+Missing requested keys remain live for later adds. Subset preserves source value
+references and requested order, and has no value equality option. Unrelated source
+updates may wake the processor to inspect deltas, but do not rerun selectors or rebuild
+the subset. See [Keyed selection](docs/projections.md#keyed-selection).
+
 `from` turns either a static readonly array or `Projection<readonly V[]>` into a keyed
 projection using `keyOf(value)`. Input order becomes formal keyed order; duplicate keys
 are errors rather than implicit overwrites. Static outer arrays are snapshotted at

package/dist/advanced.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-D45KWMzj.cjs");
+const require_transform = require("./transform-8xXf0OKB.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });

package/dist/advanced.js

@@ -1,4 +1,4 @@
-import { D as defineProcessor, S as compileProjectionDependencies, _ as assertSynchronous, r as collectionChange, t as createKeyedTransform, w as collectionView } from "./transform-3mj0eStL.js";
+import { D as defineProcessor, S as compileProjectionDependencies, _ as assertSynchronous, r as collectionChange, t as createKeyedTransform, w as collectionView } from "./transform--WCn6_v0.js";
 import { n as isPlainObject } from "./record-B2yRhYsc.js";
 //#region core/src/projection/advanced.ts
 const resetCollectionChange = Object.freeze({ kind: "reset" });

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-D45KWMzj.cjs");
+const require_transform = require("./transform-8xXf0OKB.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
 const require_driver = require("./driver-CN3dGxQI.cjs");
 //#region core/src/schema/model.ts
@@ -2883,6 +2883,163 @@ function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, mayb
 	return projection;
 }
 //#endregion
+//#region core/src/projection/keyed/selection.ts
+/** Compiles selection inputs; runtime instances retain only the request and its dependency revisions.
+* Source slot zero belongs to the collection being queried, not to the selection expression.
+*/
+const compileSelection = (input, named, select, normalize, name) => {
+	let projections;
+	let compute;
+	let initial;
+	if (named) {
+		const compiled = require_transform.compileProjectionDependencies(input, name);
+		if (typeof select !== "function") throw new TypeError(`${name} requires a selection callback.`);
+		projections = compiled.projections;
+		const selectValues = select;
+		compute = (sources) => selectValues(require_transform.snapshotProjectionValues(compiled.names, sources, 1));
+	} else if (require_transform.isProjection(input)) {
+		if (require_transform.outputKind(input) !== "value") throw new TypeError(`${name} selection must be a scalar projection.`);
+		projections = [input];
+		compute = (sources) => {
+			const source = sources[1];
+			if (source?.kind !== "value") throw new Error(`${name} resolved a non-scalar selection.`);
+			return source.value;
+		};
+	} else {
+		projections = [];
+		initial = normalize(input);
+	}
+	return {
+		projections,
+		create: () => {
+			let initialized = compute === void 0;
+			let current = initial;
+			const revisions = new Array(projections.length).fill(-1);
+			return {
+				get value() {
+					if (!initialized) throw new Error(`${name} selection was not initialized.`);
+					return current;
+				},
+				refresh(sources) {
+					if (!compute) return false;
+					let dirty = !initialized;
+					for (let index = 0; index < revisions.length; index++) {
+						const source = sources[index + 1];
+						if (source.reset || source.revision !== revisions[index]) dirty = true;
+					}
+					if (!dirty) return false;
+					const candidate = compute(sources);
+					require_transform.assertSynchronous(candidate);
+					const next = normalize(candidate, current);
+					const changed = !initialized || !Object.is(current, next);
+					current = next;
+					initialized = true;
+					for (let index = 0; index < revisions.length; index++) revisions[index] = sources[index + 1].revision;
+					return changed;
+				}
+			};
+		}
+	};
+};
+const normalizeKey = (value) => {
+	if (value !== void 0 && typeof value !== "string") throw new TypeError("derive.keyed.get key must be a string or undefined.");
+	return value;
+};
+const normalizeOrderedKeys = (value, previous) => {
+	if (!Array.isArray(value)) throw new TypeError("derive.keyed.subset ordered keys must be an array.");
+	if (previous && require_transform.sameArray(previous.keys, value)) return previous;
+	const requested = /* @__PURE__ */ new Set();
+	for (const key of value) {
+		if (typeof key !== "string") throw new TypeError("derive.keyed.subset keys must be strings.");
+		if (requested.has(key)) throw new TypeError("derive.keyed.subset keys must not contain duplicate keys.");
+		requested.add(key);
+	}
+	return {
+		keys: require_transform.snapshotArray(value),
+		requested
+	};
+};
+function createKeyedGet(source, input, selectOrEquality, maybeEquality) {
+	const name = "derive.keyed.get";
+	require_transform.assertKeyedProjection(source, `${name} source`);
+	const named = !require_transform.isProjection(input) && typeof input !== "string" && input !== void 0;
+	const selection = compileSelection(input, named, named ? selectOrEquality : void 0, normalizeKey, name);
+	const equality = named ? maybeEquality : selectOrEquality;
+	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${name} equality must be a function.`);
+	const [projection] = require_transform.defineProcessor({
+		dependencies: [source, ...selection.projections],
+		outputs: [{
+			kind: "value",
+			equality: equality ?? Object.is
+		}],
+		name,
+		create: () => {
+			const selected = selection.create();
+			return { evaluate: (evaluation) => {
+				const collection = evaluation.sources[0];
+				const output = evaluation.outputs[0];
+				if (collection.kind !== "collection" || output.kind !== "value") throw new Error(`${name} resolved invalid input/output kinds.`);
+				const keyChanged = selected.refresh(evaluation.sources);
+				const key = selected.value;
+				const change = collection.change;
+				if (evaluation.reset || keyChanged || change?.kind === "reset" || key !== void 0 && change && require_transform.collectionChangeTouchesKey(change, key)) output.output.set(key === void 0 ? void 0 : collection.read.get(key));
+			} };
+		}
+	});
+	return projection;
+}
+function createKeyedSubset(source, input, selectOrderedKeys) {
+	const name = "derive.keyed.subset";
+	require_transform.assertKeyedProjection(source, `${name} source`);
+	const selection = compileSelection(input, !require_transform.isProjection(input) && !Array.isArray(input), selectOrderedKeys, normalizeOrderedKeys, name);
+	const [projection] = require_transform.defineProcessor({
+		dependencies: [source, ...selection.projections],
+		outputs: [{
+			kind: "collection",
+			equality: Object.is
+		}],
+		name,
+		create: () => {
+			const selected = selection.create();
+			return { evaluate: (evaluation) => {
+				const driver = evaluation.sources[0];
+				const output = evaluation.outputs[0];
+				if (driver.kind !== "collection" || output.kind !== "collection") throw new Error(`${name} requires collection input and output.`);
+				const keysChanged = selected.refresh(evaluation.sources);
+				const { keys, requested } = selected.value;
+				const change = driver.change;
+				if (evaluation.reset || change?.kind === "reset") {
+					const present = keys.filter((key) => driver.read.has(key));
+					for (const key of present) output.output.set(key, driver.read.get(key));
+					output.output.order(present);
+					return;
+				}
+				let orderChanged = keysChanged;
+				if (keysChanged) {
+					for (const key of output.previous.ids()) if (!requested.has(key) || !driver.read.has(key)) output.output.remove(key);
+					for (const key of keys) if (!output.previous.has(key) && driver.read.has(key)) output.output.set(key, driver.read.get(key));
+				} else if (change) {
+					for (const entry of change.removed) {
+						if (!requested.has(entry.key)) continue;
+						output.output.remove(entry.key);
+						orderChanged = true;
+					}
+					for (const entry of change.added) {
+						if (!requested.has(entry.key)) continue;
+						output.output.set(entry.key, entry.after);
+						orderChanged = true;
+					}
+				}
+				if (change) {
+					for (const entry of change.updated) if (requested.has(entry.key) && (!keysChanged || output.previous.has(entry.key))) output.output.set(entry.key, entry.after);
+				}
+				if (orderChanged) output.output.order(keys.filter((key) => driver.read.has(key)));
+			} };
+		}
+	});
+	return projection;
+}
+//#endregion
 //#region core/src/projection/keyed/composition.ts
 const assertEquality = (equality, role) => {
 	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${role} equality must be a function.`);
@@ -3211,19 +3368,6 @@ function createKeyedSingleton(sourceOrDependencies, compute, equality) {
 }
 //#endregion
 //#region core/src/projection/derive/keyed.ts
-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
-	};
-};
 function createKeyedDerive(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
 	const dependencySpecs = typeof dependenciesOrSelect === "function" ? void 0 : dependenciesOrSelect;
 	const select = dependencySpecs === void 0 ? dependenciesOrSelect : selectOrEquality;
@@ -3328,44 +3472,6 @@ const createOrderedSnapshot = (source, name, make) => {
 };
 const createKeyedValues = (source) => createOrderedSnapshot(source, "derive.keyed.values", (_key, value) => value);
 const createKeyedEntries = (source) => createOrderedSnapshot(source, "derive.keyed.entries", (key, value) => Object.freeze([key, value]));
-const createKeyedGet = (source, key, equality = Object.is) => {
-	require_transform.assertKeyedProjection(source, "derive.keyed.get source");
-	if (require_transform.outputKind(key) !== "value") throw new TypeError("derive.keyed.get key must be a scalar projection.");
-	const [projection] = require_transform.defineProcessor({
-		dependencies: [source, key],
-		outputs: [{
-			kind: "value",
-			equality
-		}],
-		create: () => {
-			let sourceRevision = -1;
-			let keyRevision = -1;
-			let selected;
-			return { evaluate: (evaluation) => {
-				const collection = evaluation.sources[0];
-				const selectedKey = evaluation.sources[1];
-				const output = evaluation.outputs[0];
-				if (collection.kind !== "collection" || selectedKey.kind !== "value" || output.kind !== "value") throw new Error("derive.keyed.get resolved invalid input/output kinds.");
-				let affected = evaluation.reset;
-				if (evaluation.reset || keyRevision !== selectedKey.revision) {
-					const candidate = selectedKey.value;
-					if (candidate !== void 0 && typeof candidate !== "string") throw new TypeError("derive.keyed.get key must resolve to a string or undefined.");
-					selected = candidate;
-					affected = true;
-				} else if (sourceRevision !== collection.revision) {
-					const change = collection.change;
-					if (!change || change.kind === "reset") affected = true;
-					else if (selected !== void 0) affected = require_transform.collectionChangeTouchesKey(change, selected);
-				}
-				if (affected) output.output.set(selected === void 0 ? void 0 : collection.read.get(selected));
-				sourceRevision = collection.revision;
-				keyRevision = selectedKey.revision;
-			} };
-		},
-		name: "derive.keyed.get"
-	});
-	return projection;
-};
 function createKeyedFilter(source, dependenciesOrPredicate, maybePredicate) {
 	const dependencySpecs = typeof dependenciesOrPredicate === "function" ? void 0 : dependenciesOrPredicate;
 	const predicate = dependencySpecs === void 0 ? dependenciesOrPredicate : maybePredicate;
@@ -3400,101 +3506,6 @@ function createKeyedCompact(source, dependenciesOrSelect, selectOrEquality, mayb
 		}
 	});
 }
-const createKeyedSubset = (source, orderedKeys) => {
-	require_transform.assertKeyedProjection(source, "Keyed subset source");
-	const keyProjection = require_transform.isProjection(orderedKeys) ? orderedKeys : void 0;
-	if (keyProjection && require_transform.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_transform.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 normalizeGroups = (value) => {
 	const groups = typeof value === "string" ? [value] : value;
 	if (!Array.isArray(groups)) throw new TypeError("derive.keyed.groupBy selector must return a string or an array of strings.");

package/dist/index.d.cts

@@ -33,6 +33,13 @@ declare function observe<S extends ObjectSchema<object>, P>(document: ReadonlyDo
 type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>> & Partial<Record<keyof Projection<unknown>, never>>;
 type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
 //#endregion
+//#region core/src/projection/keyed/selection.d.ts
+type Equality$3<T> = (previous: T, next: T) => boolean;
+declare function createKeyedGet<K extends string, V>(source: KeyedProjection<K, V>, key: NoInfer<K> | undefined | Projection<NoInfer<K> | undefined>, equality?: Equality$3<NoInfer<V> | undefined>): Projection<V | undefined>;
+declare function createKeyedGet<K extends string, V, const D extends ProjectionDependencies>(source: KeyedProjection<K, V>, dependencies: D, selectKey: (values: ProjectionValues<D>) => Synchronous<NoInfer<K> | undefined>, equality?: Equality$3<NoInfer<V> | undefined>): Projection<V | undefined>;
+declare function createKeyedSubset<K extends string, V>(source: KeyedProjection<K, V>, orderedKeys: Projection<readonly NoInfer<K>[]> | readonly NoInfer<K>[]): KeyedProjection<K, V>;
+declare function createKeyedSubset<K extends string, V, const D extends ProjectionDependencies>(source: KeyedProjection<K, V>, dependencies: D, selectOrderedKeys: (values: ProjectionValues<D>) => Synchronous<readonly NoInfer<K>[]>): KeyedProjection<K, V>;
+//#endregion
 //#region core/src/projection/keyed/entries.d.ts
 type KeyedEntries<K extends string, V> = readonly (readonly [K, V])[];
 //#endregion
@@ -72,7 +79,7 @@ declare const derive: typeof createValueDerive & {
     keys: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly K[]>;
     values: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly V[]>;
     entries: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly (readonly [K, V])[]>;
-    get: <K extends string, V>(source: KeyedProjection<K, V>, key: Projection<NoInfer<K> | undefined>, equality?: (previous: V | undefined, next: V | undefined) => boolean) => Projection<V | undefined>;
+    get: typeof createKeyedGet;
     from: typeof createKeyedFrom;
     fromEntries: typeof createKeyedFromEntries;
     merge: typeof createKeyedMerge;
@@ -82,7 +89,7 @@ declare const derive: typeof createValueDerive & {
     };
     flatMap: typeof createKeyedFlatMap;
     singleton: typeof createKeyedSingleton;
-    subset: <K extends string, V>(source: KeyedProjection<K, V>, orderedKeys: Projection<readonly K[]> | readonly K[]) => KeyedProjection<K, V>;
+    subset: typeof createKeyedSubset;
     filter: {
       <K extends string, V>(source: KeyedProjection<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<boolean>): KeyedProjection<K, V>;
       <K extends string, V, const D extends object>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, predicate: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<boolean>): KeyedProjection<K, V>;

package/dist/index.d.ts

@@ -33,6 +33,13 @@ declare function observe<S extends ObjectSchema<object>, P>(document: ReadonlyDo
 type ProjectionDependencies = Readonly<Record<string, Projection<unknown>>> & Partial<Record<keyof Projection<unknown>, never>>;
 type ProjectionValues<D extends ProjectionDependencies> = { readonly [K in keyof D]: D[K] extends Projection<infer T> ? T : never };
 //#endregion
+//#region core/src/projection/keyed/selection.d.ts
+type Equality$3<T> = (previous: T, next: T) => boolean;
+declare function createKeyedGet<K extends string, V>(source: KeyedProjection<K, V>, key: NoInfer<K> | undefined | Projection<NoInfer<K> | undefined>, equality?: Equality$3<NoInfer<V> | undefined>): Projection<V | undefined>;
+declare function createKeyedGet<K extends string, V, const D extends ProjectionDependencies>(source: KeyedProjection<K, V>, dependencies: D, selectKey: (values: ProjectionValues<D>) => Synchronous<NoInfer<K> | undefined>, equality?: Equality$3<NoInfer<V> | undefined>): Projection<V | undefined>;
+declare function createKeyedSubset<K extends string, V>(source: KeyedProjection<K, V>, orderedKeys: Projection<readonly NoInfer<K>[]> | readonly NoInfer<K>[]): KeyedProjection<K, V>;
+declare function createKeyedSubset<K extends string, V, const D extends ProjectionDependencies>(source: KeyedProjection<K, V>, dependencies: D, selectOrderedKeys: (values: ProjectionValues<D>) => Synchronous<readonly NoInfer<K>[]>): KeyedProjection<K, V>;
+//#endregion
 //#region core/src/projection/keyed/entries.d.ts
 type KeyedEntries<K extends string, V> = readonly (readonly [K, V])[];
 //#endregion
@@ -72,7 +79,7 @@ declare const derive: typeof createValueDerive & {
     keys: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly K[]>;
     values: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly V[]>;
     entries: <K extends string, V>(source: KeyedProjection<K, V>) => Projection<readonly (readonly [K, V])[]>;
-    get: <K extends string, V>(source: KeyedProjection<K, V>, key: Projection<NoInfer<K> | undefined>, equality?: (previous: V | undefined, next: V | undefined) => boolean) => Projection<V | undefined>;
+    get: typeof createKeyedGet;
     from: typeof createKeyedFrom;
     fromEntries: typeof createKeyedFromEntries;
     merge: typeof createKeyedMerge;
@@ -82,7 +89,7 @@ declare const derive: typeof createValueDerive & {
     };
     flatMap: typeof createKeyedFlatMap;
     singleton: typeof createKeyedSingleton;
-    subset: <K extends string, V>(source: KeyedProjection<K, V>, orderedKeys: Projection<readonly K[]> | readonly K[]) => KeyedProjection<K, V>;
+    subset: typeof createKeyedSubset;
     filter: {
       <K extends string, V>(source: KeyedProjection<K, V>, predicate: (value: NoInfer<V>, key: NoInfer<K>) => Synchronous<boolean>): KeyedProjection<K, V>;
       <K extends string, V, const D extends object>(source: KeyedProjection<K, V>, dependencies: D & KeyedDependencies<NoInfer<K>, NoInfer<V>, D>, predicate: (value: NoInfer<V>, key: NoInfer<K>, dependencies: KeyedDependencyValues<D>) => Synchronous<boolean>): KeyedProjection<K, V>;

package/dist/index.js

@@ -1,4 +1,4 @@
-import { A as ownProjections, C as snapshotProjectionValues, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform-3mj0eStL.js";
+import { A as ownProjections, C as snapshotProjectionValues, D as defineProcessor, E as snapshotCollectionView, M as projectionRef, N as profile, O as defineSource, S as compileProjectionDependencies, T as mapRead, _ as assertSynchronous, a as collectionChangeTouchesKey, b as ProjectionError, c as assertKeyedProjection, d as outputKind, f as createKeyRelation, g as assertScope, h as snapshotArray, i as collectionChangeIntersects, j as producerOf, k as isProjection, l as compileKeyedDependencies, m as sameArray, n as keyedAbsent, o as collectionHasStructuralChange, p as iterableMatchesArray, s as createCollectionChange, t as createKeyedTransform, u as createKeyedDependencyRuntime, v as createScheduler, w as collectionView, x as collectKeyedInvalidation, y as ProjectionDisposedError } from "./transform--WCn6_v0.js";
 import { n as isPlainObject, r as isRecord, t as installOwn } from "./record-B2yRhYsc.js";
 import { c as AddressIndex, d as invalidValue, f as children, g as validate, h as parent, i as contextOf, l as MutationRejected, m as is, o as decodeChanges, p as contains$1, r as bindContext, s as sealChanges, t as assertRuntimeWritable, u as fail } from "./driver-B7RR-VfX.js";
 //#region core/src/schema/model.ts
@@ -2882,6 +2882,163 @@ function createKeyedFlatMap(source, dependenciesOrSelect, selectOrEquality, mayb
 	return projection;
 }
 //#endregion
+//#region core/src/projection/keyed/selection.ts
+/** Compiles selection inputs; runtime instances retain only the request and its dependency revisions.
+* Source slot zero belongs to the collection being queried, not to the selection expression.
+*/
+const compileSelection = (input, named, select, normalize, name) => {
+	let projections;
+	let compute;
+	let initial;
+	if (named) {
+		const compiled = compileProjectionDependencies(input, name);
+		if (typeof select !== "function") throw new TypeError(`${name} requires a selection callback.`);
+		projections = compiled.projections;
+		const selectValues = select;
+		compute = (sources) => selectValues(snapshotProjectionValues(compiled.names, sources, 1));
+	} else if (isProjection(input)) {
+		if (outputKind(input) !== "value") throw new TypeError(`${name} selection must be a scalar projection.`);
+		projections = [input];
+		compute = (sources) => {
+			const source = sources[1];
+			if (source?.kind !== "value") throw new Error(`${name} resolved a non-scalar selection.`);
+			return source.value;
+		};
+	} else {
+		projections = [];
+		initial = normalize(input);
+	}
+	return {
+		projections,
+		create: () => {
+			let initialized = compute === void 0;
+			let current = initial;
+			const revisions = new Array(projections.length).fill(-1);
+			return {
+				get value() {
+					if (!initialized) throw new Error(`${name} selection was not initialized.`);
+					return current;
+				},
+				refresh(sources) {
+					if (!compute) return false;
+					let dirty = !initialized;
+					for (let index = 0; index < revisions.length; index++) {
+						const source = sources[index + 1];
+						if (source.reset || source.revision !== revisions[index]) dirty = true;
+					}
+					if (!dirty) return false;
+					const candidate = compute(sources);
+					assertSynchronous(candidate);
+					const next = normalize(candidate, current);
+					const changed = !initialized || !Object.is(current, next);
+					current = next;
+					initialized = true;
+					for (let index = 0; index < revisions.length; index++) revisions[index] = sources[index + 1].revision;
+					return changed;
+				}
+			};
+		}
+	};
+};
+const normalizeKey = (value) => {
+	if (value !== void 0 && typeof value !== "string") throw new TypeError("derive.keyed.get key must be a string or undefined.");
+	return value;
+};
+const normalizeOrderedKeys = (value, previous) => {
+	if (!Array.isArray(value)) throw new TypeError("derive.keyed.subset ordered keys must be an array.");
+	if (previous && sameArray(previous.keys, value)) return previous;
+	const requested = /* @__PURE__ */ new Set();
+	for (const key of value) {
+		if (typeof key !== "string") throw new TypeError("derive.keyed.subset keys must be strings.");
+		if (requested.has(key)) throw new TypeError("derive.keyed.subset keys must not contain duplicate keys.");
+		requested.add(key);
+	}
+	return {
+		keys: snapshotArray(value),
+		requested
+	};
+};
+function createKeyedGet(source, input, selectOrEquality, maybeEquality) {
+	const name = "derive.keyed.get";
+	assertKeyedProjection(source, `${name} source`);
+	const named = !isProjection(input) && typeof input !== "string" && input !== void 0;
+	const selection = compileSelection(input, named, named ? selectOrEquality : void 0, normalizeKey, name);
+	const equality = named ? maybeEquality : selectOrEquality;
+	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${name} equality must be a function.`);
+	const [projection] = defineProcessor({
+		dependencies: [source, ...selection.projections],
+		outputs: [{
+			kind: "value",
+			equality: equality ?? Object.is
+		}],
+		name,
+		create: () => {
+			const selected = selection.create();
+			return { evaluate: (evaluation) => {
+				const collection = evaluation.sources[0];
+				const output = evaluation.outputs[0];
+				if (collection.kind !== "collection" || output.kind !== "value") throw new Error(`${name} resolved invalid input/output kinds.`);
+				const keyChanged = selected.refresh(evaluation.sources);
+				const key = selected.value;
+				const change = collection.change;
+				if (evaluation.reset || keyChanged || change?.kind === "reset" || key !== void 0 && change && collectionChangeTouchesKey(change, key)) output.output.set(key === void 0 ? void 0 : collection.read.get(key));
+			} };
+		}
+	});
+	return projection;
+}
+function createKeyedSubset(source, input, selectOrderedKeys) {
+	const name = "derive.keyed.subset";
+	assertKeyedProjection(source, `${name} source`);
+	const selection = compileSelection(input, !isProjection(input) && !Array.isArray(input), selectOrderedKeys, normalizeOrderedKeys, name);
+	const [projection] = defineProcessor({
+		dependencies: [source, ...selection.projections],
+		outputs: [{
+			kind: "collection",
+			equality: Object.is
+		}],
+		name,
+		create: () => {
+			const selected = selection.create();
+			return { evaluate: (evaluation) => {
+				const driver = evaluation.sources[0];
+				const output = evaluation.outputs[0];
+				if (driver.kind !== "collection" || output.kind !== "collection") throw new Error(`${name} requires collection input and output.`);
+				const keysChanged = selected.refresh(evaluation.sources);
+				const { keys, requested } = selected.value;
+				const change = driver.change;
+				if (evaluation.reset || change?.kind === "reset") {
+					const present = keys.filter((key) => driver.read.has(key));
+					for (const key of present) output.output.set(key, driver.read.get(key));
+					output.output.order(present);
+					return;
+				}
+				let orderChanged = keysChanged;
+				if (keysChanged) {
+					for (const key of output.previous.ids()) if (!requested.has(key) || !driver.read.has(key)) output.output.remove(key);
+					for (const key of keys) if (!output.previous.has(key) && driver.read.has(key)) output.output.set(key, driver.read.get(key));
+				} else if (change) {
+					for (const entry of change.removed) {
+						if (!requested.has(entry.key)) continue;
+						output.output.remove(entry.key);
+						orderChanged = true;
+					}
+					for (const entry of change.added) {
+						if (!requested.has(entry.key)) continue;
+						output.output.set(entry.key, entry.after);
+						orderChanged = true;
+					}
+				}
+				if (change) {
+					for (const entry of change.updated) if (requested.has(entry.key) && (!keysChanged || output.previous.has(entry.key))) output.output.set(entry.key, entry.after);
+				}
+				if (orderChanged) output.output.order(keys.filter((key) => driver.read.has(key)));
+			} };
+		}
+	});
+	return projection;
+}
+//#endregion
 //#region core/src/projection/keyed/composition.ts
 const assertEquality = (equality, role) => {
 	if (equality !== void 0 && typeof equality !== "function") throw new TypeError(`${role} equality must be a function.`);
@@ -3210,19 +3367,6 @@ function createKeyedSingleton(sourceOrDependencies, compute, equality) {
 }
 //#endregion
 //#region core/src/projection/derive/keyed.ts
-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
-	};
-};
 function createKeyedDerive(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
 	const dependencySpecs = typeof dependenciesOrSelect === "function" ? void 0 : dependenciesOrSelect;
 	const select = dependencySpecs === void 0 ? dependenciesOrSelect : selectOrEquality;
@@ -3327,44 +3471,6 @@ const createOrderedSnapshot = (source, name, make) => {
 };
 const createKeyedValues = (source) => createOrderedSnapshot(source, "derive.keyed.values", (_key, value) => value);
 const createKeyedEntries = (source) => createOrderedSnapshot(source, "derive.keyed.entries", (key, value) => Object.freeze([key, value]));
-const createKeyedGet = (source, key, equality = Object.is) => {
-	assertKeyedProjection(source, "derive.keyed.get source");
-	if (outputKind(key) !== "value") throw new TypeError("derive.keyed.get key must be a scalar projection.");
-	const [projection] = defineProcessor({
-		dependencies: [source, key],
-		outputs: [{
-			kind: "value",
-			equality
-		}],
-		create: () => {
-			let sourceRevision = -1;
-			let keyRevision = -1;
-			let selected;
-			return { evaluate: (evaluation) => {
-				const collection = evaluation.sources[0];
-				const selectedKey = evaluation.sources[1];
-				const output = evaluation.outputs[0];
-				if (collection.kind !== "collection" || selectedKey.kind !== "value" || output.kind !== "value") throw new Error("derive.keyed.get resolved invalid input/output kinds.");
-				let affected = evaluation.reset;
-				if (evaluation.reset || keyRevision !== selectedKey.revision) {
-					const candidate = selectedKey.value;
-					if (candidate !== void 0 && typeof candidate !== "string") throw new TypeError("derive.keyed.get key must resolve to a string or undefined.");
-					selected = candidate;
-					affected = true;
-				} else if (sourceRevision !== collection.revision) {
-					const change = collection.change;
-					if (!change || change.kind === "reset") affected = true;
-					else if (selected !== void 0) affected = collectionChangeTouchesKey(change, selected);
-				}
-				if (affected) output.output.set(selected === void 0 ? void 0 : collection.read.get(selected));
-				sourceRevision = collection.revision;
-				keyRevision = selectedKey.revision;
-			} };
-		},
-		name: "derive.keyed.get"
-	});
-	return projection;
-};
 function createKeyedFilter(source, dependenciesOrPredicate, maybePredicate) {
 	const dependencySpecs = typeof dependenciesOrPredicate === "function" ? void 0 : dependenciesOrPredicate;
 	const predicate = dependencySpecs === void 0 ? dependenciesOrPredicate : maybePredicate;
@@ -3399,101 +3505,6 @@ function createKeyedCompact(source, dependenciesOrSelect, selectOrEquality, mayb
 		}
 	});
 }
-const createKeyedSubset = (source, orderedKeys) => {
-	assertKeyedProjection(source, "Keyed subset source");
-	const keyProjection = 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] = 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 normalizeGroups = (value) => {
 	const groups = typeof value === "string" ? [value] : value;
 	if (!Array.isArray(groups)) throw new TypeError("derive.keyed.groupBy selector must return a string or an array of strings.");

package/dist/{transform-3mj0eStL.js → transform--WCn6_v0.js}

@@ -1,5 +1,6 @@
 import { n as isPlainObject } from "./record-B2yRhYsc.js";
 const profile = {
+	keyRelation: (key, amount = 1) => {},
 	projection: (key, amount = 1) => {},
 	recorder: (key, amount = 1) => {},
 	access: (key) => {},
@@ -186,9 +187,9 @@ const readNamedDependencyEntries = (dependencies, label) => {
 /** Creates the durable dependency value exposed to pure derive callbacks. */
 const snapshotDependencyValue = (source) => source.kind === "value" ? source.value : snapshotCollectionView(source.read);
 /** Builds the same readonly named value boundary for scalar and keyed pure computations. */
-const snapshotProjectionValues = (names, sources) => {
+const snapshotProjectionValues = (names, sources, offset = 0) => {
 	const values = Object.create(null);
-	for (let index = 0; index < names.length; index++) values[names[index]] = snapshotDependencyValue(sources[index]);
+	for (let index = 0; index < names.length; index++) values[names[index]] = snapshotDependencyValue(sources[offset + index]);
 	return Object.freeze(values);
 };
 /** Compiles the shared named Projection dependency declaration contract. */
@@ -661,57 +662,95 @@ const iterableMatchesArray = (values, expected) => {
 };
 //#endregion
 //#region core/src/projection/keyed/relation.ts
-/** Runtime-local domain-neutral many-to-many keyed relation. */
+/** Runtime-local many-to-many relation. Callers validate unique string keys before replacing.
+* Forward order is meaningful; reverse sets and map iteration carry no formal order.
+*/
 const createKeyRelation = () => {
 	const forward = /* @__PURE__ */ new Map();
 	const reverse = /* @__PURE__ */ new Map();
 	const detach = (left, right) => {
-		for (const key of right) {
-			const dependents = reverse.get(key);
-			dependents?.delete(left);
-			if (dependents?.size === 0) reverse.delete(key);
+		const dependents = reverse.get(right);
+		if (!dependents?.delete(left)) return;
+		profile.keyRelation("detachedEdges");
+		if (dependents.size === 0) {
+			reverse.delete(right);
+			profile.keyRelation("deletedBuckets");
 		}
 	};
 	const attach = (left, right) => {
-		for (const key of right) {
-			const dependents = reverse.get(key);
-			if (dependents) dependents.add(left);
-			else reverse.set(key, new Set([left]));
+		const dependents = reverse.get(right);
+		if (dependents) {
+			if (dependents.has(left)) return false;
+			dependents.add(left);
+		} else {
+			reverse.set(right, new Set([left]));
+			profile.keyRelation("createdBuckets");
 		}
+		profile.keyRelation("attachedEdges");
+		return true;
 	};
 	return {
 		replaceOne(left, right) {
 			const previous = forward.get(left);
 			if (right === void 0) {
 				if (!previous) return false;
-				detach(left, previous);
+				for (const key of previous) detach(left, key);
 				forward.delete(left);
 				return true;
 			}
 			if (previous?.length === 1 && previous[0] === right) return false;
-			if (previous) detach(left, previous);
 			const next = Object.freeze([right]);
+			if (previous) {
+				for (const key of previous) if (key !== right) detach(left, key);
+			}
+			attach(left, right);
 			forward.set(left, next);
-			attach(left, next);
 			return true;
 		},
 		replace(left, right) {
 			const previous = forward.get(left);
-			if (previous ? sameArray(previous, right) : right.length === 0) return false;
-			if (previous) detach(left, previous);
+			if (!previous) {
+				if (!right.length) return false;
+				const next = snapshotArray(right);
+				for (const key of next) attach(left, key);
+				forward.set(left, next);
+				return true;
+			}
+			if (previous === right) return false;
 			if (!right.length) {
+				for (const key of previous) detach(left, key);
 				forward.delete(left);
 				return true;
 			}
+			let start = 0;
+			while (start < previous.length && start < right.length && previous[start] === right[start]) start++;
+			if (start === previous.length && start === right.length) return false;
 			const next = snapshotArray(right);
+			let oldEnd = previous.length;
+			let nextEnd = next.length;
+			while (oldEnd > start && nextEnd > start && previous[oldEnd - 1] === next[nextEnd - 1]) {
+				oldEnd--;
+				nextEnd--;
+			}
+			let retained = 0;
+			for (let index = start; index < nextEnd; index++) if (!attach(left, next[index])) retained++;
+			if (retained === 0) for (let index = start; index < oldEnd; index++) detach(left, previous[index]);
+			else if (retained < oldEnd - start) if (nextEnd - start === 1) {
+				for (let index = start; index < oldEnd; index++) if (previous[index] !== next[start]) detach(left, previous[index]);
+			} else {
+				const requested = /* @__PURE__ */ new Set();
+				for (let index = start; index < nextEnd; index++) requested.add(next[index]);
+				profile.keyRelation("diffSets");
+				profile.keyRelation("diffKeys", requested.size);
+				for (let index = start; index < oldEnd; index++) if (!requested.has(previous[index])) detach(left, previous[index]);
+			}
 			forward.set(left, next);
-			attach(left, next);
 			return true;
 		},
 		delete(left) {
 			const previous = forward.get(left);
 			if (!previous) return false;
-			detach(left, previous);
+			for (const key of previous) detach(left, key);
 			forward.delete(left);
 			return true;
 		},

package/dist/{transform-D45KWMzj.cjs → transform-8xXf0OKB.cjs}

@@ -1,5 +1,6 @@
 const require_record = require("./record-ChYUi8PP.cjs");
 const profile = {
+	keyRelation: (key, amount = 1) => {},
 	projection: (key, amount = 1) => {},
 	recorder: (key, amount = 1) => {},
 	access: (key) => {},
@@ -186,9 +187,9 @@ const readNamedDependencyEntries = (dependencies, label) => {
 /** Creates the durable dependency value exposed to pure derive callbacks. */
 const snapshotDependencyValue = (source) => source.kind === "value" ? source.value : snapshotCollectionView(source.read);
 /** Builds the same readonly named value boundary for scalar and keyed pure computations. */
-const snapshotProjectionValues = (names, sources) => {
+const snapshotProjectionValues = (names, sources, offset = 0) => {
 	const values = Object.create(null);
-	for (let index = 0; index < names.length; index++) values[names[index]] = snapshotDependencyValue(sources[index]);
+	for (let index = 0; index < names.length; index++) values[names[index]] = snapshotDependencyValue(sources[offset + index]);
 	return Object.freeze(values);
 };
 /** Compiles the shared named Projection dependency declaration contract. */
@@ -661,57 +662,95 @@ const iterableMatchesArray = (values, expected) => {
 };
 //#endregion
 //#region core/src/projection/keyed/relation.ts
-/** Runtime-local domain-neutral many-to-many keyed relation. */
+/** Runtime-local many-to-many relation. Callers validate unique string keys before replacing.
+* Forward order is meaningful; reverse sets and map iteration carry no formal order.
+*/
 const createKeyRelation = () => {
 	const forward = /* @__PURE__ */ new Map();
 	const reverse = /* @__PURE__ */ new Map();
 	const detach = (left, right) => {
-		for (const key of right) {
-			const dependents = reverse.get(key);
-			dependents?.delete(left);
-			if (dependents?.size === 0) reverse.delete(key);
+		const dependents = reverse.get(right);
+		if (!dependents?.delete(left)) return;
+		profile.keyRelation("detachedEdges");
+		if (dependents.size === 0) {
+			reverse.delete(right);
+			profile.keyRelation("deletedBuckets");
 		}
 	};
 	const attach = (left, right) => {
-		for (const key of right) {
-			const dependents = reverse.get(key);
-			if (dependents) dependents.add(left);
-			else reverse.set(key, new Set([left]));
+		const dependents = reverse.get(right);
+		if (dependents) {
+			if (dependents.has(left)) return false;
+			dependents.add(left);
+		} else {
+			reverse.set(right, new Set([left]));
+			profile.keyRelation("createdBuckets");
 		}
+		profile.keyRelation("attachedEdges");
+		return true;
 	};
 	return {
 		replaceOne(left, right) {
 			const previous = forward.get(left);
 			if (right === void 0) {
 				if (!previous) return false;
-				detach(left, previous);
+				for (const key of previous) detach(left, key);
 				forward.delete(left);
 				return true;
 			}
 			if (previous?.length === 1 && previous[0] === right) return false;
-			if (previous) detach(left, previous);
 			const next = Object.freeze([right]);
+			if (previous) {
+				for (const key of previous) if (key !== right) detach(left, key);
+			}
+			attach(left, right);
 			forward.set(left, next);
-			attach(left, next);
 			return true;
 		},
 		replace(left, right) {
 			const previous = forward.get(left);
-			if (previous ? sameArray(previous, right) : right.length === 0) return false;
-			if (previous) detach(left, previous);
+			if (!previous) {
+				if (!right.length) return false;
+				const next = snapshotArray(right);
+				for (const key of next) attach(left, key);
+				forward.set(left, next);
+				return true;
+			}
+			if (previous === right) return false;
 			if (!right.length) {
+				for (const key of previous) detach(left, key);
 				forward.delete(left);
 				return true;
 			}
+			let start = 0;
+			while (start < previous.length && start < right.length && previous[start] === right[start]) start++;
+			if (start === previous.length && start === right.length) return false;
 			const next = snapshotArray(right);
+			let oldEnd = previous.length;
+			let nextEnd = next.length;
+			while (oldEnd > start && nextEnd > start && previous[oldEnd - 1] === next[nextEnd - 1]) {
+				oldEnd--;
+				nextEnd--;
+			}
+			let retained = 0;
+			for (let index = start; index < nextEnd; index++) if (!attach(left, next[index])) retained++;
+			if (retained === 0) for (let index = start; index < oldEnd; index++) detach(left, previous[index]);
+			else if (retained < oldEnd - start) if (nextEnd - start === 1) {
+				for (let index = start; index < oldEnd; index++) if (previous[index] !== next[start]) detach(left, previous[index]);
+			} else {
+				const requested = /* @__PURE__ */ new Set();
+				for (let index = start; index < nextEnd; index++) requested.add(next[index]);
+				profile.keyRelation("diffSets");
+				profile.keyRelation("diffKeys", requested.size);
+				for (let index = start; index < oldEnd; index++) if (!requested.has(previous[index])) detach(left, previous[index]);
+			}
 			forward.set(left, next);
-			attach(left, next);
 			return true;
 		},
 		delete(left) {
 			const previous = forward.get(left);
 			if (!previous) return false;
-			detach(left, previous);
+			for (const key of previous) detach(left, key);
 			forward.delete(left);
 			return true;
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doxum",
-  "version": "0.1.38",
+  "version": "0.1.40",
   "private": false,
   "license": "MIT",
   "description": "Doxum is a typed runtime for complex mutable documents.",

package/skills/doxum-runtime/SKILL.md

@@ -45,7 +45,7 @@ Follow these choices unless the requirement says otherwise:
 4. Use `observe` to bring a document/readable/external source into the projection graph.
 5. Use named-object `derive` for pure aggregate values.
 6. Use `derive.keyed.from` to turn an ordered scalar/static collection into a keyed projection. Use `derive.keyed.singleton({ inputs }, computeEntry)` for zero or one computed member (`[key, value]` or `undefined`), and `derive.keyed.fromEntries({ inputs }, compute)` for a complete keyed result of arbitrary size; use `flatMap` when individual keyed parents must recompute independently. Use `derive.keyed.merge` to compose multiple keyed projections; for base + sparse overrides, use `{ conflict: 'last' }`.
-7. Use `derive.keyed` when one keyed source owns output membership/order. Prefer its built-in `keys`, `values`, `entries`, `get`, `from`, `fromEntries`, `merge`, `subset`, `filter`, `compact`, `groupBy`, `flatMap`, and `singleton` primitives over hand-written incremental collection patches.
+7. Use `derive.keyed` when one keyed source owns output membership/order. Use `get(source, dependencies, selectKey)` or `subset(source, dependencies, selectOrderedKeys)` when named projections determine which existing members to read; static keys/key arrays and existing scalar selection projections also work. Prefer the keyed family's built-in primitives over hand-written incremental collection patches.
 8. Express per-output-key joins through `{ source }` for same-key lookup, `{ source, key }` for one mapped key, or `{ source, keys }` for several mapped keys. Let the Runtime own binding and reverse invalidation; do not maintain an application `Map` just to route dependency changes.
 9. Use `runtime.items(keyedProjection)` or `scope.items(...)` for stable per-membership item `Readable`s.
 10. Use `incremental.keyed` for independent retained state per driver key. Use `incremental.collection` or `incremental.group` only when direct incremental output patching or shared retained state is required.

package/skills/doxum-runtime/references/invariants.md

@@ -41,7 +41,11 @@ This file is maintainer-only. Application/library consumers should use [Public A
    remains static. `derive.keyed` declares extra sources in one named dependency object;
    `{ source, key }` members bind one source key and `{ source, keys }` members bind an
    ordered duplicate-free set of source keys for each output key. The materialized Runtime owns those bindings and reverse indexes,
-   including bindings to currently missing source entries. Processors do not create graph
+   including bindings to currently missing source entries. `projection/keyed/relation.ts`
+   owns edge differences and ordered forward snapshots. Keep retained reverse buckets intact;
+   pure reorder changes forward order even with zero edge writes. Callers validate unique
+   string keys, and reverse iteration is not formal order. Sequence comparison and
+   dependency snapshots can still cost O(number of selected keys). Processors do not create graph
    dependencies through imperative Runtime reads. A scope adds lifecycle ownership only
    through `scope.own`; scoped definitions may depend on root definitions, while root and
    sibling scopes cannot depend on scoped definitions. Notification failures leave commits

package/skills/doxum-runtime/references/projections.md

@@ -167,9 +167,26 @@ Produces ordered readonly `[key,value]` tuples. Value-only updates publish corre
 
 ```ts
 const active = derive.keyed.get(rows, activeId);
+const fixed = derive.keyed.get(rows, rowId);
+const selected = derive.keyed.get(rows, { selection }, ({ selection }) => selection.activeRowId);
 ```
 
-`activeId` is a scalar `Projection<K | undefined>`. The derive binds exactly the selected key. If the key is absent, the result is `undefined` while the binding remains live for later add.
+`activeId` may be a static `K | undefined` or scalar `Projection<K | undefined>`.
+Named form accepts ordinary projection dependencies, including `{}`, and a synchronous
+callback returning `K | undefined`. The source owns K/V; callback results, key projections
+and equality must agree with those domains. The result is `Projection<V | undefined>`.
+An absent selected key remains requested for later add; undefined selects no key.
+Optional result equality defaults to `Object.is` and retains equivalent references.
+
+Named selectors run on initialization, declared dependency changes or recovery. Source
+updates inspect deltas for the selected key; source-only reorder is ignored. Unrelated
+updates can wake the processor but do not rerun selectors or change output. Keyed named
+dependencies are whole snapshots: explicitly declaring the queried source as a named
+dependency also makes its changes relevant to the selector. Public Runtime reads and
+driver-relative dependency specs are not allowed inside this protocol. Callback, key
+validation and equality failures follow normal recovery without partial publication.
+Definitions are lazy, scoped and isolated per runtime; current batch reads and deferred
+notifications use the ordinary runtime contract.
 
 Use this for active entity, editor target, selected record, or current-cell lookups.
 
@@ -242,11 +259,32 @@ Value-only source changes only recompute affected keys. Structural or source-ord
 
 ```ts
 const visibleRows = derive.keyed.subset(rows, orderedVisibleIds);
+const selectedRows = derive.keyed.subset(rows, { selection }, ({ selection }) => selection.rowIds);
 ```
 
 Output order is `orderedVisibleIds ∩ source membership`. Missing requested ids remain latent and appear later if the source adds them. Duplicate requested keys are invalid. Values are source values and are not re-derived.
 
-Use `subset` when another projection or static array already owns the requested order.
+The second argument may be a static readonly key array or a scalar key-array projection.
+Named form accepts ordinary projection dependencies (including `{}`) and a synchronous
+callback returning `readonly K[]`. The source owns K/V; selection cannot widen the key
+domain. `[]` is empty; undefined, malformed arrays and duplicate keys (even absent ones)
+are errors. Static arrays are snapshotted at definition time; dynamic arrays are captured
+when accepted. Equal sequences reuse request state, regardless of array identity.
+
+Dependency changes rerun the selector. Source-only updates filter the existing request;
+they do not rerun selectors. Selected values update with the source's original identity,
+missing keys join when added, and source-only reorder is ignored. Subset has no value
+or keys equality option. A selection change and value change in one evaluation both
+take effect, even when the key sequence remains equal. Reset/recovery, scope disposal,
+runtime isolation and notification-boundary item lifecycles follow the normal contract.
+
+Each get/subset uses one processor and one output. Source-delta filtering can cost
+O(delta size + selection dependency count); the processor can wake for unrelated source
+changes. It does not scan all source members. Structural changes/reset may scan requested
+keys and prior output. Selection changes pay callback, normalization and dependency
+snapshot costs. Named keyed dependencies are whole snapshots; including the queried
+source explicitly can rerun the selector on its changes. Use `get`/`subset` to select
+existing members and `singleton`/`fromEntries` to construct new keyed results.
 
 ### `filter`
 

package/skills/doxum-runtime/references/public-api.md

@@ -345,7 +345,9 @@ derive.keyed(source, dependencies, (value, key, dependencies) => result, equalit
 derive.keyed.keys(source): Projection<readonly K[]>
 derive.keyed.values(source): Projection<readonly V[]>
 derive.keyed.entries(source): Projection<readonly (readonly [K,V])[]>
-derive.keyed.get(source, keyProjection, equality?): Projection<V | undefined>
+derive.keyed.get(source, keyOrProjection, equality?): Projection<V | undefined>
+derive.keyed.get(source, dependencies, selectKey, equality?): Projection<V | undefined>
+// selectKey(readonlyNamedValues) returns Synchronous<K | undefined>
 derive.keyed.from(source: Projection<readonly V[]>, keyOf, equality?): KeyedProjection<K,V>
 derive.keyed.from(source: readonly V[], keyOf, equality?): KeyedProjection<K,V>
 derive.keyed.fromEntries(dependencies, compute, equality?): KeyedProjection<K,V>
@@ -354,6 +356,8 @@ derive.keyed.fromEntries(dependencies, compute, equality?): KeyedProjection<K,V>
 derive.keyed.merge(sources, { conflict: 'error' | 'first' | 'last', equality? }): KeyedProjection<K,V>
 derive.keyed.merge(sources, { conflict: 'resolve', resolve, equality? }): KeyedProjection<K,V>
 derive.keyed.subset(source, orderedKeysOrProjection): KeyedProjection<K,V>
+derive.keyed.subset(source, dependencies, selectOrderedKeys): KeyedProjection<K,V>
+// selectOrderedKeys(readonlyNamedValues) returns Synchronous<readonly K[]>
 derive.keyed.filter(source, predicate): KeyedProjection<K,V>
 derive.keyed.filter(source, dependencies, predicate): KeyedProjection<K,V>
 derive.keyed.compact(source, selector, equality?): KeyedProjection<K,T>
@@ -368,6 +372,8 @@ derive.keyed.singleton(dependencies, computeEntry, equality?): KeyedProjection<K
 // computeEntry(readonlyNamedValues) returns Synchronous<readonly [K,V] | undefined>
 ```
 
+`get` and `subset` accept named ordinary projection dependencies, including `{}`, to compute one optional key or an ordered key array. Source defines K/V; selectors and equality cannot widen them. Source-only updates filter deltas without rerunning selectors. Missing keys remain requested. Subset preserves source values and requested order, rejects duplicate keys, and has no equality option. Equal key sequences reuse request state. Get's optional result equality defaults to `Object.is`. Callback/validation/equality failure follows normal recovery without partial publication. Processors may inspect unrelated source deltas; this is not scheduler-level key subscription. A keyed named dependency is a whole snapshot, including when it is also the queried source. See [Precise scalar lookup](projections.md#precise-scalar-lookup) and [Subset](projections.md#subset).
+
 `from` uses `keyOf(value)` as member identity and preserves the input array's formal order. Duplicate keys are processor errors; there is no silent first/last overwrite. Static arrays are shallow-snapshotted at definition creation while `keyOf` remains lazy. For a scalar array projection, each scalar publication is scanned because the source has no per-entry delta. Equality defaults to `Object.is`; an equality-equivalent value under the same key retains the previous published value identity.
 
 `fromEntries` accepts the same named projection object as `derive`, including `{}` and keyed projections. Single inputs use `{ source }`; direct-source, static-array and driver-relative dependency specs are not overloads. The callback receives readonly named values and returns the complete ordered tuple array synchronously. Empty arrays mean no members; missing keys are removed; present `undefined` is valid. Duplicate string keys, malformed tuples and callback/equality failures follow processor error/recovery rules without partial installation. Per-entry equality defaults to `Object.is` and retains equivalent value references without suppressing membership or order. Computation scans the complete old/new result, while downstream publication is incremental. A keyed dependency is a whole collection, not automatically tracked by `get`; compose `derive.keyed.get` for precise scalar lookup. See [Projections](projections.md#keyed-results-from-named-dependencies) for lifecycle, cost and examples.

package/skills/doxum-runtime/references/recipes.md

@@ -323,10 +323,31 @@ Shared keys use override values while keeping the first formal position from `ba
 ```ts
 const activeId = input<RowId | undefined>(undefined);
 const activeRow = derive.keyed.get(rows, activeId);
+const selectedRow = derive.keyed.get(rows, { selection }, ({ selection }) => selection.activeRowId);
 ```
 
 The binding remains meaningful while the selected key is absent and reacts if that key appears later.
 
+Use a static key directly for a fixed lookup. Use named dependencies when an existing
+selection projection owns the key; an intermediate scalar derive is unnecessary.
+
+## Ordered selected members
+
+```ts
+const selectedNodes = derive.keyed.subset(
+  graph.node,
+  { selection },
+  ({ selection }) => selection.nodeIds
+);
+```
+
+Output follows `selection.nodeIds` order, including requested members that appear later
+in the source. Selected source values pass through by identity. Source-only updates do
+not rerun the selector; a new selection with equal keys does not produce a fake change.
+Use `[]` to select nothing and avoid duplicate keys. Keep source out of named dependencies
+unless computing the keys actually needs the entire source collection. The processor can
+still inspect unrelated source deltas; it does not rebuild the whole subset for them.
+
 ## Reverse index / groupBy
 
 ```ts