doxum 0.1.27 → 0.1.29

package/dist/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_scheduler = require("./scheduler-k1ZGR1PG.cjs");
+const require_transform = require("./transform-B6YxfR0R.cjs");
 const require_record = require("./record-ChYUi8PP.cjs");
-const require_driver = require("./driver-BL91gn7_.cjs");
+const require_driver = require("./driver-CN3dGxQI.cjs");
 //#region core/src/schema/model.ts
 const schemaNodeOf = (schema) => schema;
 const collectionEntryNode = (node) => node.kind === "map" || node.kind === "table" || node.kind === "list" ? node.value : void 0;
@@ -59,9 +59,9 @@ function tree(value) {
 const length$1 = (keys) => keys.length;
 const keyAt = (keys, index) => Array.isArray(keys) ? keys[index] : keys.at(index);
 const equal = (left, right) => {
-	require_scheduler.profile.equality.call();
+	require_transform.profile.equality.call();
 	if (left === right) return true;
-	require_scheduler.profile.equality.container();
+	require_transform.profile.equality.container();
 	if (left.length !== right.length) return false;
 	for (let index = 0; index < left.length; index++) if (left[index] !== keyAt(right, index)) return false;
 	return true;
@@ -84,7 +84,7 @@ const knownKeys = (values) => {
 			if (!positions) {
 				positions = /* @__PURE__ */ new Map();
 				for (let index = 0; index < values.length; index++) positions.set(values[index], index);
-				require_scheduler.profile.address.listIndex(values.length);
+				require_transform.profile.address.listIndex(values.length);
 			}
 			return positions.get(key) ?? -1;
 		}
@@ -108,7 +108,7 @@ const indexedKeys = (values, keyOf) => {
 			if (!positions) {
 				positions = /* @__PURE__ */ new Map();
 				for (let index = 0; index < values.length; index++) positions.set(keyOf(values[index]), index);
-				require_scheduler.profile.address.listIndex(values.length);
+				require_transform.profile.address.listIndex(values.length);
 			}
 			return positions.get(key) ?? -1;
 		}
@@ -187,7 +187,7 @@ const compiledShape = (node, value) => {
 	if (!layout) {
 		const members = /* @__PURE__ */ new Map();
 		for (const key of Object.keys(shape).sort()) {
-			require_scheduler.profile.address.schemaStep();
+			require_transform.profile.address.schemaStep();
 			members.set(key, {
 				kind: "fixed",
 				key,
@@ -341,7 +341,7 @@ const checkTreePayload = (node, value, address, strict = false) => {
 	return present ? checkValue(node, value.value, address, strict) : void 0;
 };
 const copyTreeNode = (value) => {
-	require_scheduler.profile.copy.treeNode();
+	require_transform.profile.copy.treeNode();
 	return {
 		...value,
 		children: [...value.children]
@@ -355,7 +355,7 @@ const equalTreeNode = (left, right) => {
 /** Copy editable structure; atomic payloads retain their immutable ownership contract. */
 const copyValue = (node, value) => {
 	if (value === void 0 || node.kind === "field") return value;
-	require_scheduler.profile.copy.structure();
+	require_transform.profile.copy.structure();
 	if ((node.kind === "object" || node.kind === "variant") && require_record.isRecord(value)) {
 		const result = Object.create(Object.getPrototypeOf(value));
 		const { members } = compiledShape(node, value);
@@ -519,8 +519,8 @@ const resolveWithPrefix = (schema, root, address, prefix) => {
 	}
 	let cacheable = true;
 	for (let index = start; index < address.length - 1; index += 1) {
-		require_scheduler.profile.address.schemaStep();
-		require_scheduler.profile.address.documentStep();
+		require_transform.profile.address.schemaStep();
+		require_transform.profile.address.documentStep();
 		const resolved = step(node, current, address[index]);
 		if (!resolved) return void 0;
 		if (node?.kind !== "object" && node?.kind !== "table" && node?.kind !== "map") cacheable = false;
@@ -538,8 +538,8 @@ const resolveWithPrefix = (schema, root, address, prefix) => {
 };
 /** Resolves one member from an already current schema/container pair. */
 const resolveChild = (node, current, last) => {
-	require_scheduler.profile.address.schemaStep();
-	require_scheduler.profile.address.documentStep();
+	require_transform.profile.address.schemaStep();
+	require_transform.profile.address.documentStep();
 	const resolved = step(node, current, last);
 	if (!resolved || !require_record.isRecord(current) && !Array.isArray(current)) return void 0;
 	if (node?.kind === "table" && require_record.isRecord(current) && require_record.isRecord(current.byId)) return {
@@ -569,18 +569,44 @@ const moveSelection = (current, selection, position) => {
 		selected.add(key);
 	}
 	const moved = [];
-	const remaining = [];
-	for (const key of current) (selected.has(key) ? moved : remaining).push(key);
+	let remainingLength = 0;
+	let anchorIndex = -1;
+	const anchoredKey = position && ("before" in position ? position.before : "after" in position ? position.after : void 0);
+	for (const key of current) {
+		if (selected.has(key)) {
+			moved.push(key);
+			continue;
+		}
+		if (key === anchoredKey) anchorIndex = remainingLength;
+		remainingLength++;
+	}
 	if (moved.length !== selected.size) return { kind: "missing" };
-	if (!valid(remaining, position)) return { kind: "invalid-anchor" };
-	const insertion = index(remaining, position);
+	let insertion;
+	if (!position || "at" in position && position.at === "end") insertion = remainingLength;
+	else if ("at" in position) {
+		if (position.at !== "start") return { kind: "invalid-anchor" };
+		insertion = 0;
+	} else {
+		if (anchorIndex < 0) return { kind: "invalid-anchor" };
+		insertion = "before" in position ? anchorIndex : anchorIndex + 1;
+	}
+	const order = new Array(current.length);
+	let outputIndex = 0;
+	let remainingIndex = 0;
+	let inserted = false;
+	for (const key of current) {
+		if (selected.has(key)) continue;
+		if (!inserted && remainingIndex === insertion) {
+			for (const movedKey of moved) order[outputIndex++] = movedKey;
+			inserted = true;
+		}
+		order[outputIndex++] = key;
+		remainingIndex++;
+	}
+	if (!inserted) for (const movedKey of moved) order[outputIndex++] = movedKey;
 	return {
 		kind: "ok",
-		order: [
-			...remaining.slice(0, insertion),
-			...moved,
-			...remaining.slice(insertion)
-		]
+		order
 	};
 };
 const index = (keys, anchor) => {
@@ -817,7 +843,7 @@ const sameTreeTarget = (left, right) => {
 	return left.kind !== "node" || right.kind === "node" && left.id === right.id;
 };
 const same = (left, right) => {
-	require_scheduler.profile.dependency.comparison();
+	require_transform.profile.dependency.comparison();
 	if ("schema" in left && "schema" in right && left.schema !== right.schema) return false;
 	if (!sameTreeTarget(treeTarget(left), treeTarget(right))) return false;
 	if (left.kind !== right.kind) return false;
@@ -825,7 +851,7 @@ const same = (left, right) => {
 	const rightAddress = address(right);
 	if (leftAddress.length !== rightAddress.length) return false;
 	for (let index = 0; index < leftAddress.length; index += 1) {
-		require_scheduler.profile.dependency.segmentCompared();
+		require_transform.profile.dependency.segmentCompared();
 		if (leftAddress[index] !== rightAddress[index]) return false;
 	}
 	return left.kind !== "collection" || id(left) === id(right);
@@ -938,7 +964,7 @@ const locations = /* @__PURE__ */ new WeakMap();
 const locationOf = (value) => locations.get(value);
 const addressOf = (target) => {
 	if (target.at) return target.at;
-	require_scheduler.profile.access("addresses");
+	require_transform.profile.access("addresses");
 	return target.at = addressOf(target.parent).concat(target.key);
 };
 const assertActive = (context) => {
@@ -960,7 +986,7 @@ const snapshot = (value) => {
 	if (!location) return value;
 	const { context } = location;
 	const at = addressOf(location.target);
-	require_scheduler.profile.access("snapshots");
+	require_transform.profile.access("snapshots");
 	collect(context, at);
 	const resolved = resolve(context, location.target);
 	if (!resolved.node) throw new Error("The selected schema address no longer exists.");
@@ -975,7 +1001,7 @@ const resolve = (context, target) => {
 	assertActive(context);
 	const generation = context.session?.generation ?? 0;
 	if (target.generation !== generation) {
-		require_scheduler.profile.access("resolutions");
+		require_transform.profile.access("resolutions");
 		if (!target.parent && !target.at.length) {
 			target.node = context.state.schema;
 			target.value = context.state.document;
@@ -990,7 +1016,7 @@ const resolve = (context, target) => {
 	return target;
 };
 const createAccess = (context, initial = []) => {
-	require_scheduler.profile.access("scopes");
+	require_transform.profile.access("scopes");
 	const mutable = () => {
 		assertActive(context);
 		if (!context.session) throw new TypeError("Cannot modify read-only document access.");
@@ -1001,13 +1027,13 @@ const createAccess = (context, initial = []) => {
 		return target.container = session.bind(addressOf(target), target.node, target.value);
 	};
 	const childAt = (target, key) => {
-		require_scheduler.profile.access("addresses");
+		require_transform.profile.access("addresses");
 		return addressOf(target).concat(key);
 	};
 	const access = (target) => {
 		if (target.proxy) return target.proxy;
 		const proxy = new Proxy(target, handler);
-		require_scheduler.profile.access("proxies");
+		require_transform.profile.access("proxies");
 		locations.set(proxy, {
 			context,
 			target
@@ -1365,14 +1391,25 @@ const compilePath = (owner, kind, pick) => {
 //#endregion
 //#region core/src/address/relation.ts
 const contains = (parent, child) => {
-	require_scheduler.profile.address.prefixComparison();
+	require_transform.profile.address.prefixComparison();
 	if (parent.length > child.length) return false;
 	for (let index = 0; index < parent.length; index += 1) {
-		require_scheduler.profile.address.segmentCompared();
+		require_transform.profile.address.segmentCompared();
 		if (parent[index] !== child[index]) return false;
 	}
 	return true;
 };
+/** Compare a virtual `[...base, segment]` address with an existing address without allocating it. */
+const compareExtended = (base, segment, other) => {
+	require_transform.profile.address.prefixComparison();
+	const length = base.length + 1;
+	const common = Math.min(length, other.length);
+	for (let index = 0; index < common; index += 1) {
+		require_transform.profile.address.segmentCompared();
+		if ((index < base.length ? base[index] : segment) !== other[index]) return "disjoint";
+	}
+	return length === other.length ? "equal" : length < other.length ? "ancestor" : "descendant";
+};
 //#endregion
 //#region core/src/impact.ts
 const createImpact = (schema, changes) => {
@@ -1381,7 +1418,7 @@ const createImpact = (schema, changes) => {
 	let orders;
 	const index = () => {
 		if (!values) {
-			require_scheduler.profile.impact.index();
+			require_transform.profile.impact.index();
 			values = new require_driver.AddressIndex();
 			orders = new require_driver.AddressIndex();
 			visitChangedLocations(changes, (at) => values.add(at, true), (at) => orders.add(at, true));
@@ -1390,7 +1427,7 @@ const createImpact = (schema, changes) => {
 	};
 	const cache = /* @__PURE__ */ new Map();
 	const affects = (value) => {
-		require_scheduler.profile.impact.affects();
+		require_transform.profile.impact.affects();
 		if (!belongs(value, schema)) return false;
 		if (reset) return true;
 		return affected(value, index(), orders);
@@ -1701,7 +1738,7 @@ const transition = (node, key, beforePresent, before, afterPresent, after) => {
 	if (beforePresent === afterPresent && (!beforePresent || Object.is(before, after))) return;
 	if (node.kind !== "field" && beforePresent === afterPresent && equalValue(node, before, after)) return;
 	const value = afterPresent ? node.kind === "field" ? after : copyValue(node, after) : void 0;
-	require_scheduler.profile.recorder("transitions");
+	require_transform.profile.recorder("transitions");
 	return !beforePresent ? {
 		key,
 		kind: "added",
@@ -1756,7 +1793,7 @@ const diffMember = (changes, members, node, at, key, beforePresent, before, afte
 			for (const id of Object.keys(right)) if (!Object.hasOwn(left, id)) diffMember(changes, children, node.value, childAt, id, false, void 0, true, right[id]);
 			let order;
 			if (node.kind === "table" && !equal(a.ids, b.ids)) {
-				require_scheduler.profile.recorder("publishedOrderItems", b.ids.length);
+				require_transform.profile.recorder("publishedOrderItems", b.ids.length);
 				order = {
 					before: a.ids,
 					after: [...b.ids]
@@ -1799,7 +1836,7 @@ const reconstructBefore = (node, current, records, offset) => {
 };
 const sealMembers = (fact, changes) => {
 	const members = [];
-	for (const member of fact.members?.values() ?? []) {
+	if (fact.members) for (const member of fact.members.values()) {
 		if (!member) continue;
 		const key = memberKey(fact, member.key);
 		const present = Object.hasOwn(fact.parent, key);
@@ -1814,7 +1851,7 @@ const sealMembers = (fact, changes) => {
 		const current = fact.node.kind === "list" ? indexedKeys(fact.value, fact.node.keyOf) : fact.value.ids;
 		if (!equal(fact.order, current)) {
 			const after = orderOf(fact.node, fact.value);
-			require_scheduler.profile.recorder("publishedOrderItems", after.length);
+			require_transform.profile.recorder("publishedOrderItems", after.length);
 			order = {
 				before: fact.order,
 				after
@@ -1872,7 +1909,7 @@ var ChangeRecorder = class {
 			this.indexedGroups = true;
 			for (const fact of this.facts) if (fact.kind === "members") {
 				index.add(fact.at, fact);
-				require_scheduler.profile.recorder("indexedGroups");
+				require_transform.profile.recorder("indexedGroups");
 			}
 		}
 		return index;
@@ -1883,7 +1920,7 @@ var ChangeRecorder = class {
 	absorb(at, node, value, present) {
 		const index = this.indexGroups();
 		const children = [];
-		index.query((fact) => {
+		index.forEachOverlap(at, (fact) => {
 			if (fact.kind === "members") {
 				if (fact.at.length < at.length) {
 					if (fact.at.length + 1 === at.length) {
@@ -1902,18 +1939,19 @@ var ChangeRecorder = class {
 					at: fact.at,
 					group: fact
 				});
-				for (const member of fact.members?.values() ?? []) {
+				if (fact.members) for (const member of fact.members.values()) {
 					if (!member) continue;
-					const memberAt = fact.at.concat(member.key);
-					if (contains(at, memberAt)) children.push({
+					const compared = compareExtended(fact.at, member.key, at);
+					if (compared !== "equal" && compared !== "descendant") continue;
+					children.push({
 						kind: "member",
-						at: memberAt,
+						at: fact.at.concat(member.key),
 						group: fact,
 						member
 					});
 				}
 			} else if (contains(at, fact.at)) children.push(fact);
-		})(at);
+		});
 		if (present) value = reconstructBefore(node, value, children, at.length);
 		this.releaseCovered(children);
 		return value;
@@ -1921,7 +1959,7 @@ var ChangeRecorder = class {
 	releaseCovered(children) {
 		let changedGroups;
 		for (const child of children) {
-			require_scheduler.profile.recorder("absorbed");
+			require_transform.profile.recorder("absorbed");
 			if (child.kind === "member") {
 				const { group, member } = child;
 				forgetMember(group, member.key);
@@ -1931,15 +1969,17 @@ var ChangeRecorder = class {
 				(changedGroups ??= /* @__PURE__ */ new Set()).add(child.group);
 			} else this.unregister(child);
 		}
-		for (const group of changedGroups ?? []) if (emptyGroup(group)) this.unregister(group);
+		if (changedGroups) {
+			for (const group of changedGroups) if (emptyGroup(group)) this.unregister(group);
+		}
 	}
 	register(fact) {
 		this.facts.add(fact);
 		if (fact.kind === "members") {
 			this.groups.set(fact.parent, fact);
-			require_scheduler.profile.recorder("groups");
+			require_transform.profile.recorder("groups");
 			if (!this.indexedGroups) return;
-			require_scheduler.profile.recorder("indexedGroups");
+			require_transform.profile.recorder("indexedGroups");
 		}
 		(this.index ??= new require_driver.AddressIndex()).add(fact.at, fact);
 	}
@@ -1969,14 +2009,14 @@ var ChangeRecorder = class {
 		if (group.layout === "dynamic") (group.members ??= /* @__PURE__ */ new Map()).set(key, member);
 		else if (definition.kind === "fixed") group.members[definition.slot] = member;
 		else throw new Error("A fixed member group requires a fixed schema member.");
-		require_scheduler.profile.recorder("facts");
+		require_transform.profile.recorder("facts");
 	}
 	reset() {
 		if (this.resetBefore) return;
 		const value = this.absorb([], this.state.schema, this.state.document, true);
 		this.resetBefore = { value };
 		this.groups = /* @__PURE__ */ new WeakMap();
-		require_scheduler.profile.recorder("facts");
+		require_transform.profile.recorder("facts");
 	}
 	createGroup(container) {
 		const group = container.layout.kind === "fixed" ? {
@@ -2001,13 +2041,13 @@ var ChangeRecorder = class {
 		return group;
 	}
 	order(container) {
-		require_scheduler.profile.recorder("orderCaptures");
+		require_transform.profile.recorder("orderCaptures");
 		let group = this.groups.get(container.parent);
 		if (group?.order || this.covered(container.at)) return;
 		group ??= this.createGroup(container);
 		group.order = orderOf(container.node, container.value);
-		require_scheduler.profile.recorder("orderSnapshots");
-		require_scheduler.profile.recorder("orderItems", group.order.length);
+		require_transform.profile.recorder("orderSnapshots");
+		require_transform.profile.recorder("orderItems", group.order.length);
 	}
 	tree(container, id) {
 		const { at, value: tree } = container;
@@ -2025,7 +2065,7 @@ var ChangeRecorder = class {
 			this.register(fact);
 		}
 		if (id !== void 0 && !fact.nodes.has(id)) {
-			require_scheduler.profile.recorder("treeNodes");
+			require_transform.profile.recorder("treeNodes");
 			fact.nodes.set(id, Object.hasOwn(tree.nodes, id) ? copyTreeNode(tree.nodes[id]) : void 0);
 		}
 	}
@@ -2048,7 +2088,7 @@ var ChangeRecorder = class {
 	seal() {
 		if (this.resetBefore) {
 			if (equalValue(this.state.schema, this.resetBefore.value, this.state.document)) return require_driver.sealChanges([]);
-			require_scheduler.profile.recorder("sealed");
+			require_transform.profile.recorder("sealed");
 			return require_driver.sealChanges([{
 				kind: "reset",
 				before: this.resetBefore.value,
@@ -2059,7 +2099,7 @@ var ChangeRecorder = class {
 		for (const fact of this.facts) if (fact.kind === "members") sealMembers(fact, changes);
 		else sealTree(fact, this.state, changes);
 		const result = require_driver.sealChanges(changes);
-		require_scheduler.profile.recorder("sealed", result.changes.length);
+		require_transform.profile.recorder("sealed", result.changes.length);
 		return result;
 	}
 };
@@ -2664,7 +2704,7 @@ const select = (document, selector, equality = Object.is) => {
 };
 //#endregion
 //#region core/src/projection/input.ts
-const valueInput = (initial, equality = Object.is) => require_scheduler.defineSource({
+const valueInput = (initial, equality = Object.is) => require_transform.defineSource({
 	kind: "value-input",
 	initial,
 	equality
@@ -2678,7 +2718,7 @@ const collectionInput = (initial = /* @__PURE__ */ new Map(), equality = Object.
 		if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
 		entries.set(key, value);
 	}
-	return require_scheduler.defineSource({
+	return require_transform.defineSource({
 		kind: "collection-input",
 		initial: entries,
 		equality
@@ -2691,13 +2731,13 @@ const input = Object.assign(valueInput, { collection: collectionInput });
 //#endregion
 //#region core/src/projection/observe.ts
 function observe(source, selector) {
-	if (isExternalSource(source)) return source.kind === "collection" ? require_scheduler.defineSource({
+	if (isExternalSource(source)) return source.kind === "collection" ? require_transform.defineSource({
 		kind: "external-collection",
 		source
 	}, {
 		kind: "collection",
 		equality: Object.is
-	}) : require_scheduler.defineSource({
+	}) : require_transform.defineSource({
 		kind: "external-value",
 		source,
 		equality: Object.is
@@ -2705,7 +2745,7 @@ function observe(source, selector) {
 		kind: "value",
 		equality: Object.is
 	});
-	if ("current" in source && typeof source.current === "function") return require_scheduler.defineSource({
+	if ("current" in source && typeof source.current === "function") return require_transform.defineSource({
 		kind: "readable",
 		readable: source,
 		equality: Object.is
@@ -2720,7 +2760,7 @@ function observe(source, selector) {
 		schema: state.schema,
 		address: Object.freeze([])
 	});
-	return require_scheduler.defineSource({
+	return require_transform.defineSource({
 		kind: "document",
 		document,
 		selector: selected
@@ -2736,41 +2776,6 @@ const isExternalSource = (source) => {
 };
 //#endregion
 //#region core/src/projection/derive/keyed.ts
-const outputKind = (projection) => {
-	return require_scheduler.outputDefinitionOf(projection).kind;
-};
-const assertKeyedProjection = (projection, role) => {
-	if (outputKind(projection) !== "collection") throw new TypeError(`${role} must be a keyed collection projection.`);
-};
-const isKeyedDependency = (value) => {
-	if (!value || typeof value !== "object" || require_scheduler.isProjection(value)) return false;
-	const candidate = value;
-	return require_scheduler.isProjection(candidate.source) && typeof candidate.key === "function";
-};
-const bindKey = (index, outputKey, sourceKey) => {
-	const previous = index.forward.get(outputKey);
-	if (previous === sourceKey) return;
-	if (previous !== void 0) {
-		const dependents = index.reverse.get(previous);
-		dependents?.delete(outputKey);
-		if (dependents?.size === 0) index.reverse.delete(previous);
-		index.forward.delete(outputKey);
-	}
-	if (sourceKey === void 0) return;
-	index.forward.set(outputKey, sourceKey);
-	const dependents = index.reverse.get(sourceKey);
-	if (dependents) dependents.add(outputKey);
-	else index.reverse.set(sourceKey, new Set([outputKey]));
-};
-const unbindKey = (indexes, outputKey) => {
-	for (const index of indexes) if (index) bindKey(index, outputKey, void 0);
-};
-const createBindingIndex = () => ({
-	forward: /* @__PURE__ */ new Map(),
-	reverse: /* @__PURE__ */ new Map()
-});
-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();
@@ -2784,164 +2789,22 @@ const compileOrderedKeys = (value, role) => {
 		requested: seen
 	};
 };
-const createKeyedTransform = (source, dependencySpecs, select, equality, name) => {
-	assertKeyedProjection(source, "Keyed derive source");
-	const dependencies = [source];
-	const dependencyNames = [];
-	const keyed = [];
-	if (dependencySpecs !== void 0) {
-		if (!require_record.isPlainObject(dependencySpecs) || require_scheduler.isProjection(dependencySpecs)) throw new TypeError("Keyed derive dependencies must be a plain object.");
-		for (const name of Reflect.ownKeys(dependencySpecs)) {
-			if (typeof name !== "string") throw new TypeError("Keyed derive dependency names must be strings.");
-			const descriptor = Object.getOwnPropertyDescriptor(dependencySpecs, name);
-			if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError("Keyed derive dependencies must be enumerable data properties.");
-			const dependency = descriptor.value;
-			dependencyNames.push(name);
-			if (require_scheduler.isProjection(dependency)) {
-				dependencies.push(dependency);
-				keyed.push(void 0);
-				continue;
-			}
-			if (!isKeyedDependency(dependency)) throw new TypeError("Keyed derive dependencies must be projections or keyed lookups.");
-			assertKeyedProjection(dependency.source, "Dynamic keyed dependency source");
-			dependencies.push(dependency.source);
-			keyed.push(dependency);
-		}
-	}
-	const [projection] = require_scheduler.defineProcessor({
-		dependencies,
-		outputs: [{
-			kind: "collection",
-			equality: equality ?? Object.is
-		}],
-		create: () => {
-			const bindings = keyed.map((dependency) => dependency ? createBindingIndex() : void 0);
-			const globalValues = keyed.map(() => void 0);
-			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.");
-					for (let index = 0; index < keyed.length; index++) {
-						if (keyed[index]) continue;
-						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);
-						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);
-							}
-							dependencyValues = Object.freeze(values);
-						}
-						const next = select(value, key, dependencyValues);
-						require_scheduler.assertSynchronous(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.filter((key) => output.next.has(key)));
-						rememberRevisions(evaluation.sources);
-						return;
-					}
-					const dirty = /* @__PURE__ */ new Set();
-					let all = false;
-					let updateOrder = false;
-					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(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.order);
-						}
-					}
-					for (let index = 0; index < keyed.length; index++) {
-						const sourceContext = evaluation.sources[index + 1];
-						if (revisions[index + 1] === sourceContext.revision) continue;
-						if (!keyed[index]) {
-							all = true;
-							continue;
-						}
-						if (sourceContext.kind !== "collection" || !sourceContext.change) {
-							all = true;
-							continue;
-						}
-						if (sourceContext.change.kind === "reset") {
-							all = true;
-							continue;
-						}
-						const reverse = bindings[index].reverse;
-						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)) 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.length = 0;
-				}
-			};
-		},
-		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");
+	return require_transform.createKeyedTransform({
+		source,
+		dependencies: dependencySpecs,
+		equality,
+		name: "derive.keyed",
+		evaluate: ({ value, key, dependencies }) => dependencySpecs === void 0 ? select(value, key) : select(value, key, dependencies)
+	});
 }
 const createKeyedKeys = (source) => {
-	assertKeyedProjection(source, "Keyed keys source");
-	const [projection] = require_scheduler.defineProcessor({
+	require_transform.assertKeyedProjection(source, "Keyed keys source");
+	const [projection] = require_transform.defineProcessor({
 		dependencies: [source],
 		outputs: [{
 			kind: "value",
@@ -2951,15 +2814,15 @@ const createKeyedKeys = (source) => {
 			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());
+			if (evaluation.reset || !driver.change || require_transform.collectionHasStructuralChange(driver.change)) output.output.set(driver.read.ids());
 		} }),
 		name: "derive.keyed.keys"
 	});
 	return projection;
 };
-const createKeyedValues = (source) => {
-	assertKeyedProjection(source, "Keyed values source");
-	const [projection] = require_scheduler.defineProcessor({
+const createOrderedSnapshot = (source, name, make) => {
+	require_transform.assertKeyedProjection(source, `${name} source`);
+	const [projection] = require_transform.defineProcessor({
 		dependencies: [source],
 		outputs: [{
 			kind: "value",
@@ -2969,33 +2832,32 @@ const createKeyedValues = (source) => {
 			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) => {
+				const result = Object.freeze(driver.read.ids().map((key, index) => {
 					nextIndexes.set(key, index);
-					return driver.read.get(key);
+					return make(key, driver.read.get(key));
 				}));
 				indexes = nextIndexes;
-				return values;
+				return result;
 			};
 			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) => {
+				const result = Object.freeze(driver.read.ids().map((key, index) => {
 					nextIndexes.set(key, index);
-					if (changedValues.has(key)) return changedValues.get(key);
+					if (changedValues.has(key)) return make(key, changedValues.get(key));
 					const previousIndex = indexes.get(key);
-					return previousIndex === void 0 ? driver.read.get(key) : previous[previousIndex];
+					return previousIndex === void 0 ? make(key, driver.read.get(key)) : previous[previousIndex];
 				}));
 				indexes = nextIndexes;
-				return values;
+				return result;
 			};
 			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.");
+					if (driver.kind !== "collection" || output.kind !== "value") throw new Error(`${name} requires collection input and value output.`);
 					const change = driver.change;
 					if (evaluation.reset || !change || change.kind === "reset") {
 						output.output.set(rebuild(driver));
@@ -3006,7 +2868,7 @@ const createKeyedValues = (source) => {
 						output.output.set(rebuild(driver));
 						return;
 					}
-					if (require_scheduler.collectionHasStructuralChange(change)) {
+					if (require_transform.collectionHasStructuralChange(change)) {
 						output.output.set(rebuildIncremental(driver, change, previous));
 						return;
 					}
@@ -3018,14 +2880,54 @@ const createKeyedValues = (source) => {
 							output.output.set(rebuild(driver));
 							return;
 						}
-						next[index] = entry.after;
+						next[index] = make(entry.key, entry.after);
 					}
 					output.output.set(Object.freeze(next));
 				},
 				release: () => indexes.clear()
 			};
 		},
-		name: "derive.keyed.values"
+		name
+	});
+	return projection;
+};
+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;
 };
@@ -3033,28 +2935,40 @@ 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");
+	return require_transform.createKeyedTransform({
+		source,
+		dependencies: dependencySpecs,
+		equality: Object.is,
+		name: "derive.keyed.filter",
+		evaluate: ({ value, key, dependencies }) => {
+			const included = dependencySpecs === void 0 ? predicate(value, key) : predicate(value, key, dependencies);
+			require_transform.assertSynchronous(included);
+			if (typeof included !== "boolean") throw new TypeError("Keyed filter predicate must return boolean.");
+			return included ? value : require_transform.keyedAbsent;
+		}
+	});
 }
 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");
+	return require_transform.createKeyedTransform({
+		source,
+		dependencies: dependencySpecs,
+		equality,
+		name: "derive.keyed.compact",
+		evaluate: ({ value, key, dependencies }) => {
+			const next = dependencySpecs === void 0 ? select(value, key) : select(value, key, dependencies);
+			require_transform.assertSynchronous(next);
+			return next === void 0 ? require_transform.keyedAbsent : next;
+		}
+	});
 }
 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.");
+	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 {
@@ -3062,7 +2976,7 @@ const createKeyedSubset = (source, orderedKeys) => {
 			requested: compiled.requested
 		};
 	})();
-	const [projection] = require_scheduler.defineProcessor({
+	const [projection] = require_transform.defineProcessor({
 		dependencies: keyProjection ? [source, keyProjection] : [source],
 		outputs: [{
 			kind: "collection",
@@ -3146,9 +3060,199 @@ const createKeyedSubset = (source, orderedKeys) => {
 	});
 	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.");
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const group of groups) {
+		if (typeof group !== "string") throw new TypeError("derive.keyed.groupBy selector must return only string group keys.");
+		if (seen.has(group)) throw new TypeError("derive.keyed.groupBy selector must not return duplicate group keys.");
+		seen.add(group);
+		result.push(group);
+	}
+	return Object.freeze(result);
+};
+function createKeyedGroupBy(source, dependenciesOrSelector, maybeSelector) {
+	require_transform.assertKeyedProjection(source, "derive.keyed.groupBy source");
+	const dependencySpecs = typeof dependenciesOrSelector === "function" ? void 0 : dependenciesOrSelector;
+	const selector = dependencySpecs === void 0 ? dependenciesOrSelector : maybeSelector;
+	if (typeof selector !== "function") throw new TypeError("derive.keyed.groupBy requires a selector.");
+	const compiled = require_transform.compileKeyedDependencies(source, dependencySpecs, "derive.keyed.groupBy");
+	const [projection] = require_transform.defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: (previous, next) => {
+				return require_transform.sameArray(previous, next);
+			}
+		}],
+		create: () => {
+			const dependencies = require_transform.createKeyedDependencyRuntime(compiled);
+			const relation = require_transform.createKeyRelation();
+			const orderIndex = /* @__PURE__ */ new Map();
+			const groupRanks = /* @__PURE__ */ new Map();
+			const refreshOrderIndex = (driver) => {
+				orderIndex.clear();
+				driver.read.ids().forEach((key, index) => orderIndex.set(key, index));
+			};
+			const selectGroups = (driver, sources, key, affected) => {
+				if (!driver.read.has(key)) return false;
+				const value = driver.read.get(key);
+				const dependencyValues = dependencies.resolve(value, key, sources);
+				const selected = dependencySpecs === void 0 ? selector(value, key) : selector(value, key, dependencyValues);
+				require_transform.assertSynchronous(selected);
+				const next = normalizeGroups(selected);
+				const previous = relation.forward(key) ?? Object.freeze([]);
+				if (!relation.replace(key, next)) return false;
+				for (const group of previous) affected.add(group);
+				for (const group of next) affected.add(group);
+				return true;
+			};
+			const updateGroup = (group, output) => {
+				const reverse = relation.reverse(group);
+				if (!reverse?.size) {
+					groupRanks.delete(group);
+					output.output.remove(group);
+					return;
+				}
+				const members = [...reverse].sort((left, right) => (orderIndex.get(left) ?? Number.MAX_SAFE_INTEGER) - (orderIndex.get(right) ?? Number.MAX_SAFE_INTEGER));
+				const first = members[0];
+				const source = orderIndex.get(first);
+				const selector = relation.forward(first)?.indexOf(group) ?? -1;
+				if (source === void 0 || selector < 0) throw new Error("derive.keyed.groupBy relation is inconsistent with source order.");
+				groupRanks.set(group, {
+					source,
+					selector
+				});
+				output.output.set(group, Object.freeze(members));
+			};
+			const publishGroupOrder = (output) => {
+				const order = [...groupRanks.keys()];
+				order.sort((leftKey, rightKey) => {
+					const left = groupRanks.get(leftKey);
+					const right = groupRanks.get(rightKey);
+					if (left.source !== right.source) return left.source - right.source;
+					if (left.selector !== right.selector) return left.selector - right.selector;
+					return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+				});
+				output.output.order(order);
+			};
+			const rebuild = (driver, sources, output) => {
+				dependencies.clearBindings();
+				relation.clear();
+				groupRanks.clear();
+				refreshOrderIndex(driver);
+				const affected = /* @__PURE__ */ new Set();
+				for (const key of driver.read.ids()) selectGroups(driver, sources, key, affected);
+				for (const key of output.previous.ids()) affected.add(key);
+				for (const group of affected) updateGroup(group, output);
+				publishGroupOrder(output);
+			};
+			const publishAffected = (affected, output, orderDirty) => {
+				for (const group of affected) updateGroup(group, output);
+				if (orderDirty) publishGroupOrder(output);
+			};
+			const removeSourceKey = (key, affected) => {
+				const previous = relation.forward(key);
+				if (!previous) return false;
+				for (const group of previous) affected.add(group);
+				return relation.delete(key);
+			};
+			const markAllGroups = (output, affected) => {
+				for (const group of relation.rights()) affected.add(group);
+				for (const group of output.previous.ids()) affected.add(group);
+			};
+			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.groupBy requires collection input and output.");
+					dependencies.prepare(evaluation.sources, evaluation.reset);
+					if (evaluation.reset) {
+						rebuild(driver, evaluation.sources, output);
+						dependencies.remember(evaluation.sources);
+						return;
+					}
+					const dirty = /* @__PURE__ */ new Set();
+					const affected = /* @__PURE__ */ new Set();
+					let all = false;
+					let structural = false;
+					let orderDirty = false;
+					if (dependencies.driverChanged(driver)) {
+						const change = driver.change;
+						if (!change || change.kind === "reset") {
+							rebuild(driver, evaluation.sources, output);
+							dependencies.remember(evaluation.sources);
+							return;
+						} else {
+							for (const entry of change.removed) {
+								orderDirty ||= removeSourceKey(entry.key, affected);
+								dependencies.remove(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);
+							structural = Boolean(change.added.length || change.removed.length || change.order);
+							orderDirty ||= structural;
+							if (structural) refreshOrderIndex(driver);
+						}
+					}
+					all ||= dependencies.collectInvalidated(evaluation.sources, dirty);
+					if (all) for (const key of driver.read.ids()) dirty.add(key);
+					for (const key of dirty) orderDirty ||= selectGroups(driver, evaluation.sources, key, affected);
+					if (structural) markAllGroups(output, affected);
+					publishAffected(affected, output, orderDirty);
+					dependencies.remember(evaluation.sources);
+				},
+				release: () => {
+					relation.clear();
+					orderIndex.clear();
+					groupRanks.clear();
+					dependencies.release();
+				}
+			};
+		},
+		name: "derive.keyed.groupBy"
+	});
+	return projection;
+}
+const createKeyedSingleton = (source, keyOf, equality = Object.is) => {
+	if (require_transform.outputKind(source) !== "value") throw new TypeError("derive.keyed.singleton source must be a scalar projection.");
+	if (typeof keyOf !== "function") throw new TypeError("derive.keyed.singleton requires a key selector.");
+	const [projection] = require_transform.defineProcessor({
+		dependencies: [source],
+		outputs: [{
+			kind: "collection",
+			equality
+		}],
+		create: () => ({ evaluate: (evaluation) => {
+			const scalar = evaluation.sources[0];
+			const output = evaluation.outputs[0];
+			if (scalar.kind !== "value" || output.kind !== "collection") throw new Error("derive.keyed.singleton resolved invalid input/output kinds.");
+			const previous = output.previous.ids();
+			if (scalar.value === void 0) {
+				for (const key of previous) output.output.remove(key);
+				return;
+			}
+			const key = keyOf(scalar.value);
+			require_transform.assertSynchronous(key);
+			if (typeof key !== "string") throw new TypeError("derive.keyed.singleton key selector must return a string.");
+			for (const previousKey of previous) if (previousKey !== key) output.output.remove(previousKey);
+			output.output.set(key, scalar.value);
+			if (previous.length !== 1 || previous[0] !== key) output.output.order([key]);
+		} }),
+		name: "derive.keyed.singleton"
+	});
+	return projection;
+};
 const keyedDerive = Object.assign(createKeyedDerive, {
 	keys: createKeyedKeys,
 	values: createKeyedValues,
+	entries: createKeyedEntries,
+	get: createKeyedGet,
+	groupBy: createKeyedGroupBy,
+	singleton: createKeyedSingleton,
 	subset: createKeyedSubset,
 	filter: createKeyedFilter,
 	compact: createKeyedCompact
@@ -3156,10 +3260,10 @@ const keyedDerive = Object.assign(createKeyedDerive, {
 //#endregion
 //#region core/src/projection/derive.ts
 function createValueDerive(dependencies, compute, equality = Object.is) {
-	const compiled = require_scheduler.compileProjectionDependencies(dependencies, "Derive");
+	const compiled = require_transform.compileProjectionDependencies(dependencies, "Derive");
 	const names = compiled.names;
 	const ordered = compiled.projections;
-	const [projection] = require_scheduler.defineProcessor({
+	const [projection] = require_transform.defineProcessor({
 		dependencies: ordered,
 		outputs: [{
 			kind: "value",
@@ -3169,9 +3273,9 @@ function createValueDerive(dependencies, compute, equality = Object.is) {
 			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]);
+			for (let index = 0; index < names.length; index++) values[names[index]] = require_transform.snapshotDependencyValue(evaluation.sources[index]);
 			const next = compute(Object.freeze(values));
-			require_scheduler.assertSynchronous(next);
+			require_transform.assertSynchronous(next);
 			output.output.set(next);
 		} })
 	});
@@ -3182,7 +3286,7 @@ const derive = Object.assign(createValueDerive, { keyed: keyedDerive });
 //#region core/src/projection/collection/index.ts
 const height = (node) => node?.height ?? 0;
 const node = (key, value, left, right) => {
-	require_scheduler.profile.collectionIndex.node();
+	require_transform.profile.collectionIndex.node();
 	return Object.freeze({
 		key,
 		value,
@@ -3243,7 +3347,7 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 	}
 	static from(entries) {
 		const sorted = [...entries].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
-		require_scheduler.profile.collectionIndex.build(sorted.length);
+		require_transform.profile.collectionIndex.build(sorted.length);
 		return new PersistentKeyedIndex(fromSorted(sorted));
 	}
 	get(key) {
@@ -3300,13 +3404,14 @@ const createPublishedCollection = () => {
 		},
 		publish: (staged, nextIds, reset) => {
 			if (reset) {
-				const entries = [];
-				for (const [key, entry] of staged) if (entry.present) entries.push([key, entry.value]);
-				index = PersistentKeyedIndex.from(entries);
 				values.clear();
-			} else for (const [key, entry] of staged) index = entry.present ? index.set(key, entry.value) : index.remove(key);
-			for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
-			else values.delete(key);
+				for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
+				index = PersistentKeyedIndex.from(values);
+			} else for (const [key, entry] of staged) {
+				index = entry.present ? index.set(key, entry.value) : index.remove(key);
+				if (entry.present) values.set(key, entry.value);
+				else values.delete(key);
+			}
 			ids = nextIds;
 		},
 		release: () => {
@@ -3319,7 +3424,7 @@ const createPublishedCollection = () => {
 /** Owns staged keyed intent, exact transitions and published collection state. */
 const createCollectionOutput = (binding) => {
 	const published = createPublishedCollection();
-	let staged = /* @__PURE__ */ new Map();
+	const staged = /* @__PURE__ */ new Map();
 	let nextIds = published.ids();
 	let change;
 	let initialized = false;
@@ -3335,12 +3440,15 @@ const createCollectionOutput = (binding) => {
 		return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : published.get(key);
 	};
 	const deriveIds = () => {
-		const result = cleared ? [] : published.ids().filter(hasNext);
+		const result = [];
+		if (!cleared) {
+			for (const key of published.ids()) if (hasNext(key)) result.push(key);
+		}
 		for (const [key, entry] of staged) if (entry.present && (cleared || !published.has(key))) result.push(key);
 		return result;
 	};
 	const begin = (active, initialize) => {
-		staged = /* @__PURE__ */ new Map();
+		staged.clear();
 		nextIds = published.ids();
 		change = void 0;
 		explicitOrder = void 0;
@@ -3348,16 +3456,18 @@ const createCollectionOutput = (binding) => {
 		reset = initialize;
 		const read = (next) => ({
 			get: (key) => {
-				require_scheduler.assertScope(active);
+				require_transform.assertScope(active);
 				return next ? getNext(key) : published.get(key);
 			},
 			has: (key) => {
-				require_scheduler.assertScope(active);
+				require_transform.assertScope(active);
 				return next ? hasNext(key) : published.has(key);
 			},
 			ids: () => {
-				require_scheduler.assertScope(active);
-				return next ? Object.freeze(explicitOrder ? [...explicitOrder] : [...deriveIds()]) : published.ids();
+				require_transform.assertScope(active);
+				if (!next) return published.ids();
+				if (explicitOrder) return explicitOrder;
+				return Object.freeze(deriveIds());
 			}
 		});
 		return {
@@ -3365,7 +3475,7 @@ const createCollectionOutput = (binding) => {
 			next: read(true),
 			output: {
 				set: (key, value) => {
-					require_scheduler.assertScope(active);
+					require_transform.assertScope(active);
 					if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
 					staged.set(key, {
 						present: true,
@@ -3373,12 +3483,12 @@ const createCollectionOutput = (binding) => {
 					});
 				},
 				remove: (key) => {
-					require_scheduler.assertScope(active);
+					require_transform.assertScope(active);
 					staged.set(key, { present: false });
 				},
 				order: (order) => {
-					require_scheduler.assertScope(active);
-					explicitOrder = Object.freeze([...order]);
+					require_transform.assertScope(active);
+					explicitOrder = require_transform.snapshotArray(order);
 				}
 			}
 		};
@@ -3387,9 +3497,7 @@ const createCollectionOutput = (binding) => {
 		if (cleared) {
 			for (const key of published.keys()) if (!staged.has(key)) staged.set(key, { present: false });
 		}
-		require_scheduler.profile.projection("touchedKeys", staged.size);
-		const added = /* @__PURE__ */ new Set();
-		const removed = /* @__PURE__ */ new Set();
+		require_transform.profile.projection("touchedKeys", staged.size);
 		const addedEntries = [];
 		const updatedEntries = [];
 		const removedEntries = [];
@@ -3397,7 +3505,6 @@ const createCollectionOutput = (binding) => {
 			const existed = published.has(key);
 			if (entry.present) {
 				if (!existed) {
-					added.add(key);
 					addedEntries.push({
 						key,
 						after: entry.value
@@ -3413,22 +3520,31 @@ const createCollectionOutput = (binding) => {
 				else if (!nextReset) staged.delete(key);
 				continue;
 			}
-			if (existed) {
-				removed.add(key);
-				removedEntries.push({
-					key,
-					before: published.get(key)
-				});
-			} else staged.delete(key);
+			if (existed) removedEntries.push({
+				key,
+				before: published.get(key)
+			});
+			else staged.delete(key);
 		}
 		const ids = published.ids();
-		if (explicitOrder || added.size || removed.size) {
-			const order = explicitOrder ?? [...ids.filter((key) => !removed.has(key)), ...added];
-			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]);
+		if (explicitOrder) {
+			const expectedLength = published.size() + addedEntries.length - removedEntries.length;
+			const seen = /* @__PURE__ */ new Set();
+			for (const key of explicitOrder) {
+				if (seen.has(key) || !hasNext(key)) throw new TypeError("Projection order must contain every key exactly once.");
+				seen.add(key);
+			}
+			if (seen.size !== expectedLength) throw new TypeError("Projection order must contain every key exactly once.");
+			nextIds = require_transform.sameArray(ids, explicitOrder) ? ids : explicitOrder;
+		} else if (addedEntries.length || removedEntries.length) {
+			const order = new Array(published.size() + addedEntries.length - removedEntries.length);
+			let index = 0;
+			for (const key of ids) if (hasNext(key)) order[index++] = key;
+			for (const entry of addedEntries) order[index++] = entry.key;
+			nextIds = require_transform.sameArray(ids, order) ? ids : Object.freeze(order);
 		} else nextIds = ids;
-		require_scheduler.profile.projection("changedKeys", addedEntries.length + updatedEntries.length + removedEntries.length);
-		change = nextReset ? Object.freeze({ kind: "reset" }) : require_scheduler.createCollectionChange({
+		require_transform.profile.projection("changedKeys", addedEntries.length + updatedEntries.length + removedEntries.length);
+		change = nextReset ? Object.freeze({ kind: "reset" }) : require_transform.createCollectionChange({
 			added: addedEntries,
 			updated: updatedEntries,
 			removed: removedEntries,
@@ -3442,15 +3558,15 @@ const createCollectionOutput = (binding) => {
 		kind: "collection",
 		read: {
 			get: (key) => {
-				require_scheduler.assertScope(active);
+				require_transform.assertScope(active);
 				return getNext(key);
 			},
 			has: (key) => {
-				require_scheduler.assertScope(active);
+				require_transform.assertScope(active);
 				return hasNext(key);
 			},
 			ids: () => {
-				require_scheduler.assertScope(active);
+				require_transform.assertScope(active);
 				return nextIds;
 			}
 		},
@@ -3476,7 +3592,7 @@ const createCollectionOutput = (binding) => {
 			initialized = true;
 		},
 		emit: (call) => {
-			Array.from(listeners).forEach((listener) => call(listener));
+			Array.from(listeners).forEach((listener) => call(listener, change));
 		},
 		hasConsumers: () => consumers.size > 0,
 		forEachConsumer: (run) => consumers.forEach(run),
@@ -3532,12 +3648,12 @@ const createValueOutput = (binding) => {
 		return {
 			previous: initialized ? value : void 0,
 			next: () => {
-				require_scheduler.assertScope(active);
+				require_transform.assertScope(active);
 				if (staged !== unset) return staged;
 				return initialize ? void 0 : initialized ? value : void 0;
 			},
 			output: Object.freeze({ set: (candidate) => {
-				require_scheduler.assertScope(active);
+				require_transform.assertScope(active);
 				staged = candidate;
 			} })
 		};
@@ -3564,7 +3680,7 @@ const createValueOutput = (binding) => {
 		begin,
 		seal,
 		context: (active) => {
-			require_scheduler.assertScope(active);
+			require_transform.assertScope(active);
 			return Object.freeze({
 				kind: "value",
 				value: next,
@@ -3585,8 +3701,8 @@ const createValueOutput = (binding) => {
 			initialized = true;
 		},
 		emit: (call) => {
-			require_scheduler.profile.materialized.notification();
-			Array.from(listeners).forEach((listener) => call(listener));
+			require_transform.profile.materialized.notification();
+			Array.from(listeners).forEach((listener) => call(listener, void 0));
 		},
 		hasConsumers: () => consumers.size > 0,
 		forEachConsumer: (run) => consumers.forEach(run),
@@ -3624,7 +3740,7 @@ const createProcessor = (scheduler, definition, dependencies) => {
 	let instance;
 	let cause;
 	const check = () => {
-		if (!scheduler.active || processor.disposed) throw new require_scheduler.ProjectionDisposedError();
+		if (!scheduler.active || processor.disposed) throw new require_transform.ProjectionDisposedError();
 		if (processor.fault) throw processor.fault;
 	};
 	const bound = definition.outputs.map((outputDefinition) => {
@@ -3678,8 +3794,8 @@ const createProcessor = (scheduler, definition, dependencies) => {
 				instance = void 0;
 			}
 			if (!instance) instance = definition.create();
-			require_scheduler.profile.materialized[reset ? "rebuilt" : "updated"]();
-			require_scheduler.assertSynchronous(instance.evaluate({
+			require_transform.profile.materialized[reset ? "rebuilt" : "updated"]();
+			require_transform.assertSynchronous(instance.evaluate({
 				reset,
 				cause: runCause,
 				sources,
@@ -3726,7 +3842,7 @@ const createProcessor = (scheduler, definition, dependencies) => {
 	try {
 		scheduler.initialize(() => {
 			const invalid = dependencies.find((output) => output.owner.fault || output.owner.disposed);
-			if (invalid) throw invalid.owner.fault ?? new require_scheduler.ProjectionDisposedError();
+			if (invalid) throw invalid.owner.fault ?? new require_transform.ProjectionDisposedError();
 			if (processor.evaluate(true, void 0).length) processor.publish();
 			processor.clear();
 		});
@@ -3741,6 +3857,21 @@ const createProcessor = (scheduler, definition, dependencies) => {
 	return processor;
 };
 //#endregion
+//#region core/src/projection/readable/listeners.ts
+/** Exhaustively notifies an already-stable projection listener snapshot. */
+const notifyProjectionListenerSnapshot = (listeners, message) => {
+	let failures;
+	for (const listener of listeners) try {
+		listener();
+	} catch (error) {
+		(failures ??= []).push(error);
+	}
+	if (failures?.length === 1) throw failures[0];
+	if (failures?.length) throw new AggregateError(failures, message);
+};
+/** Snapshots a mutable listener collection before exhaustive notification. */
+const notifyProjectionListeners = (listeners, message) => notifyProjectionListenerSnapshot([...listeners], message);
+//#endregion
 //#region core/src/projection/readable/selection.ts
 let activeTracker;
 const trackKey = (key) => {
@@ -3793,9 +3924,8 @@ const trackedMap = (source) => {
 const selectionAffects = (selection, change) => {
 	if (!change || change.kind === "reset") 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;
+	if (selection.structure && require_transform.collectionHasStructuralChange(change)) return true;
+	return require_transform.collectionChangeIntersects(change, selection.keys);
 };
 const createDirectReadable = (source) => Object.freeze({
 	current: source.current,
@@ -3837,7 +3967,7 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 			activeTracker = previousTracker;
 		}
 		const nextSelection = Object.freeze({
-			keys: new Set(tracker.keys),
+			keys: tracker.keys,
 			all: tracker.all || isMapLike(current) && tracker.keys.size === 0 && !tracker.structure,
 			structure: tracker.structure
 		});
@@ -3862,7 +3992,7 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 		if (!change && previousCollection) {
 			const current = source.current();
 			if (isMapLike(current)) {
-				change = require_scheduler.diffCollection(previousCollection, current);
+				change = require_transform.diffCollection(previousCollection, current);
 				previousCollection = current;
 				if (!change) {
 					sourceRevision = source.revision();
@@ -3875,7 +4005,7 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 			updateCollectionSnapshot();
 			return;
 		}
-		if (evaluate()) Array.from(listeners).forEach((listener) => listener());
+		if (evaluate()) notifyProjectionListeners(listeners, "Projection selector listeners failed.");
 	};
 	const installSource = () => {
 		if (!unsubscribeSource) unsubscribeSource = source.subscribe(onProjectionChange);
@@ -3906,7 +4036,7 @@ const hasDocumentDirty = (dirty) => dirty.replace || dirty.order || dirty.treeRo
 const equivalent = (node, left, right) => node.kind === "field" ? Object.is(left, right) : equalValue(node, left, right);
 const replaceValue = (node, previous, current) => equivalent(node, previous, current) ? previous : copyValue(node, current);
 const cloneRecord = (value) => {
-	require_scheduler.profile.copy.shallowRecord(Object.getOwnPropertyNames(value).length);
+	require_transform.profile.copy.shallowRecord(Object.getOwnPropertyNames(value).length);
 	return Object.create(Object.getPrototypeOf(value), Object.getOwnPropertyDescriptors(value));
 };
 const materializeRecordChild = (node, previous, current, key, dirty) => {
@@ -4079,10 +4209,11 @@ const clearDocumentDirty = (dirty) => {
 	dirty.treeNodes.clear();
 	dirty.children.clear();
 };
-const locate = (dirty, path) => {
+const locateRange = (dirty, path, start, tail) => {
 	let current = dirty;
-	for (const key of path) {
+	for (let index = start; index < path.length; index++) {
 		if (current.replace) return void 0;
+		const key = path[index];
 		let child = current.children.get(key);
 		if (!child) {
 			child = createDocumentDirty();
@@ -4090,10 +4221,17 @@ const locate = (dirty, path) => {
 		}
 		current = child;
 	}
-	return current;
+	if (tail === void 0) return current;
+	if (current.replace) return void 0;
+	let child = current.children.get(tail);
+	if (!child) {
+		child = createDocumentDirty();
+		current.children.set(tail, child);
+	}
+	return child;
 };
-const markDocumentReplace = (dirty, path) => {
-	const current = locate(dirty, path);
+const replaceAt = (dirty, path, start, tail) => {
+	const current = locateRange(dirty, path, start, tail);
 	if (!current) return;
 	current.replace = true;
 	current.order = false;
@@ -4101,15 +4239,18 @@ const markDocumentReplace = (dirty, path) => {
 	current.treeNodes.clear();
 	current.children.clear();
 };
-const markDocumentOrder = (dirty, path) => {
-	const current = locate(dirty, path);
+const markDocumentReplace = (dirty, path) => {
+	replaceAt(dirty, path, 0);
+};
+const markDocumentOrderRange = (dirty, path, start) => {
+	const current = locateRange(dirty, path, start);
 	if (current && !current.replace) current.order = true;
 };
-const markDocumentTree = (dirty, path, root, nodes) => {
-	const current = locate(dirty, path);
+const markDocumentTree = (dirty, path, start, root, nodes) => {
+	const current = locateRange(dirty, path, start);
 	if (!current || current.replace) return;
 	current.treeRoot ||= root;
-	for (const id of nodes) current.treeNodes.add(id);
+	for (const node of nodes) current.treeNodes.add(node.id);
 };
 const createCollectionPending = () => ({
 	reset: false,
@@ -4139,19 +4280,19 @@ const mergeValueChanges = (selector, dirty, changes) => {
 	const at = selector.address;
 	for (const change of changes.changes) {
 		if (change.kind === "reset") {
-			markDocumentReplace(dirty, []);
+			replaceAt(dirty, at, at.length);
 			return;
 		}
 		if (change.kind === "members") {
 			for (const member of change.members) {
-				const changed = [...change.at, member.key];
-				if (contains(changed, at)) markDocumentReplace(dirty, []);
-				else if (contains(at, changed)) markDocumentReplace(dirty, changed.slice(at.length));
+				const compared = compareExtended(change.at, member.key, at);
+				if (compared === "ancestor" || compared === "equal") replaceAt(dirty, at, at.length);
+				else if (compared === "descendant") replaceAt(dirty, change.at, at.length, member.key);
 			}
-			if (change.order && contains(at, change.at)) markDocumentOrder(dirty, change.at.slice(at.length));
+			if (change.order && contains(at, change.at)) markDocumentOrderRange(dirty, change.at, at.length);
 			continue;
 		}
-		if (contains(at, change.at)) markDocumentTree(dirty, change.at.slice(at.length), change.before !== change.after, change.nodes.map((node) => node.id));
+		if (contains(at, change.at)) markDocumentTree(dirty, change.at, at.length, change.before !== change.after, change.nodes);
 	}
 };
 const mergeCollectionChanges = (selector, pending, changes) => {
@@ -4163,13 +4304,15 @@ const mergeCollectionChanges = (selector, pending, changes) => {
 			return;
 		}
 		if (selector.tree?.kind === "nodes") {
-			if (change.kind === "members") {
-				for (const member of change.members) if (contains([...change.at, member.key], at)) {
+			if (change.kind === "members") for (const member of change.members) {
+				const compared = compareExtended(change.at, member.key, at);
+				if (compared === "ancestor" || compared === "equal") {
 					resetCollectionPending(pending);
 					return;
 				}
-			} else if (change.at.length === at.length && contains(change.at, at)) for (const node of change.nodes) {
-				markDocumentReplace(dirtyEntry(pending, node.id), []);
+			}
+			else if (change.at.length === at.length && contains(change.at, at)) for (const node of change.nodes) {
+				replaceAt(dirtyEntry(pending, node.id), at, at.length);
 				pending.order ||= node.kind !== "updated";
 			}
 			else if (contains(change.at, at)) {
@@ -4180,39 +4323,32 @@ const mergeCollectionChanges = (selector, pending, changes) => {
 		}
 		if (change.kind === "members") {
 			for (const member of change.members) {
-				const changed = [...change.at, member.key];
-				if (contains(changed, at)) {
-					resetCollectionPending(pending);
-					return;
-				}
-				if (!contains(at, changed)) continue;
-				const relative = changed.slice(at.length);
-				if (!relative.length) {
+				const compared = compareExtended(change.at, member.key, at);
+				if (compared === "ancestor" || compared === "equal") {
 					resetCollectionPending(pending);
 					return;
 				}
-				markDocumentReplace(dirtyEntry(pending, relative[0]), relative.slice(1));
-				if (relative.length === 1 && member.kind !== "updated") pending.order = true;
-			}
-			if (change.order && contains(at, change.at)) {
-				const relative = change.at.slice(at.length);
-				if (!relative.length) pending.order = true;
-				else markDocumentOrder(dirtyEntry(pending, relative[0]), relative.slice(1));
+				if (compared !== "descendant") continue;
+				if (at.length === change.at.length) {
+					replaceAt(dirtyEntry(pending, member.key), change.at, change.at.length);
+					if (member.kind !== "updated") pending.order = true;
+				} else replaceAt(dirtyEntry(pending, change.at[at.length]), change.at, at.length + 1, member.key);
 			}
+			if (change.order && contains(at, change.at)) if (change.at.length === at.length) pending.order = true;
+			else markDocumentOrderRange(dirtyEntry(pending, change.at[at.length]), change.at, at.length + 1);
 			continue;
 		}
 		if (!contains(at, change.at)) continue;
-		const relative = change.at.slice(at.length);
-		if (!relative.length) {
+		if (change.at.length === at.length) {
 			resetCollectionPending(pending);
 			return;
 		}
-		markDocumentTree(dirtyEntry(pending, relative[0]), relative.slice(1), change.before !== change.after, change.nodes.map((node) => node.id));
+		markDocumentTree(dirtyEntry(pending, change.at[at.length]), change.at, at.length + 1, change.before !== change.after, change.nodes);
 	}
 };
 //#endregion
 //#region core/src/projection/source/boundary.ts
-const sourceError = (cause) => new require_scheduler.ProjectionError("source", cause);
+const sourceError = (cause) => new require_transform.ProjectionError("source", cause);
 const createValueBoundary = (scheduler, name, initial, equality, prepare, clearSource) => {
 	let boundary;
 	let pendingReset = false;
@@ -4221,7 +4357,7 @@ const createValueBoundary = (scheduler, name, initial, equality, prepare, clearS
 	let recovering = false;
 	let cleanup;
 	const check = () => {
-		if (!scheduler.active || boundary.disposed) throw new require_scheduler.ProjectionDisposedError();
+		if (!scheduler.active || boundary.disposed) throw new require_transform.ProjectionDisposedError();
 		if (boundary.fault) throw boundary.fault;
 	};
 	const state = createValueOutput({
@@ -4328,24 +4464,37 @@ const stageCollectionRead = (state, read, active, options) => {
 	const evaluation = state.begin(active, options.reset);
 	if (options.reset) {
 		const ids = read.ids();
-		require_scheduler.profile.collectionView.idsScanned(ids.length);
+		require_transform.profile.collectionView.idsScanned(ids.length);
 		for (const key of ids) {
-			require_scheduler.profile.collectionView.mapped();
+			require_transform.profile.collectionView.mapped();
 			evaluation.output.set(key, read.get(key));
 		}
 		evaluation.output.order(ids);
 	} else {
 		const previous = state.current();
-		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();
+		let currentIds;
+		const ids = () => currentIds ??= read.ids();
+		if (options.candidates) for (const key of options.candidates) if (read.has(key)) {
+			require_transform.profile.collectionView.mapped();
 			evaluation.output.set(key, read.get(key));
 		} else evaluation.output.remove(key);
+		else {
+			const previousIds = previous.ids();
+			const nextIds = ids();
+			require_transform.profile.collectionView.idsScanned(previousIds.length + nextIds.length);
+			for (const key of previousIds) if (read.has(key)) {
+				require_transform.profile.collectionView.mapped();
+				evaluation.output.set(key, read.get(key));
+			} else evaluation.output.remove(key);
+			for (const key of nextIds) if (!previous.has(key)) {
+				require_transform.profile.collectionView.mapped();
+				evaluation.output.set(key, read.get(key));
+			}
+		}
 		if (options.orderMayChange || !options.candidates) {
-			const ids = read.ids();
-			if (options.candidates) require_scheduler.profile.collectionView.idsScanned(ids.length);
-			evaluation.output.order(ids);
+			const nextIds = ids();
+			if (options.candidates) require_transform.profile.collectionView.idsScanned(nextIds.length);
+			evaluation.output.order(nextIds);
 		}
 	}
 	return state.seal(options.reset, options.isEqual ?? Object.is);
@@ -4361,7 +4510,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 	const candidates = /* @__PURE__ */ new Set();
 	let cleanup;
 	const check = () => {
-		if (!scheduler.active || boundary.disposed) throw new require_scheduler.ProjectionDisposedError();
+		if (!scheduler.active || boundary.disposed) throw new require_transform.ProjectionDisposedError();
 		if (boundary.fault) throw boundary.fault;
 	};
 	const state = createCollectionOutput({
@@ -4639,16 +4788,18 @@ const createDocumentSourceRegistry = (scheduler) => {
 			const snapshots = /* @__PURE__ */ new Map();
 			const replacement = createDocumentDirty();
 			if (pending.reset) markDocumentReplace(replacement, []);
+			let cachedIds;
 			const ids = () => {
-				require_scheduler.assertScope(active);
-				if (treeNodes) return node?.kind === "tree" && require_record.isRecord(value) && require_record.isRecord(value.nodes) ? Object.freeze(Object.keys(value.nodes)) : Object.freeze([]);
-				if (node?.kind === "map" && require_record.isRecord(value)) return Object.freeze(Object.keys(value));
-				if (node?.kind === "table" && require_record.isRecord(value) && Array.isArray(value.ids)) return Object.freeze([...value.ids]);
-				if (node?.kind === "list" && Array.isArray(value)) return Object.freeze(toArray(indexedKeys(value, node.keyOf)));
-				return Object.freeze([]);
+				require_transform.assertScope(active);
+				if (cachedIds) return cachedIds;
+				if (treeNodes) return cachedIds = node?.kind === "tree" && require_record.isRecord(value) && require_record.isRecord(value.nodes) ? Object.freeze(Object.keys(value.nodes)) : Object.freeze([]);
+				if (node?.kind === "map" && require_record.isRecord(value)) return cachedIds = Object.freeze(Object.keys(value));
+				if (node?.kind === "table" && require_record.isRecord(value) && Array.isArray(value.ids)) return cachedIds = Object.freeze([...value.ids]);
+				if (node?.kind === "list" && Array.isArray(value)) return cachedIds = Object.freeze(toArray(indexedKeys(value, node.keyOf)));
+				return cachedIds = Object.freeze([]);
 			};
 			const has = (key) => {
-				require_scheduler.assertScope(active);
+				require_transform.assertScope(active);
 				if (treeNodes) return Boolean(node?.kind === "tree" && require_record.isRecord(value) && require_record.isRecord(value.nodes) && Object.hasOwn(value.nodes, key));
 				if (node?.kind === "map" && require_record.isRecord(value)) return Object.hasOwn(value, key);
 				if (node?.kind === "table" && require_record.isRecord(value) && require_record.isRecord(value.byId)) return Object.hasOwn(value.byId, key);
@@ -4669,7 +4820,7 @@ const createDocumentSourceRegistry = (scheduler) => {
 			};
 			return Object.freeze({
 				get: (key) => {
-					require_scheduler.assertScope(active);
+					require_transform.assertScope(active);
 					if (!snapshots.has(key)) if (!has(key)) snapshots.set(key, void 0);
 					else {
 						const current = raw(key);
@@ -5016,7 +5167,7 @@ const materializeInputSource = (scheduler, definition) => {
 	}
 	if (source.kind !== "collection-input") throw new Error("Invalid projection input source.");
 	const values = new Map(source.initial);
-	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => require_scheduler.mapRead(values), definition.output.equality, () => void 0);
+	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => require_transform.mapRead(values), definition.output.equality, () => void 0);
 	return {
 		...boundary,
 		write: {
@@ -5029,17 +5180,17 @@ const materializeInputSource = (scheduler, definition) => {
 				let active = true;
 				const draft = Object.freeze({
 					get: (key) => {
-						require_scheduler.assertScope(() => active);
+						require_transform.assertScope(() => active);
 						const entry = staged.get(key);
 						return entry ? entry.present ? entry.value : void 0 : values.get(key);
 					},
 					has: (key) => {
-						require_scheduler.assertScope(() => active);
+						require_transform.assertScope(() => active);
 						const entry = staged.get(key);
 						return entry ? entry.present : values.has(key);
 					},
 					set: (key, value) => {
-						require_scheduler.assertScope(() => active);
+						require_transform.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);
@@ -5054,7 +5205,7 @@ const materializeInputSource = (scheduler, definition) => {
 						});
 					},
 					remove: (key) => {
-						require_scheduler.assertScope(() => active);
+						require_transform.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);
@@ -5067,7 +5218,7 @@ const materializeInputSource = (scheduler, definition) => {
 					}
 				});
 				try {
-					require_scheduler.assertSynchronous(run(draft));
+					require_transform.assertSynchronous(run(draft));
 				} finally {
 					active = false;
 				}
@@ -5132,19 +5283,249 @@ const createSourceRegistry = (scheduler) => {
 	};
 };
 //#endregion
+//#region core/src/projection/readable/keyed.ts
+/** Runtime-owned keyed consumer family over one materialized collection output. */
+const createProjectionItems = (source, checkOwner) => {
+	if (source.kind !== "collection") throw new TypeError("Projection items require a keyed collection projection.");
+	let disposed = false;
+	const active = /* @__PURE__ */ new Map();
+	const followers = /* @__PURE__ */ new Map();
+	const waiting = /* @__PURE__ */ new Map();
+	let keysValue = Object.freeze([...source.current().keys()]);
+	let keysRevision = 0;
+	const keyListeners = /* @__PURE__ */ new Set();
+	const check = () => {
+		if (disposed) throw new require_transform.ProjectionDisposedError();
+		checkOwner();
+	};
+	const notifications = [];
+	const notify = (listeners) => {
+		for (const listener of listeners) notifications.push(listener);
+	};
+	const flushNotifications = () => {
+		try {
+			notifyProjectionListenerSnapshot(notifications, "Projection item listeners failed.");
+		} finally {
+			notifications.length = 0;
+		}
+	};
+	const unregisterWaiting = (state) => {
+		const states = waiting.get(state.key);
+		states?.delete(state);
+		if (states?.size === 0) waiting.delete(state.key);
+	};
+	const registerWaiting = (state) => {
+		if (state.tracked || state.ended) return;
+		const states = waiting.get(state.key);
+		if (states) states.add(state);
+		else waiting.set(state.key, new Set([state]));
+	};
+	const publishState = (state, value) => {
+		if (state.ended) return;
+		if (Object.is(state.value, value)) {
+			state.value = value;
+			return;
+		}
+		state.value = value;
+		state.revision++;
+		notify(state.listeners);
+	};
+	const attachActive = (state, value) => {
+		if (state.ended) return;
+		unregisterWaiting(state);
+		state.tracked = true;
+		const canonical = active.get(state.key);
+		if (!canonical) active.set(state.key, state);
+		else if (canonical !== state) {
+			const states = followers.get(state.key);
+			if (states) states.add(state);
+			else followers.set(state.key, new Set([state]));
+		}
+		publishState(state, value);
+	};
+	const terminateState = (state) => {
+		if (state.ended) return;
+		unregisterWaiting(state);
+		state.tracked = false;
+		publishState(state, void 0);
+		state.ended = true;
+	};
+	const terminateKey = (key) => {
+		const canonical = active.get(key);
+		if (canonical) terminateState(canonical);
+		const extra = followers.get(key);
+		if (extra) for (const state of extra) terminateState(state);
+		active.delete(key);
+		followers.delete(key);
+	};
+	const activateWaiting = (key, value) => {
+		const states = waiting.get(key);
+		if (!states?.size) return;
+		waiting.delete(key);
+		for (const state of states) attachActive(state, value);
+	};
+	const updateKey = (key, value) => {
+		const canonical = active.get(key);
+		if (canonical) publishState(canonical, value);
+		const extra = followers.get(key);
+		if (extra) for (const state of extra) publishState(state, value);
+	};
+	const updateKeys = (current) => {
+		if (require_transform.iterableMatchesArray(current.keys(), keysValue)) return;
+		keysValue = Object.freeze([...current.keys()]);
+		keysRevision++;
+		notify(keyListeners);
+	};
+	const createItem = (key, initial) => {
+		const state = {
+			key,
+			listeners: /* @__PURE__ */ new Set(),
+			tracked: initial !== void 0,
+			ended: false,
+			value: initial?.value,
+			revision: 0
+		};
+		const ensureObserved = () => {
+			if (state.ended || state.tracked) return;
+			const current = source.current();
+			if (current.has(key)) attachActive(state, current.get(key));
+		};
+		state.readable = Object.freeze({
+			current: () => {
+				check();
+				ensureObserved();
+				return state.value;
+			},
+			revision: () => {
+				check();
+				ensureObserved();
+				return state.revision;
+			},
+			subscribe: (listener) => {
+				check();
+				ensureObserved();
+				state.listeners.add(listener);
+				if (!state.tracked && !state.ended) registerWaiting(state);
+				return () => {
+					state.listeners.delete(listener);
+					if (!state.listeners.size && !state.tracked) unregisterWaiting(state);
+				};
+			}
+		});
+		return state;
+	};
+	const reconcile = (current) => {
+		for (const key of active.keys()) if (!current.has(key)) terminateKey(key);
+		else updateKey(key, current.get(key));
+		for (const key of waiting.keys()) if (current.has(key)) activateWaiting(key, current.get(key));
+		updateKeys(current);
+	};
+	const onChange = (change) => {
+		check();
+		const current = source.current();
+		if (!change || change.kind === "reset") {
+			reconcile(current);
+			flushNotifications();
+			return;
+		}
+		for (const entry of change.removed) terminateKey(entry.key);
+		for (const entry of change.added) activateWaiting(entry.key, entry.after);
+		for (const entry of change.updated) updateKey(entry.key, entry.after);
+		if (change.added.length || change.removed.length || change.order) updateKeys(current);
+		flushNotifications();
+	};
+	const stop = source.subscribe(onChange);
+	const keys = Object.freeze({
+		current: () => {
+			check();
+			return keysValue;
+		},
+		revision: () => {
+			check();
+			return keysRevision;
+		},
+		subscribe: (listener) => {
+			check();
+			keyListeners.add(listener);
+			return () => keyListeners.delete(listener);
+		}
+	});
+	return {
+		items: Object.freeze({
+			keys,
+			get: (key) => {
+				check();
+				const canonical = active.get(key);
+				if (canonical) return canonical.readable;
+				const pending = waiting.get(key)?.values().next().value;
+				if (pending) return pending.readable;
+				const current = source.current();
+				if (current.has(key)) {
+					const state = createItem(key, {
+						present: true,
+						value: current.get(key)
+					});
+					active.set(key, state);
+					return state.readable;
+				}
+				return createItem(key).readable;
+			}
+		}),
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			stop();
+			keyListeners.clear();
+			const known = /* @__PURE__ */ new Set();
+			active.forEach((state) => known.add(state));
+			followers.forEach((states) => states.forEach((state) => known.add(state)));
+			waiting.forEach((states) => states.forEach((state) => known.add(state)));
+			known.forEach((state) => state.listeners.clear());
+			active.clear();
+			followers.clear();
+			waiting.clear();
+			notifications.length = 0;
+		}
+	};
+};
+//#endregion
 //#region core/src/projection/runtime.ts
 const createProjectionRuntime = (options) => {
-	const scheduler = require_scheduler.createScheduler(options?.onError ?? (() => void 0));
+	const scheduler = require_transform.createScheduler(options?.onError ?? (() => void 0));
 	const sources = createSourceRegistry(scheduler);
 	const materialized = /* @__PURE__ */ new WeakMap();
 	const publicViews = /* @__PURE__ */ new WeakMap();
 	const scopes = /* @__PURE__ */ new Set();
+	const rootItems = /* @__PURE__ */ new Map();
+	const disposeItemControllers = (registry, failures) => {
+		const controllers = [...registry.values()];
+		registry.clear();
+		for (const controller of controllers) try {
+			controller.dispose();
+		} catch (error) {
+			failures.push(error);
+		}
+	};
+	const disposeScopeConsumers = (state, failures) => {
+		disposeItemControllers(state.items, failures);
+		const subscriptions = [...state.subscriptions];
+		state.subscriptions.clear();
+		for (const unsubscribe of subscriptions) try {
+			unsubscribe();
+		} catch (error) {
+			failures.push(error);
+		}
+	};
+	const throwCleanupFailures = (failures, message) => {
+		if (failures.length === 1) throw failures[0];
+		if (failures.length) throw new AggregateError(failures, message);
+	};
 	const assertAccess = (definition, requester) => {
 		scheduler.assertActive();
 		const owner = definition.owner;
 		if (owner === void 0) return;
 		if (owner !== requester) throw new TypeError("Projection belongs to another scope.");
-		if (!requester?.active) throw new require_scheduler.ProjectionDisposedError();
+		if (!requester?.active) throw new require_transform.ProjectionDisposedError();
 	};
 	const rememberScoped = (definition, requester) => {
 		if (requester && definition.owner === requester) requester.materialized.push(definition);
@@ -5162,7 +5543,7 @@ const createProjectionRuntime = (options) => {
 				...source.write ? { write: source.write } : {}
 			});
 		} else {
-			if (definition.owner === void 0 && definition.dependencies.some((dependency) => require_scheduler.producerOf(dependency).owner !== void 0)) throw new TypeError("A root projection cannot depend on a scoped projection.");
+			if (definition.owner === void 0 && definition.dependencies.some((dependency) => require_transform.producerOf(dependency).owner !== void 0)) throw new TypeError("A root projection cannot depend on a scoped projection.");
 			const dependencies = definition.dependencies.map((dependency) => resolveOutput(dependency, requester));
 			const processor = createProcessor(scheduler, definition, Object.freeze(dependencies));
 			result = Object.freeze({
@@ -5176,14 +5557,14 @@ const createProjectionRuntime = (options) => {
 		return result;
 	};
 	const resolveOutput = (projection, requester) => {
-		const ref = require_scheduler.projectionRef(projection);
+		const ref = require_transform.projectionRef(projection);
 		const output = materializeProducer(ref.producer, requester).outputs[ref.output];
 		if (!output) throw new TypeError("Projection output does not exist.");
 		return output;
 	};
 	const assertOutput = (output) => {
 		scheduler.assertActive();
-		if (output.owner.disposed) throw new require_scheduler.ProjectionDisposedError();
+		if (output.owner.disposed) throw new require_transform.ProjectionDisposedError();
 		if (output.owner.fault) throw output.owner.fault;
 	};
 	const publicCurrent = (output) => {
@@ -5193,7 +5574,7 @@ const createProjectionRuntime = (options) => {
 		const cached = publicViews.get(output);
 		if (cached?.revision === revision) return cached.value;
 		if (output.kind === "collection") {
-			const value = require_scheduler.collectionView(current);
+			const value = require_transform.collectionView(current);
 			publicViews.set(output, {
 				revision,
 				value
@@ -5201,7 +5582,7 @@ const createProjectionRuntime = (options) => {
 			return value;
 		}
 		if (isMapLike(current)) {
-			const value = require_scheduler.snapshotCollectionView(require_scheduler.mapRead(current));
+			const value = require_transform.snapshotCollectionView(require_transform.mapRead(current));
 			publicViews.set(output, {
 				revision,
 				value
@@ -5224,6 +5605,19 @@ const createProjectionRuntime = (options) => {
 			subscribe: output.subscribe
 		});
 	};
+	const projectionItems = (projection, requester) => {
+		const output = resolveOutput(projection, requester);
+		if (output.kind !== "collection") throw new TypeError("Projection items require a keyed collection projection.");
+		const registry = requester?.items ?? rootItems;
+		const existing = registry.get(output);
+		if (existing) return existing.items;
+		const controller = createProjectionItems(readableSource(projection, requester), () => {
+			if (requester && !requester.active) throw new require_transform.ProjectionDisposedError();
+			assertOutput(output);
+		});
+		registry.set(output, controller);
+		return controller.items;
+	};
 	const makeReadable = (projection, selector, equality, requester) => {
 		const source = readableSource(projection, requester);
 		return selector ? createSelectorReadable(source, selector, equality) : createDirectReadable(source);
@@ -5232,7 +5626,7 @@ const createProjectionRuntime = (options) => {
 		return makeReadable(projection, selector, equality);
 	}
 	const inputWrite = (target, requester) => {
-		const ref = require_scheduler.projectionRef(target);
+		const ref = require_transform.projectionRef(target);
 		if (ref.output !== 0 || ref.producer.kind !== "source") throw new TypeError("Projection is not an input.");
 		if (ref.producer.source.kind !== "value-input" && ref.producer.source.kind !== "collection-input") throw new TypeError("Projection is not an input.");
 		const write = materializeProducer(ref.producer, requester).write;
@@ -5257,13 +5651,7 @@ const createProjectionRuntime = (options) => {
 		scheduler.assertIdle();
 		state.active = false;
 		const failures = [];
-		const subscriptions = [...state.subscriptions];
-		state.subscriptions.clear();
-		for (const unsubscribe of subscriptions) try {
-			unsubscribe();
-		} catch (error) {
-			failures.push(error);
-		}
+		disposeScopeConsumers(state, failures);
 		for (let index = state.materialized.length - 1; index >= 0; index--) {
 			const definition = state.materialized[index];
 			const current = materialized.get(definition);
@@ -5278,25 +5666,26 @@ const createProjectionRuntime = (options) => {
 		}
 		state.materialized.length = 0;
 		scopes.delete(state);
-		if (failures.length) throw failures[0];
+		throwCleanupFailures(failures, "Projection scope cleanup failed.");
 	};
 	const createScope = () => {
 		scheduler.assertIdle();
 		const state = {
 			active: true,
 			materialized: [],
-			subscriptions: /* @__PURE__ */ new Set()
+			subscriptions: /* @__PURE__ */ new Set(),
+			items: /* @__PURE__ */ new Map()
 		};
 		scopes.add(state);
 		const assertActive = () => {
-			if (!state.active) throw new require_scheduler.ProjectionDisposedError();
+			if (!state.active) throw new require_transform.ProjectionDisposedError();
 			scheduler.assertActive();
 		};
 		function own(target) {
 			assertActive();
 			const projections = [];
 			const collect = (value) => {
-				if (require_scheduler.isProjection(value)) {
+				if (require_transform.isProjection(value)) {
 					projections.push(value);
 					return;
 				}
@@ -5306,13 +5695,13 @@ const createProjectionRuntime = (options) => {
 					const descriptor = Object.getOwnPropertyDescriptor(value, key);
 					if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError("Projection ownership tree must use enumerable data properties.");
 					const child = descriptor.value;
-					if (!require_scheduler.isProjection(child) && !require_record.isPlainObject(child)) throw new TypeError("Projection ownership tree leaves must be projections.");
+					if (!require_transform.isProjection(child) && !require_record.isPlainObject(child)) throw new TypeError("Projection ownership tree leaves must be projections.");
 					collect(child);
 				}
 			};
 			collect(target);
 			if (!projections.length) throw new TypeError("Projection ownership tree must contain a projection.");
-			require_scheduler.ownProjections(projections, state);
+			require_transform.ownProjections(projections, state);
 			return target;
 		}
 		function scopeSelect(projection, selector, equality) {
@@ -5357,6 +5746,10 @@ const createProjectionRuntime = (options) => {
 				return readProjection(projection, state);
 			},
 			select: scopeSelect,
+			items: (projection) => {
+				assertActive();
+				return projectionItems(projection, state);
+			},
 			update: scopeUpdate,
 			batch: scopeBatch,
 			dispose: () => disposeScope(state)
@@ -5365,6 +5758,7 @@ const createProjectionRuntime = (options) => {
 	return Object.freeze({
 		read: readProjection,
 		select: selectProjection,
+		items: projectionItems,
 		update,
 		batch,
 		scope: createScope,
@@ -5374,16 +5768,11 @@ const createProjectionRuntime = (options) => {
 			const failures = [];
 			for (const scope of scopes) {
 				scope.active = false;
-				const subscriptions = [...scope.subscriptions];
-				scope.subscriptions.clear();
-				for (const unsubscribe of subscriptions) try {
-					unsubscribe();
-				} catch (error) {
-					failures.push(error);
-				}
+				disposeScopeConsumers(scope, failures);
 				scope.materialized.length = 0;
 			}
 			scopes.clear();
+			disposeItemControllers(rootItems, failures);
 			try {
 				sources.dispose();
 			} catch (error) {
@@ -5394,8 +5783,7 @@ const createProjectionRuntime = (options) => {
 			} catch (error) {
 				failures.push(error);
 			}
-			if (failures.length === 1) throw failures[0];
-			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
+			throwCleanupFailures(failures, "Projection cleanup failed.");
 		}
 	});
 };
@@ -5403,8 +5791,8 @@ const createProjectionRuntime = (options) => {
 exports.DocumentDisposedError = DocumentDisposedError;
 exports.DocumentReentrancyError = DocumentReentrancyError;
 exports.ParseError = ParseError;
-exports.ProjectionDisposedError = require_scheduler.ProjectionDisposedError;
-exports.ProjectionError = require_scheduler.ProjectionError;
+exports.ProjectionDisposedError = require_transform.ProjectionDisposedError;
+exports.ProjectionError = require_transform.ProjectionError;
 exports.TransactionRejected = TransactionRejected;
 exports.createDocument = createDocument;
 exports.createProjectionRuntime = createProjectionRuntime;