doxum 0.1.28 → 0.1.30

package/dist/index.cjs

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_transform = require("./transform-DUleAsG0.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;
@@ -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) => {
@@ -1373,6 +1399,17 @@ const contains = (parent, child) => {
 	}
 	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) => {
@@ -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);
@@ -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;
@@ -1931,7 +1969,9 @@ 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);
@@ -2880,12 +2920,7 @@ const createKeyedGet = (source, key, equality = Object.is) => {
 				} else if (sourceRevision !== collection.revision) {
 					const change = collection.change;
 					if (!change || change.kind === "reset") affected = true;
-					else if (selected !== void 0) {
-						for (const changedKey of require_transform.collectionChange.keys(change)) if (changedKey === selected) {
-							affected = true;
-							break;
-						}
-					}
+					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;
@@ -3049,9 +3084,7 @@ function createKeyedGroupBy(source, dependenciesOrSelector, maybeSelector) {
 		outputs: [{
 			kind: "collection",
 			equality: (previous, next) => {
-				const left = previous;
-				const right = next;
-				return left.length === right.length && left.every((key, index) => key === right[index]);
+				return require_transform.sameArray(previous, next);
 			}
 		}],
 		create: () => {
@@ -3095,11 +3128,14 @@ function createKeyedGroupBy(source, dependenciesOrSelector, maybeSelector) {
 				output.output.set(group, Object.freeze(members));
 			};
 			const publishGroupOrder = (output) => {
-				const order = [...groupRanks.entries()].sort(([leftKey, left], [rightKey, right]) => {
+				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;
-				}).map(([group]) => group);
+				});
 				output.output.order(order);
 			};
 			const rebuild = (driver, sources, output) => {
@@ -3151,7 +3187,8 @@ function createKeyedGroupBy(source, dependenciesOrSelector, maybeSelector) {
 							return;
 						} else {
 							for (const entry of change.removed) {
-								orderDirty ||= removeSourceKey(entry.key, affected);
+								const changed = removeSourceKey(entry.key, affected);
+								orderDirty ||= changed;
 								dependencies.remove(entry.key);
 								dirty.delete(entry.key);
 							}
@@ -3164,7 +3201,10 @@ function createKeyedGroupBy(source, dependenciesOrSelector, maybeSelector) {
 					}
 					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);
+					for (const key of dirty) {
+						const changed = selectGroups(driver, evaluation.sources, key, affected);
+						orderDirty ||= changed;
+					}
 					if (structural) markAllGroups(output, affected);
 					publishAffected(affected, output, orderDirty);
 					dependencies.remember(evaluation.sources);
@@ -3368,13 +3408,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: () => {
@@ -3387,7 +3428,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;
@@ -3403,12 +3444,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;
@@ -3425,7 +3469,9 @@ const createCollectionOutput = (binding) => {
 			},
 			ids: () => {
 				require_transform.assertScope(active);
-				return next ? Object.freeze(explicitOrder ? [...explicitOrder] : [...deriveIds()]) : published.ids();
+				if (!next) return published.ids();
+				if (explicitOrder) return explicitOrder;
+				return Object.freeze(deriveIds());
 			}
 		});
 		return {
@@ -3446,7 +3492,7 @@ const createCollectionOutput = (binding) => {
 				},
 				order: (order) => {
 					require_transform.assertScope(active);
-					explicitOrder = Object.freeze([...order]);
+					explicitOrder = require_transform.snapshotArray(order);
 				}
 			}
 		};
@@ -3456,8 +3502,6 @@ const createCollectionOutput = (binding) => {
 			for (const key of published.keys()) if (!staged.has(key)) staged.set(key, { present: false });
 		}
 		require_transform.profile.projection("touchedKeys", staged.size);
-		const added = /* @__PURE__ */ new Set();
-		const removed = /* @__PURE__ */ new Set();
 		const addedEntries = [];
 		const updatedEntries = [];
 		const removedEntries = [];
@@ -3465,7 +3509,6 @@ const createCollectionOutput = (binding) => {
 			const existed = published.has(key);
 			if (entry.present) {
 				if (!existed) {
-					added.add(key);
 					addedEntries.push({
 						key,
 						after: entry.value
@@ -3481,19 +3524,28 @@ 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_transform.profile.projection("changedKeys", addedEntries.length + updatedEntries.length + removedEntries.length);
 		change = nextReset ? Object.freeze({ kind: "reset" }) : require_transform.createCollectionChange({
@@ -3810,18 +3862,19 @@ const createProcessor = (scheduler, definition, dependencies) => {
 };
 //#endregion
 //#region core/src/projection/readable/listeners.ts
-/** Exhaustively notifies one projection-readable listener snapshot. */
-const notifyProjectionListeners = (listeners, message) => {
-	const snapshot = [...listeners];
-	const failures = [];
-	for (const listener of snapshot) try {
+/** 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);
+		(failures ??= []).push(error);
 	}
-	if (failures.length === 1) throw failures[0];
-	if (failures.length) throw new AggregateError(failures, message);
+	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;
@@ -3876,8 +3929,7 @@ const selectionAffects = (selection, change) => {
 	if (!change || change.kind === "reset") return true;
 	if (selection.all) return true;
 	if (selection.structure && require_transform.collectionHasStructuralChange(change)) return true;
-	for (const key of require_transform.collectionChange.keys(change)) if (selection.keys.has(key)) return true;
-	return false;
+	return require_transform.collectionChangeIntersects(change, selection.keys);
 };
 const createDirectReadable = (source) => Object.freeze({
 	current: source.current,
@@ -3919,7 +3971,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
 		});
@@ -4161,10 +4213,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();
@@ -4172,10 +4225,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;
@@ -4183,15 +4243,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,
@@ -4221,19 +4284,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) => {
@@ -4245,13 +4308,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)) {
@@ -4262,34 +4327,27 @@ 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
@@ -4418,16 +4476,29 @@ const stageCollectionRead = (state, read, active, options) => {
 		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_transform.profile.collectionView.idsScanned(keys.length);
-		for (const key of keys) if (read.has(key)) {
+		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_transform.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);
@@ -4721,13 +4792,15 @@ const createDocumentSourceRegistry = (scheduler) => {
 			const snapshots = /* @__PURE__ */ new Map();
 			const replacement = createDocumentDirty();
 			if (pending.reset) markDocumentReplace(replacement, []);
+			let cachedIds;
 			const ids = () => {
 				require_transform.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([]);
+				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_transform.assertScope(active);
@@ -5215,7 +5288,6 @@ const createSourceRegistry = (scheduler) => {
 };
 //#endregion
 //#region core/src/projection/readable/keyed.ts
-const sameKeys = (previous, next) => previous.length === next.length && previous.every((key, index) => key === next[index]);
 /** 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.");
@@ -5235,7 +5307,11 @@ const createProjectionItems = (source, checkOwner) => {
 		for (const listener of listeners) notifications.push(listener);
 	};
 	const flushNotifications = () => {
-		notifyProjectionListeners(notifications.splice(0), "Projection item listeners failed.");
+		try {
+			notifyProjectionListenerSnapshot(notifications, "Projection item listeners failed.");
+		} finally {
+			notifications.length = 0;
+		}
 	};
 	const unregisterWaiting = (state) => {
 		const states = waiting.get(state.key);
@@ -5278,16 +5354,11 @@ const createProjectionItems = (source, checkOwner) => {
 		publishState(state, void 0);
 		state.ended = true;
 	};
-	const statesFor = (key) => {
-		const result = [];
+	const terminateKey = (key) => {
 		const canonical = active.get(key);
-		if (canonical) result.push(canonical);
+		if (canonical) terminateState(canonical);
 		const extra = followers.get(key);
-		if (extra) result.push(...extra);
-		return result;
-	};
-	const terminateKey = (key) => {
-		for (const state of statesFor(key)) terminateState(state);
+		if (extra) for (const state of extra) terminateState(state);
 		active.delete(key);
 		followers.delete(key);
 	};
@@ -5298,12 +5369,14 @@ const createProjectionItems = (source, checkOwner) => {
 		for (const state of states) attachActive(state, value);
 	};
 	const updateKey = (key, value) => {
-		for (const state of statesFor(key)) publishState(state, 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) => {
-		const next = Object.freeze([...current.keys()]);
-		if (sameKeys(keysValue, next)) return;
-		keysValue = next;
+		if (require_transform.iterableMatchesArray(current.keys(), keysValue)) return;
+		keysValue = Object.freeze([...current.keys()]);
 		keysRevision++;
 		notify(keyListeners);
 	};
@@ -5346,9 +5419,9 @@ const createProjectionItems = (source, checkOwner) => {
 		return state;
 	};
 	const reconcile = (current) => {
-		for (const key of [...active.keys()]) if (!current.has(key)) terminateKey(key);
+		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));
+		for (const key of waiting.keys()) if (current.has(key)) activateWaiting(key, current.get(key));
 		updateKeys(current);
 	};
 	const onChange = (change) => {