doxum 0.1.26 → 0.1.28

package/dist/transform-DUleAsG0.cjs

@@ -0,0 +1,1105 @@
+const require_record = require("./record-ChYUi8PP.cjs");
+const profile = {
+	projection: (key, amount = 1) => {},
+	recorder: (key, amount = 1) => {},
+	access: (key) => {},
+	copy: {
+		structure: () => {},
+		treeNode: () => {},
+		shallowRecord: (items) => {}
+	},
+	equality: {
+		call: () => {},
+		container: () => {}
+	},
+	address: {
+		listIndex: (items) => {},
+		schemaStep: () => {},
+		documentStep: () => {},
+		prefixComparison: () => {},
+		segmentCompared: () => {}
+	},
+	impact: {
+		index: () => {},
+		affects: () => {}
+	},
+	dependency: {
+		comparison: () => {},
+		segmentCompared: () => {}
+	},
+	collectionIndex: {
+		node: () => {},
+		build: (items) => {}
+	},
+	collectionView: {
+		mapped: () => {},
+		idsScanned: (amount = 1) => {},
+		arrayCopied: () => {}
+	},
+	materialized: {
+		updated: () => {},
+		rebuilt: () => {},
+		notification: () => {}
+	}
+};
+//#endregion
+//#region core/src/projection/definition.ts
+const projections = /* @__PURE__ */ new WeakMap();
+const defineRef = (producer, output) => {
+	const handle = Object.freeze({});
+	projections.set(handle, Object.freeze({
+		producer,
+		output
+	}));
+	return handle;
+};
+const projectionRef = (projection) => {
+	const ref = projections.get(projection);
+	if (!ref) throw new TypeError("Unknown projection definition.");
+	return ref;
+};
+const producerOf = (projection) => projectionRef(projection).producer;
+/** Resolves the immutable output description owned by a projection definition. */
+const outputDefinitionOf = (projection) => {
+	const ref = projectionRef(projection);
+	const producer = ref.producer;
+	const output = producer.kind === "source" ? producer.output : producer.outputs[ref.output];
+	if (!output) throw new TypeError("Projection output does not exist.");
+	return output;
+};
+const isProjection = (value) => value !== null && typeof value === "object" && projections.has(value);
+const ownProjections = (projections, owner) => {
+	const producers = new Set(projections.map(producerOf));
+	for (const producer of producers) {
+		if (producer.owner !== void 0 && producer.owner !== owner) throw new TypeError("Projection producer already belongs to another scope.");
+		if (producer.owner === void 0 && producer.materialized) throw new TypeError("A materialized root projection cannot become scope-owned.");
+		if (producer.kind !== "processor") continue;
+		for (const dependency of producer.dependencies) {
+			const dependencyOwner = producerOf(dependency).owner;
+			if (dependencyOwner !== void 0 && dependencyOwner !== owner) throw new TypeError("A scope cannot depend on another scope.");
+		}
+	}
+	for (const producer of producers) producer.owner = owner;
+};
+const freezeOutput = (output) => Object.freeze({
+	kind: output.kind,
+	equality: output.equality,
+	...output.path ? { path: Object.freeze([...output.path]) } : {}
+});
+const defineProcessor = (definition) => {
+	if (!Array.isArray(definition.dependencies)) throw new TypeError("Projection dependencies must be an array.");
+	definition.dependencies.forEach(projectionRef);
+	if (!definition.outputs.length) throw new TypeError("Projection processor requires an output.");
+	const producer = {
+		kind: "processor",
+		dependencies: Object.freeze([...definition.dependencies]),
+		outputs: Object.freeze(definition.outputs.map(freezeOutput)),
+		create: definition.create,
+		...definition.name ? { name: definition.name } : {}
+	};
+	return Object.freeze(producer.outputs.map((_, output) => defineRef(producer, output)));
+};
+const defineSource = (source, output) => {
+	return defineRef({
+		kind: "source",
+		source,
+		output: freezeOutput(output)
+	}, 0);
+};
+//#endregion
+//#region core/src/projection/collection/view.ts
+const mapRead = (value) => ({
+	get: (key) => value.get(key),
+	has: (key) => value.has(key),
+	ids: () => Object.freeze([...value.keys()])
+});
+/** Immutable map-like view over a CollectionRead. */
+const collectionView = (read) => {
+	const ids = read.ids();
+	const entries = function* () {
+		for (const key of ids) yield [key, read.get(key)];
+	};
+	const values = function* () {
+		for (const key of ids) yield read.get(key);
+	};
+	const view = {
+		get: (key) => read.get(key),
+		has: (key) => read.has(key),
+		get size() {
+			return ids.length;
+		},
+		keys: () => ids[Symbol.iterator](),
+		values,
+		entries,
+		forEach: (callback, thisArg) => {
+			for (const key of ids) callback.call(thisArg, read.get(key), key, view);
+		},
+		[Symbol.iterator]: entries
+	};
+	return Object.freeze(view);
+};
+/** Eager durable view used when a processor result may retain its dependency value. */
+const snapshotCollectionView = (read) => {
+	const ids = read.ids();
+	const values = /* @__PURE__ */ new Map();
+	for (const key of ids) values.set(key, read.get(key));
+	return collectionView(mapRead(values));
+};
+//#endregion
+//#region core/src/projection/dependency.ts
+/** Owns validation of the shared named dependency object shape. */
+const readNamedDependencyEntries = (dependencies, label) => {
+	if (!require_record.isPlainObject(dependencies) || isProjection(dependencies)) throw new TypeError(`${label} dependencies must be a plain object.`);
+	const entries = [];
+	for (const name of Reflect.ownKeys(dependencies)) {
+		if (typeof name !== "string") throw new TypeError(`${label} dependency names must be strings.`);
+		const descriptor = Object.getOwnPropertyDescriptor(dependencies, name);
+		if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError(`${label} dependencies must be enumerable data properties.`);
+		entries.push(Object.freeze({
+			name,
+			value: descriptor.value
+		}));
+	}
+	return Object.freeze(entries);
+};
+/** Creates the durable dependency value exposed to pure derive callbacks. */
+const snapshotDependencyValue = (source) => source.kind === "value" ? source.value : snapshotCollectionView(source.read);
+/** Compiles the shared named Projection dependency declaration contract. */
+const compileProjectionDependencies = (dependencies, label) => {
+	const names = [];
+	const projections = [];
+	for (const { name, value } of readNamedDependencyEntries(dependencies, label)) {
+		const projection = value;
+		projectionRef(projection);
+		names.push(name);
+		projections.push(projection);
+	}
+	return Object.freeze({
+		names: Object.freeze(names),
+		projections: Object.freeze(projections)
+	});
+};
+//#endregion
+//#region core/src/projection/collection/change.ts
+const commonOrderChanged = (before, after, added, removed) => {
+	const beforeCommon = before.filter((key) => !removed.has(key));
+	const afterCommon = after.filter((key) => !added.has(key));
+	return beforeCommon.some((key, index) => afterCommon[index] !== key);
+};
+/** Builds the canonical incremental CollectionChange from already-known net transitions. */
+const createCollectionChange = (input) => {
+	const addedKeys = new Set(input.added.map((entry) => entry.key));
+	const removedKeys = new Set(input.removed.map((entry) => entry.key));
+	const orderChanged = input.beforeOrder !== input.afterOrder && commonOrderChanged(input.beforeOrder, input.afterOrder, addedKeys, removedKeys);
+	if (!input.added.length && !input.updated.length && !input.removed.length && !orderChanged) return void 0;
+	return Object.freeze({
+		kind: "incremental",
+		added: Object.freeze([...input.added]),
+		updated: Object.freeze([...input.updated]),
+		removed: Object.freeze([...input.removed]),
+		...orderChanged ? { order: Object.freeze({
+			before: Object.freeze([...input.beforeOrder]),
+			after: Object.freeze([...input.afterOrder])
+		}) } : {}
+	});
+};
+/** Exact fallback diff between two published map-like snapshots. */
+const diffCollection = (previous, current, isEqual = Object.is) => {
+	const added = [];
+	const updated = [];
+	const removed = [];
+	for (const [key, before] of previous) if (!current.has(key)) removed.push({
+		key,
+		before
+	});
+	else {
+		const after = current.get(key);
+		if (!isEqual(before, after)) updated.push({
+			key,
+			before,
+			after
+		});
+	}
+	for (const [key, after] of current) if (!previous.has(key)) added.push({
+		key,
+		after
+	});
+	return createCollectionChange({
+		added,
+		updated,
+		removed,
+		beforeOrder: [...previous.keys()],
+		afterOrder: [...current.keys()]
+	});
+};
+const changedKeys = function* (change) {
+	if (change.kind !== "incremental") throw new TypeError("collectionChange.keys requires an incremental CollectionChange.");
+	for (const entry of change.added) yield entry.key;
+	for (const entry of change.updated) yield entry.key;
+	for (const entry of change.removed) yield entry.key;
+};
+const collectionChange = Object.freeze({ keys: changedKeys });
+const collectionHasStructuralChange = (change) => change.kind === "reset" || Boolean(change.added.length || change.removed.length || change.order);
+//#endregion
+//#region core/src/projection/contract.ts
+var ProjectionError = class extends Error {
+	cause;
+	constructor(phase, cause) {
+		super(`Projection ${phase} failed.`, { cause });
+		this.phase = phase;
+		this.name = "ProjectionError";
+		this.cause = cause;
+	}
+};
+var ProjectionDisposedError = class extends Error {
+	constructor() {
+		super("Projection has been disposed.");
+		this.name = "ProjectionDisposedError";
+	}
+};
+//#endregion
+//#region core/src/projection/graph/scheduler.ts
+const createScheduler = (onError) => {
+	let disposed = false;
+	let depth = 0;
+	let batchSequence = 0;
+	let activeBatch;
+	let phase = "idle";
+	let sequence = 0;
+	const sources = /* @__PURE__ */ new Set();
+	const processors = /* @__PURE__ */ new Set();
+	const pendingSources = /* @__PURE__ */ new Set();
+	const heap = [];
+	const queued = /* @__PURE__ */ new Set();
+	const completed = /* @__PURE__ */ new Set();
+	const emissions = /* @__PURE__ */ new Set();
+	const errors = [];
+	let reportingFailures = [];
+	const guards = /* @__PURE__ */ new Set();
+	const assertActive = () => {
+		if (disposed) throw new ProjectionDisposedError();
+	};
+	const assertIdle = () => {
+		assertActive();
+		if (phase !== "idle") throw new Error("Projection cannot be re-entered during processing or notification.");
+	};
+	const lock = (value) => guards.forEach((guard) => guard(value));
+	const enqueue = (processor) => {
+		if (processor.disposed || queued.has(processor)) return;
+		queued.add(processor);
+		profile.projection("scheduledNodes");
+		let index = heap.length;
+		heap.push(processor);
+		while (index > 0) {
+			const parent = index - 1 >> 1;
+			if (heap[parent].order < processor.order) break;
+			heap[index] = heap[parent];
+			index = parent;
+		}
+		heap[index] = processor;
+	};
+	const pop = () => {
+		const first = heap[0];
+		const last = heap.pop();
+		if (heap.length) {
+			let index = 0;
+			while (index * 2 + 1 < heap.length) {
+				let child = index * 2 + 1;
+				if (child + 1 < heap.length && heap[child + 1].order < heap[child].order) child++;
+				if (last.order < heap[child].order) break;
+				heap[index] = heap[child];
+				index = child;
+			}
+			heap[index] = last;
+		}
+		return first;
+	};
+	const errorFor = (producer, cause, kind = producer.kind === "source" ? "source" : "processor") => new ProjectionError(kind, cause);
+	const capture = (source) => {
+		if (disposed) return;
+		if (phase !== "idle") {
+			source.fault = errorFor(source, /* @__PURE__ */ new Error("Source changed while projection was running."), "source");
+			errors.push(source.fault);
+			throw source.fault;
+		}
+		pendingSources.add(source);
+		profile.projection("sourceEvents");
+		if (source.fault) errors.push(source.fault);
+	};
+	const settleCause = () => {
+		if (activeBatch?.cause !== void 0) return activeBatch.cause;
+		for (const source of pendingSources) {
+			const cause = source.pendingCause();
+			if (cause !== void 0) return cause;
+		}
+	};
+	const settle = () => {
+		if (disposed || depth || phase !== "idle") return;
+		phase = "compute";
+		lock(true);
+		const cause = settleCause();
+		try {
+			for (const source of pendingSources) {
+				if (source.disposed) continue;
+				const wasFaulted = source.fault !== void 0;
+				let changed = false;
+				let force = false;
+				if (!source.fault || source.recovering()) try {
+					const prepared = source.prepare(cause);
+					changed = prepared.changed;
+					force = prepared.force;
+					source.fault = void 0;
+				} catch (failure) {
+					source.fault = errorFor(source, failure, "source");
+					errors.push(source.fault);
+				}
+				const recovered = wasFaulted && !source.fault;
+				if (changed) source.publish();
+				if (source.fault || changed || force || recovered) {
+					const output = source.outputs[0];
+					emissions.add(output);
+					output.forEachConsumer(enqueue);
+				}
+			}
+			while (heap.length) {
+				const processor = pop();
+				if (processor.disposed) continue;
+				const wasFaulted = processor.fault !== void 0;
+				profile.projection("processedNodes");
+				let changedOutputs = Object.freeze([]);
+				const blocked = processor.dependencies.find((output) => output.owner.fault || output.owner.disposed);
+				if (blocked) processor.fault = errorFor(processor, blocked.owner.fault ?? new ProjectionDisposedError(), "blocked");
+				else {
+					const reset = wasFaulted || processor.dependencies.some((output) => output.reset());
+					try {
+						changedOutputs = processor.evaluate(reset, cause, wasFaulted);
+						const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
+						if (dependencyFailure) throw dependencyFailure;
+						processor.fault = void 0;
+					} catch (failure) {
+						const error = errorFor(processor, failure);
+						processor.fault = error;
+						if (!reset) try {
+							changedOutputs = processor.evaluate(true, cause, true);
+							const dependencyFailure = processor.dependencies.find((output) => output.owner.fault)?.owner.fault;
+							if (dependencyFailure) throw dependencyFailure;
+							processor.fault = void 0;
+							errors.push(error);
+						} catch (rebuildFailure) {
+							processor.fault = errorFor(processor, rebuildFailure);
+							errors.push(processor.fault);
+						}
+						else errors.push(error);
+					}
+				}
+				completed.add(processor);
+				const recovered = wasFaulted && !processor.fault;
+				if (processor.fault) processor.outputs.forEach((output) => {
+					emissions.add(output);
+					output.forEachConsumer(enqueue);
+				});
+				else {
+					if (changedOutputs.length) {
+						processor.publish();
+						changedOutputs.forEach((output) => emissions.add(output));
+					}
+					(recovered ? processor.outputs : changedOutputs).forEach((output) => output.forEachConsumer(enqueue));
+				}
+				if (processor.fault || changedOutputs.length) profile.projection("publishedNodes");
+			}
+		} finally {
+			lock(false);
+			phase = "idle";
+		}
+	};
+	const flush = () => {
+		if (disposed || depth) return [];
+		if (pendingSources.size || completed.size) profile.projection("flushes");
+		phase = "notify";
+		lock(true);
+		const reportFailures = [];
+		try {
+			emissions.forEach((output) => output.emit((listener, change) => {
+				try {
+					listener(change);
+				} catch (cause) {
+					errors.push(errorFor(output.owner, cause, "listener"));
+				}
+			}));
+			for (const error of errors.slice()) try {
+				onError(error);
+			} catch (cause) {
+				reportFailures.push(cause);
+			}
+			return Object.freeze([...errors.map((error) => Object.freeze({
+				phase: error.phase === "listener" ? "listener" : "processor",
+				error
+			})), ...reportFailures.map((error) => Object.freeze({
+				phase: "listener",
+				error
+			}))]);
+		} finally {
+			pendingSources.forEach((source) => source.clear());
+			completed.forEach((processor) => processor.clear());
+			pendingSources.clear();
+			queued.clear();
+			completed.clear();
+			emissions.clear();
+			errors.length = 0;
+			reportingFailures = reportFailures;
+			lock(false);
+			phase = "idle";
+		}
+	};
+	const run = () => {
+		settle();
+		const result = flush();
+		const failures = reportingFailures;
+		reportingFailures = [];
+		if (failures.length) throw new AggregateError(failures, "Projection error reporter failed.");
+		return result;
+	};
+	const batch = (callback, options) => {
+		assertIdle();
+		if (depth === 0) activeBatch = Object.freeze({
+			id: ++batchSequence,
+			...options?.cause === void 0 ? {} : { cause: options.cause }
+		});
+		depth++;
+		let failed = false;
+		try {
+			const value = callback();
+			assertSynchronous(value);
+			return value;
+		} catch (error) {
+			failed = true;
+			throw error;
+		} finally {
+			depth--;
+			if (!depth) try {
+				if (failed) try {
+					run();
+				} catch {}
+				else run();
+			} finally {
+				activeBatch = void 0;
+			}
+		}
+	};
+	const releaseProducer = (producer) => {
+		assertIdle();
+		if (producer.outputs.some((output) => output.hasConsumers())) throw new Error("Projection producer is still used by another processor.");
+		producer.disposed = true;
+		if (producer.kind === "processor") {
+			producer.dependencies.forEach((output) => output.detachConsumer(producer));
+			processors.delete(producer);
+			queued.delete(producer);
+			completed.delete(producer);
+		} else {
+			sources.delete(producer);
+			pendingSources.delete(producer);
+		}
+		const failures = [];
+		try {
+			producer.release();
+		} catch (error) {
+			failures.push(error);
+		}
+		try {
+			producer.clear();
+		} catch (error) {
+			failures.push(error);
+		}
+		producer.outputs.forEach((output) => emissions.delete(output));
+		if (failures.length) throw failures[0];
+	};
+	return {
+		assertActive,
+		assertIdle,
+		capture,
+		settle,
+		flush,
+		run,
+		registerGuard(guard) {
+			assertActive();
+			guards.add(guard);
+			let registered = true;
+			return () => {
+				if (!registered) return;
+				registered = false;
+				guards.delete(guard);
+			};
+		},
+		get active() {
+			return !disposed;
+		},
+		addSource(source) {
+			assertIdle();
+			sources.add(source);
+		},
+		addProcessor(processor) {
+			assertIdle();
+			processors.add(processor);
+			processor.dependencies.forEach((output) => output.attachConsumer(processor));
+		},
+		releaseProducer,
+		order: () => sequence++,
+		initialize(callback) {
+			assertIdle();
+			phase = "compute";
+			lock(true);
+			try {
+				return callback();
+			} finally {
+				lock(false);
+				phase = "idle";
+			}
+		},
+		batch,
+		batchContext: () => activeBatch,
+		dispose() {
+			if (disposed) return;
+			assertIdle();
+			disposed = true;
+			const failures = [];
+			processors.forEach((processor) => {
+				processor.disposed = true;
+				try {
+					processor.release();
+				} catch (error) {
+					failures.push(error);
+				}
+			});
+			sources.forEach((source) => {
+				source.disposed = true;
+				try {
+					source.release();
+				} catch (error) {
+					failures.push(error);
+				}
+			});
+			processors.clear();
+			sources.clear();
+			pendingSources.clear();
+			heap.length = 0;
+			queued.clear();
+			completed.clear();
+			emissions.clear();
+			guards.clear();
+			errors.length = 0;
+			reportingFailures = [];
+			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
+		}
+	};
+};
+const assertSynchronous = (value) => {
+	if (value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function") throw new TypeError("Projection callbacks must be synchronous.");
+};
+const assertScope = (active) => {
+	if (!active()) throw new Error("Projection reader or writer is no longer active.");
+};
+//#endregion
+//#region core/src/projection/keyed/relation.ts
+/** Runtime-local domain-neutral many-to-many keyed relation. */
+const createKeyRelation = () => {
+	const forward = /* @__PURE__ */ new Map();
+	const reverse = /* @__PURE__ */ new Map();
+	const detach = (left, right) => {
+		for (const key of right) {
+			const dependents = reverse.get(key);
+			dependents?.delete(left);
+			if (dependents?.size === 0) reverse.delete(key);
+		}
+	};
+	const attach = (left, right) => {
+		for (const key of right) {
+			const dependents = reverse.get(key);
+			if (dependents) dependents.add(left);
+			else reverse.set(key, new Set([left]));
+		}
+	};
+	return {
+		replace(left, right) {
+			const previous = forward.get(left) ?? Object.freeze([]);
+			if (previous.length === right.length && previous.every((key, index) => key === right[index])) return false;
+			detach(left, previous);
+			if (!right.length) {
+				forward.delete(left);
+				return true;
+			}
+			const next = Object.freeze([...right]);
+			forward.set(left, next);
+			attach(left, next);
+			return true;
+		},
+		delete(left) {
+			const previous = forward.get(left);
+			if (!previous) return false;
+			detach(left, previous);
+			forward.delete(left);
+			return true;
+		},
+		forward: (left) => forward.get(left),
+		reverse: (right) => reverse.get(right),
+		lefts: () => forward.keys(),
+		rights: () => reverse.keys(),
+		clear() {
+			forward.clear();
+			reverse.clear();
+		}
+	};
+};
+//#endregion
+//#region core/src/projection/keyed/dependency.ts
+const outputKind = (projection) => outputDefinitionOf(projection).kind;
+const assertKeyedProjection = (projection, role) => {
+	if (outputKind(projection) !== "collection") throw new TypeError(`${role} must be a keyed collection projection.`);
+};
+const compileDynamicDependency = (value, label) => {
+	if (!require_record.isPlainObject(value) || isProjection(value)) throw new TypeError(`${label} dependencies must be projections or singular/plural keyed lookups.`);
+	const candidate = {};
+	const allowed = new Set([
+		"source",
+		"key",
+		"keys"
+	]);
+	let hasKey = false;
+	let hasKeys = false;
+	for (const name of Reflect.ownKeys(value)) {
+		if (typeof name !== "string" || !allowed.has(name)) throw new TypeError(`${label} dynamic keyed dependency contains an unknown property.`);
+		const descriptor = Object.getOwnPropertyDescriptor(value, name);
+		if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError(`${label} dynamic keyed dependency must use enumerable data properties.`);
+		candidate[name] = descriptor.value;
+		if (name === "key") hasKey = true;
+		if (name === "keys") hasKeys = true;
+	}
+	if (!isProjection(candidate.source)) throw new TypeError(`${label} dynamic keyed dependency source must be a projection.`);
+	if (hasKey === hasKeys) throw new TypeError(`${label} dynamic keyed dependency must declare exactly one of key or keys.`);
+	const singular = hasKey;
+	const selector = singular ? candidate.key : candidate.keys;
+	if (typeof selector !== "function") throw new TypeError(`${label} dynamic keyed dependency selector must be a function.`);
+	assertKeyedProjection(candidate.source, `${label} dynamic keyed dependency source`);
+	return singular ? {
+		kind: "one",
+		projection: candidate.source,
+		select: selector
+	} : {
+		kind: "many",
+		projection: candidate.source,
+		select: selector
+	};
+};
+const compileKeyedDependencies = (driver, dependencySpecs, label) => {
+	const entries = [];
+	const projections = [driver];
+	if (dependencySpecs === void 0) return Object.freeze({
+		entries: Object.freeze(entries),
+		projections: Object.freeze(projections)
+	});
+	for (const { name, value: dependency } of readNamedDependencyEntries(dependencySpecs, label)) {
+		if (isProjection(dependency)) {
+			entries.push(Object.freeze({
+				name,
+				kind: "global",
+				projection: dependency
+			}));
+			projections.push(dependency);
+			continue;
+		}
+		const dynamic = compileDynamicDependency(dependency, label);
+		entries.push(Object.freeze({
+			name,
+			...dynamic
+		}));
+		projections.push(dynamic.projection);
+	}
+	return Object.freeze({
+		entries: Object.freeze(entries),
+		projections: Object.freeze(projections)
+	});
+};
+const selectedKeys = (dependency, value, key) => {
+	const result = dependency.select(value, key);
+	assertSynchronous(result);
+	if (dependency.kind === "one") {
+		if (result === void 0) return Object.freeze([]);
+		if (typeof result !== "string") throw new TypeError("Dynamic keyed dependency key must be a string or undefined.");
+		return Object.freeze([result]);
+	}
+	if (!Array.isArray(result)) throw new TypeError("Dynamic keyed dependency keys must be an array of strings.");
+	const seen = /* @__PURE__ */ new Set();
+	const keys = [];
+	for (const selected of result) {
+		if (typeof selected !== "string") throw new TypeError("Dynamic keyed dependency keys must contain only strings.");
+		if (seen.has(selected)) throw new TypeError("Dynamic keyed dependency keys must not contain duplicates.");
+		seen.add(selected);
+		keys.push(selected);
+	}
+	return Object.freeze(keys);
+};
+const emptyValues = Object.freeze(Object.create(null));
+const createKeyedDependencyRuntime = (compiled) => {
+	const states = compiled.entries.map((entry, index) => entry.kind === "global" ? {
+		kind: "global",
+		entry,
+		sourceIndex: index + 1,
+		revision: -1,
+		globalValue: void 0
+	} : {
+		kind: "dynamic",
+		entry,
+		sourceIndex: index + 1,
+		relation: createKeyRelation(),
+		revision: -1
+	});
+	let driverRevision = -1;
+	return {
+		prepare(sources, reset) {
+			for (const state of states) {
+				if (state.kind !== "global") continue;
+				const source = sources[state.sourceIndex];
+				if (reset || state.revision !== source.revision) state.globalValue = snapshotDependencyValue(source);
+			}
+		},
+		resolve(driverValue, driverKey, sources) {
+			if (!states.length) return emptyValues;
+			const values = Object.create(null);
+			for (const state of states) {
+				if (state.kind === "global") {
+					values[state.entry.name] = state.globalValue;
+					continue;
+				}
+				const dependency = state.entry;
+				const source = sources[state.sourceIndex];
+				if (source.kind !== "collection") throw new TypeError("Dynamic keyed dependency resolved to a non-collection source.");
+				const keys = selectedKeys(dependency, driverValue, driverKey);
+				state.relation.replace(driverKey, keys);
+				if (dependency.kind === "one") {
+					const selected = keys[0];
+					values[dependency.name] = selected === void 0 ? void 0 : source.read.get(selected);
+					continue;
+				}
+				const selected = /* @__PURE__ */ new Map();
+				for (const key of keys) if (source.read.has(key)) selected.set(key, source.read.get(key));
+				values[dependency.name] = collectionView(mapRead(selected));
+			}
+			return Object.freeze(values);
+		},
+		driverChanged(source) {
+			return driverRevision !== source.revision;
+		},
+		collectInvalidated(sources, dirty) {
+			let all = false;
+			for (const state of states) {
+				const source = sources[state.sourceIndex];
+				if (state.revision === source.revision) continue;
+				state.entry;
+				if (state.kind === "global") {
+					all = true;
+					continue;
+				}
+				if (source.kind !== "collection" || !source.change || source.change.kind === "reset") {
+					all = true;
+					continue;
+				}
+				for (const sourceKey of collectionChange.keys(source.change)) for (const dependent of state.relation.reverse(sourceKey) ?? []) dirty.add(dependent);
+			}
+			return all;
+		},
+		remove(driverKey) {
+			for (const state of states) if (state.kind === "dynamic") state.relation.delete(driverKey);
+		},
+		clearBindings() {
+			for (const state of states) if (state.kind === "dynamic") state.relation.clear();
+		},
+		remember(sources) {
+			driverRevision = sources[0]?.revision ?? -1;
+			for (const state of states) state.revision = sources[state.sourceIndex].revision;
+		},
+		release() {
+			for (const state of states) {
+				state.revision = -1;
+				if (state.kind === "global") state.globalValue = void 0;
+				else state.relation.clear();
+			}
+			driverRevision = -1;
+		}
+	};
+};
+//#endregion
+//#region core/src/projection/keyed/transform.ts
+const keyedAbsent = Symbol("keyed-transform-absent");
+/** Shared driver-keyed lifecycle for pure and retained keyed transforms. */
+const createKeyedTransform = (definition) => {
+	assertKeyedProjection(definition.source, `${definition.name} source`);
+	const compiled = compileKeyedDependencies(definition.source, definition.dependencies, definition.name);
+	const [projection] = defineProcessor({
+		dependencies: compiled.projections,
+		outputs: [{
+			kind: "collection",
+			equality: definition.equality ?? Object.is
+		}],
+		create: () => {
+			const dependencies = createKeyedDependencyRuntime(compiled);
+			const states = /* @__PURE__ */ new Map();
+			const dropState = (key) => {
+				states.delete(key);
+				dependencies.remove(key);
+			};
+			return {
+				evaluate: (evaluation) => {
+					const driver = evaluation.sources[0];
+					const output = evaluation.outputs[0];
+					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error(`${definition.name} requires collection input and output.`);
+					dependencies.prepare(evaluation.sources, evaluation.reset);
+					const stateFor = (key, value) => {
+						if (states.has(key)) return states.get(key);
+						const state = definition.state ? definition.state(value, key) : void 0;
+						assertSynchronous(state);
+						if (definition.state) states.set(key, state);
+						return state;
+					};
+					const project = (key) => {
+						if (!driver.read.has(key)) return false;
+						const value = driver.read.get(key);
+						const beforePresent = output.previous.has(key);
+						const next = definition.evaluate({
+							key,
+							value,
+							dependencies: dependencies.resolve(value, key, evaluation.sources),
+							state: stateFor(key, value),
+							reset: evaluation.reset,
+							cause: evaluation.cause
+						});
+						assertSynchronous(next);
+						if (next === keyedAbsent) output.output.remove(key);
+						else output.output.set(key, next);
+						return beforePresent !== output.next.has(key);
+					};
+					if (evaluation.reset) {
+						dependencies.clearBindings();
+						const ids = driver.read.ids();
+						const present = new Set(ids);
+						for (const key of [...states.keys()]) if (!present.has(key)) states.delete(key);
+						for (const key of ids) project(key);
+						output.output.order(ids.filter((key) => output.next.has(key)));
+						dependencies.remember(evaluation.sources);
+						return;
+					}
+					const dirty = /* @__PURE__ */ new Set();
+					let all = false;
+					let updateOrder = false;
+					let membershipChanged = false;
+					if (dependencies.driverChanged(driver)) {
+						const change = driver.change;
+						if (!change || change.kind === "reset") {
+							all = true;
+							updateOrder = true;
+							for (const key of output.previous.ids()) {
+								if (driver.read.has(key)) continue;
+								output.output.remove(key);
+								dropState(key);
+								membershipChanged = true;
+							}
+						} else {
+							for (const entry of change.removed) {
+								membershipChanged ||= output.previous.has(entry.key);
+								output.output.remove(entry.key);
+								dropState(entry.key);
+								dirty.delete(entry.key);
+							}
+							for (const entry of change.added) dirty.add(entry.key);
+							for (const entry of change.updated) dirty.add(entry.key);
+							updateOrder = Boolean(change.order);
+						}
+					}
+					all ||= dependencies.collectInvalidated(evaluation.sources, dirty);
+					if (all) for (const key of driver.read.ids()) dirty.add(key);
+					for (const key of dirty) {
+						const changedMembership = project(key);
+						membershipChanged ||= changedMembership;
+					}
+					if (updateOrder || membershipChanged) output.output.order(driver.read.ids().filter((key) => output.next.has(key)));
+					dependencies.remember(evaluation.sources);
+				},
+				release: () => {
+					states.clear();
+					dependencies.release();
+				}
+			};
+		},
+		name: definition.name
+	});
+	return projection;
+};
+//#endregion
+Object.defineProperty(exports, "ProjectionDisposedError", {
+	enumerable: true,
+	get: function() {
+		return ProjectionDisposedError;
+	}
+});
+Object.defineProperty(exports, "ProjectionError", {
+	enumerable: true,
+	get: function() {
+		return ProjectionError;
+	}
+});
+Object.defineProperty(exports, "assertKeyedProjection", {
+	enumerable: true,
+	get: function() {
+		return assertKeyedProjection;
+	}
+});
+Object.defineProperty(exports, "assertScope", {
+	enumerable: true,
+	get: function() {
+		return assertScope;
+	}
+});
+Object.defineProperty(exports, "assertSynchronous", {
+	enumerable: true,
+	get: function() {
+		return assertSynchronous;
+	}
+});
+Object.defineProperty(exports, "collectionChange", {
+	enumerable: true,
+	get: function() {
+		return collectionChange;
+	}
+});
+Object.defineProperty(exports, "collectionHasStructuralChange", {
+	enumerable: true,
+	get: function() {
+		return collectionHasStructuralChange;
+	}
+});
+Object.defineProperty(exports, "collectionView", {
+	enumerable: true,
+	get: function() {
+		return collectionView;
+	}
+});
+Object.defineProperty(exports, "compileKeyedDependencies", {
+	enumerable: true,
+	get: function() {
+		return compileKeyedDependencies;
+	}
+});
+Object.defineProperty(exports, "compileProjectionDependencies", {
+	enumerable: true,
+	get: function() {
+		return compileProjectionDependencies;
+	}
+});
+Object.defineProperty(exports, "createCollectionChange", {
+	enumerable: true,
+	get: function() {
+		return createCollectionChange;
+	}
+});
+Object.defineProperty(exports, "createKeyRelation", {
+	enumerable: true,
+	get: function() {
+		return createKeyRelation;
+	}
+});
+Object.defineProperty(exports, "createKeyedDependencyRuntime", {
+	enumerable: true,
+	get: function() {
+		return createKeyedDependencyRuntime;
+	}
+});
+Object.defineProperty(exports, "createKeyedTransform", {
+	enumerable: true,
+	get: function() {
+		return createKeyedTransform;
+	}
+});
+Object.defineProperty(exports, "createScheduler", {
+	enumerable: true,
+	get: function() {
+		return createScheduler;
+	}
+});
+Object.defineProperty(exports, "defineProcessor", {
+	enumerable: true,
+	get: function() {
+		return defineProcessor;
+	}
+});
+Object.defineProperty(exports, "defineSource", {
+	enumerable: true,
+	get: function() {
+		return defineSource;
+	}
+});
+Object.defineProperty(exports, "diffCollection", {
+	enumerable: true,
+	get: function() {
+		return diffCollection;
+	}
+});
+Object.defineProperty(exports, "isProjection", {
+	enumerable: true,
+	get: function() {
+		return isProjection;
+	}
+});
+Object.defineProperty(exports, "keyedAbsent", {
+	enumerable: true,
+	get: function() {
+		return keyedAbsent;
+	}
+});
+Object.defineProperty(exports, "mapRead", {
+	enumerable: true,
+	get: function() {
+		return mapRead;
+	}
+});
+Object.defineProperty(exports, "outputKind", {
+	enumerable: true,
+	get: function() {
+		return outputKind;
+	}
+});
+Object.defineProperty(exports, "ownProjections", {
+	enumerable: true,
+	get: function() {
+		return ownProjections;
+	}
+});
+Object.defineProperty(exports, "producerOf", {
+	enumerable: true,
+	get: function() {
+		return producerOf;
+	}
+});
+Object.defineProperty(exports, "profile", {
+	enumerable: true,
+	get: function() {
+		return profile;
+	}
+});
+Object.defineProperty(exports, "projectionRef", {
+	enumerable: true,
+	get: function() {
+		return projectionRef;
+	}
+});
+Object.defineProperty(exports, "snapshotCollectionView", {
+	enumerable: true,
+	get: function() {
+		return snapshotCollectionView;
+	}
+});
+Object.defineProperty(exports, "snapshotDependencyValue", {
+	enumerable: true,
+	get: function() {
+		return snapshotDependencyValue;
+	}
+});
+
+//# sourceMappingURL=transform-DUleAsG0.cjs.map