doxum 0.1.19 → 0.1.21

package/dist/advanced-COFJtWMT.js

@@ -0,0 +1,1188 @@
+import { B as profile } from "./issue-W0hT8u8D.js";
+import { f as checkKey, t as accessOf } from "./access-BeSV5ve-.js";
+//#region core/src/schema.ts
+const collectionEntryNode = (node) => node.kind === "map" || node.kind === "table" || node.kind === "list" ? node.value : void 0;
+const node = (value) => Object.freeze(value);
+const field = (validator) => node({
+	kind: "field",
+	...validator ? { validator } : {}
+});
+const optional = (value) => {
+	if (![
+		"field",
+		"variant",
+		"map",
+		"list",
+		"tree"
+	].includes(value.kind)) throw new TypeError("Only field, variant, map, list and tree nodes support optional presence.");
+	return node({
+		...value,
+		optional: true
+	});
+};
+const object = (shape) => node({
+	kind: "object",
+	shape: Object.freeze({ ...shape })
+});
+const variant = (tag, variants) => node({
+	kind: "variant",
+	tag,
+	variants: Object.freeze({ ...variants })
+});
+const table = (value, options) => node({
+	kind: "table",
+	value,
+	...options
+});
+const map = (value, options) => node({
+	kind: "map",
+	value,
+	...options
+});
+const list = (value, config) => node({
+	kind: "list",
+	keyOf: config.keyOf,
+	value
+});
+const tree = (value) => node({
+	kind: "tree",
+	value
+});
+const paths = /* @__PURE__ */ new WeakMap();
+const pathProxy = (nodes, address, owner) => {
+	const proxy = new Proxy({}, { get: (_target, property) => {
+		if (typeof property !== "string") return void 0;
+		if (nodes.every((node) => collectionEntryNode(node) !== void 0) && property === "item") return (id) => {
+			if (typeof id !== "string") throw new TypeError("Collection keys must be strings.");
+			for (const node of nodes) if (node.kind === "table" || node.kind === "map") {
+				const invalid = checkKey(node.key, id, [...address, id]);
+				if (invalid) throw new TypeError(invalid.message);
+			}
+			return pathProxy(nodes.map((node) => collectionEntryNode(node)), [...address, id], owner);
+		};
+		const children = nodes.flatMap((node) => {
+			if (node.kind === "object") return Object.hasOwn(node.shape, property) ? [node.shape[property]] : [];
+			if (node.kind !== "variant") return [];
+			if (property === node.tag) return [field()];
+			return Object.values(node.variants).flatMap((branch) => Object.hasOwn(branch.shape, property) ? [branch.shape[property]] : []);
+		});
+		if (!children.length) throw new TypeError(`Invalid schema path segment: ${property}`);
+		return pathProxy(children, [...address, property], owner);
+	} });
+	paths.set(proxy, {
+		nodes,
+		address,
+		owner
+	});
+	return proxy;
+};
+const compilePath = (owner, kind, pick) => {
+	const scope = {};
+	const value = pick(pathProxy([owner], [], scope));
+	const selected = typeof value === "object" && value !== null ? paths.get(value) : void 0;
+	if (!selected || selected.owner !== scope) throw new TypeError("Selector must return a path from its callback.");
+	const collection = selected.nodes.every((node) => collectionEntryNode(node) !== void 0);
+	if (kind === "collection" && !collection) throw new TypeError("Collection selectors require a map, table or list path.");
+	return Object.freeze({
+		kind: kind === "auto" ? collection ? "collection" : "value" : kind,
+		schema: owner,
+		address: Object.freeze([...selected.address])
+	});
+};
+//#endregion
+//#region core/src/projection/contract.ts
+var ProjectionError = class extends Error {
+	constructor(phase, identity, revisions, cause) {
+		super(`Projection ${phase} failed: ${identity}`, { cause });
+		this.phase = phase;
+		this.identity = identity;
+		this.revisions = revisions;
+		this.name = "ProjectionError";
+	}
+};
+var ProjectionDisposedError = class extends Error {
+	constructor() {
+		super("Projection has been disposed.");
+		this.name = "ProjectionDisposedError";
+	}
+};
+//#endregion
+//#region core/src/projection/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 cleanups = /* @__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 revisionsOf = (producer) => producer.kind === "processor" ? producer.dependencies.map((output) => output.revision()) : producer.outputs.map((output) => output.revision());
+	const errorFor = (producer, cause, kind = producer.kind === "source" ? "source" : "processor") => new ProjectionError(kind, producer.name, revisionsOf(producer), 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.consumers.forEach(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);
+						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);
+							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.consumers.forEach(enqueue);
+				});
+				else {
+					if (changedOutputs.length) {
+						processor.publish();
+						changedOutputs.forEach((output) => emissions.add(output));
+					}
+					(recovered ? processor.outputs : changedOutputs).forEach((output) => output.consumers.forEach(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) => {
+				try {
+					listener();
+				} 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 = (optionsOrCallback, maybeCallback) => {
+		assertIdle();
+		const options = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
+		const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : maybeCallback;
+		if (!callback) throw new TypeError("Projection batch requires a callback.");
+		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.consumers.size)) throw new Error("Projection producer is still used by another processor.");
+		producer.disposed = true;
+		if (producer.kind === "processor") {
+			producer.dependencies.forEach((output) => output.consumers.delete(producer));
+			processors.delete(producer);
+			queued.delete(producer);
+			completed.delete(producer);
+		} else {
+			sources.delete(producer);
+			pendingSources.delete(producer);
+		}
+		producer.release();
+		producer.clear();
+		producer.outputs.forEach((output) => emissions.delete(output));
+	};
+	return {
+		assertActive,
+		assertIdle,
+		capture,
+		settle,
+		flush,
+		run,
+		guards,
+		cleanups,
+		get active() {
+			return !disposed;
+		},
+		addSource(source) {
+			assertIdle();
+			sources.add(source);
+		},
+		addProcessor(processor) {
+			assertIdle();
+			processors.add(processor);
+			processor.dependencies.forEach((output) => output.consumers.add(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 = [];
+			cleanups.forEach((cleanup) => {
+				try {
+					cleanup();
+				} catch (error) {
+					failures.push(error);
+				}
+			});
+			cleanups.clear();
+			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/collection-output.ts
+const height = (node) => node?.height ?? 0;
+const makeTreeNode = (key, value, left, right) => Object.freeze({
+	key,
+	value,
+	left,
+	right,
+	height: Math.max(height(left), height(right)) + 1
+});
+const rotateLeft = (node) => {
+	const right = node.right;
+	return makeTreeNode(right.key, right.value, makeTreeNode(node.key, node.value, node.left, right.left), right.right);
+};
+const rotateRight = (node) => {
+	const left = node.left;
+	return makeTreeNode(left.key, left.value, left.left, makeTreeNode(node.key, node.value, left.right, node.right));
+};
+const rebalance = (node) => {
+	const balance = height(node.left) - height(node.right);
+	if (balance > 1) {
+		if (height(node.left.left) < height(node.left.right)) return rotateRight(makeTreeNode(node.key, node.value, rotateLeft(node.left), node.right));
+		return rotateRight(node);
+	}
+	if (balance < -1) {
+		if (height(node.right.right) < height(node.right.left)) return rotateLeft(makeTreeNode(node.key, node.value, node.left, rotateRight(node.right)));
+		return rotateLeft(node);
+	}
+	return node;
+};
+const treeSet = (node, key, value) => {
+	if (!node) return makeTreeNode(key, value);
+	if (key === node.key) return makeTreeNode(key, value, node.left, node.right);
+	if (key < node.key) return rebalance(makeTreeNode(node.key, node.value, treeSet(node.left, key, value), node.right));
+	return rebalance(makeTreeNode(node.key, node.value, node.left, treeSet(node.right, key, value)));
+};
+const treeMin = (node) => node.left ? treeMin(node.left) : node;
+const treeRemove = (node, key) => {
+	if (!node) return void 0;
+	if (key < node.key) return rebalance(makeTreeNode(node.key, node.value, treeRemove(node.left, key), node.right));
+	if (key > node.key) return rebalance(makeTreeNode(node.key, node.value, node.left, treeRemove(node.right, key)));
+	if (!node.left) return node.right;
+	if (!node.right) return node.left;
+	const next = treeMin(node.right);
+	return rebalance(makeTreeNode(next.key, next.value, node.left, treeRemove(node.right, next.key)));
+};
+const treeGet = (node, key) => {
+	let current = node;
+	while (current) {
+		if (key === current.key) return current.value;
+		current = key < current.key ? current.left : current.right;
+	}
+};
+const treeHas = (node, key) => {
+	let current = node;
+	while (current) {
+		if (key === current.key) return true;
+		current = key < current.key ? current.left : current.right;
+	}
+	return false;
+};
+const treeFromSorted = (entries, start = 0, end = entries.length) => {
+	if (start >= end) return void 0;
+	const middle = start + end >> 1;
+	const [key, value] = entries[middle];
+	return makeTreeNode(key, value, treeFromSorted(entries, start, middle), treeFromSorted(entries, middle + 1, end));
+};
+/** Owns staged keyed intent, exact transitions and the persistent published lookup. */
+const createCollectionOutput = () => {
+	const values = /* @__PURE__ */ new Map();
+	let ids = Object.freeze([]);
+	let staged = /* @__PURE__ */ new Map();
+	let nextIds = ids;
+	let change;
+	let initialized = false;
+	let reset = false;
+	let revision = 0;
+	let publishedRoot;
+	let explicitOrder;
+	let cleared = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const hasNext = (key) => staged.has(key) ? staged.get(key).present : !cleared && values.has(key);
+	const getNext = (key) => {
+		const entry = staged.get(key);
+		return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : values.get(key);
+	};
+	const deriveIds = () => {
+		const result = cleared ? [] : ids.filter(hasNext);
+		for (const [key, entry] of staged) if (entry.present && (cleared || !values.has(key))) result.push(key);
+		return result;
+	};
+	const begin = (active, initialize) => {
+		staged = /* @__PURE__ */ new Map();
+		nextIds = ids;
+		change = void 0;
+		explicitOrder = void 0;
+		cleared = initialize;
+		reset = initialize;
+		const read = (next) => ({
+			get: (key) => {
+				assertScope(active);
+				return next ? getNext(key) : values.get(key);
+			},
+			has: (key) => {
+				assertScope(active);
+				return next ? hasNext(key) : values.has(key);
+			},
+			ids: () => {
+				assertScope(active);
+				return next ? Object.freeze(explicitOrder ? [...explicitOrder] : [...deriveIds()]) : ids;
+			}
+		});
+		return {
+			previous: read(false),
+			next: read(true),
+			output: {
+				set: (key, value) => {
+					assertScope(active);
+					if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+					staged.set(key, {
+						present: true,
+						value
+					});
+				},
+				remove: (key) => {
+					assertScope(active);
+					staged.set(key, { present: false });
+				},
+				order: (order) => {
+					assertScope(active);
+					explicitOrder = Object.freeze([...order]);
+				}
+			}
+		};
+	};
+	const seal = (nextReset, isEqual) => {
+		if (cleared) {
+			for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
+		}
+		profile.projection("touchedKeys", staged.size);
+		const added = /* @__PURE__ */ new Set();
+		const removed = /* @__PURE__ */ new Set();
+		const updated = /* @__PURE__ */ new Set();
+		for (const [key, entry] of staged) {
+			const existed = values.has(key);
+			if (entry.present) {
+				if (!existed) added.add(key);
+				else if (!isEqual(values.get(key), entry.value)) updated.add(key);
+				else if (!nextReset) staged.delete(key);
+			} else if (existed) removed.add(key);
+			else staged.delete(key);
+		}
+		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 !== values.size + added.size - removed.size || order.some((key) => !hasNext(key))) throw new TypeError("Projection order must contain every key exactly once.");
+			nextIds = ids.length === order.length && ids.every((key, index) => key === order[index]) ? ids : Object.freeze([...order]);
+		} else nextIds = ids;
+		const changedKeys = new Set([
+			...added,
+			...removed,
+			...updated
+		]);
+		profile.projection("changedKeys", changedKeys.size);
+		const addedEntries = [];
+		const updatedEntries = [];
+		const removedEntries = [];
+		for (const key of changedKeys) {
+			const beforePresent = values.has(key);
+			const afterPresent = hasNext(key);
+			if (beforePresent === afterPresent) {
+				if (!beforePresent || isEqual(values.get(key), getNext(key))) continue;
+			}
+			if (!beforePresent) addedEntries.push({
+				key,
+				after: getNext(key)
+			});
+			else if (!afterPresent) removedEntries.push({
+				key,
+				before: values.get(key)
+			});
+			else updatedEntries.push({
+				key,
+				before: values.get(key),
+				after: getNext(key)
+			});
+		}
+		const orderChanged = nextIds !== ids;
+		if (nextReset) change = Object.freeze({ kind: "reset" });
+		else if (addedEntries.length || updatedEntries.length || removedEntries.length || orderChanged) {
+			let commonOrderChanged = false;
+			if (orderChanged) {
+				const before = ids.filter((key) => !removed.has(key));
+				const after = nextIds.filter((key) => !added.has(key));
+				commonOrderChanged = before.some((key, index) => after[index] !== key);
+			}
+			change = Object.freeze({
+				kind: "incremental",
+				added: Object.freeze(addedEntries),
+				updated: Object.freeze(updatedEntries),
+				removed: Object.freeze(removedEntries),
+				...commonOrderChanged ? { order: Object.freeze({
+					before: Object.freeze([...ids]),
+					after: Object.freeze([...nextIds])
+				}) } : {}
+			});
+		}
+		reset = nextReset;
+		return change !== void 0;
+	};
+	const context = (active, cause) => Object.freeze({
+		kind: "collection",
+		read: {
+			get: (key) => {
+				assertScope(active);
+				return getNext(key);
+			},
+			has: (key) => {
+				assertScope(active);
+				return hasNext(key);
+			},
+			ids: () => {
+				assertScope(active);
+				return nextIds;
+			}
+		},
+		change,
+		revision,
+		reset,
+		cause
+	});
+	const current = (check) => {
+		const root = publishedRoot;
+		const publishedIds = ids;
+		return Object.freeze({
+			get: (key) => {
+				check();
+				return treeGet(root, key);
+			},
+			has: (key) => {
+				check();
+				return treeHas(root, key);
+			},
+			ids: () => {
+				check();
+				return publishedIds;
+			}
+		});
+	};
+	return {
+		begin,
+		seal,
+		context,
+		current,
+		revision: () => revision,
+		reset: () => reset,
+		publish: () => {
+			if (change) if (change.kind === "reset") {
+				const entries = [];
+				for (const [key, entry] of staged) if (entry.present) entries.push([key, entry.value]);
+				entries.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+				publishedRoot = treeFromSorted(entries);
+			} else for (const [key, entry] of staged) publishedRoot = entry.present ? treeSet(publishedRoot, key, entry.value) : treeRemove(publishedRoot, key);
+			for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
+			else values.delete(key);
+			if (change && initialized) revision++;
+			ids = nextIds;
+			initialized = true;
+		},
+		emit: (call) => {
+			const resetEvent = Object.freeze({ kind: "reset" });
+			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
+		},
+		clear: () => {
+			staged.clear();
+			nextIds = ids;
+			change = void 0;
+			reset = false;
+			explicitOrder = void 0;
+			cleared = false;
+		},
+		release: () => {
+			values.clear();
+			staged.clear();
+			publishedRoot = void 0;
+			listeners.clear();
+			ids = nextIds = Object.freeze([]);
+			change = void 0;
+			initialized = false;
+			revision = 0;
+			reset = false;
+			explicitOrder = void 0;
+			cleared = false;
+		},
+		subscribe: (listener) => listeners.add(listener),
+		unsubscribe: (listener) => listeners.delete(listener)
+	};
+};
+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));
+};
+/**
+* The one source-to-CollectionChange kernel. Candidate keys only narrow value work;
+* exact membership/value/order semantics remain owned here.
+*/
+const stageCollectionRead = (state, read, active, options) => {
+	const evaluation = state.begin(active, options.reset);
+	if (options.reset) {
+		const ids = read.ids();
+		profile.collectionView.idsScanned(ids.length);
+		for (const key of ids) {
+			profile.collectionView.mapped();
+			evaluation.output.set(key, read.get(key));
+		}
+		evaluation.output.order(ids);
+	} else {
+		const previous = state.current(() => void 0);
+		const keys = options.candidates ? [...new Set(options.candidates)] : [...new Set([...previous.ids(), ...read.ids()])];
+		if (!options.candidates) profile.collectionView.idsScanned(keys.length);
+		for (const key of keys) if (read.has(key)) {
+			profile.collectionView.mapped();
+			evaluation.output.set(key, read.get(key));
+		} else evaluation.output.remove(key);
+		if (options.orderMayChange || !options.candidates) {
+			const ids = read.ids();
+			if (options.candidates) profile.collectionView.idsScanned(ids.length);
+			evaluation.output.order(ids);
+		}
+	}
+	return state.seal(options.reset, options.isEqual ?? Object.is);
+};
+/** Exact net transition between two published map-like snapshots. */
+const collectionChangeBetween = (previous, current, isEqual = Object.is) => {
+	const added = [];
+	const removed = [];
+	const updated = [];
+	for (const [key, before] of previous) if (!current.has(key)) removed.push({
+		key,
+		before
+	});
+	else {
+		const after = current.get(key);
+		if (!isEqual(before, after)) updated.push({
+			key,
+			before,
+			after
+		});
+	}
+	for (const [key, after] of current) if (!previous.has(key)) added.push({
+		key,
+		after
+	});
+	const beforeKeys = new Set(previous.keys());
+	const afterKeys = new Set(current.keys());
+	const beforeCommon = [...previous.keys()].filter((key) => afterKeys.has(key));
+	const afterCommon = [...current.keys()].filter((key) => beforeKeys.has(key));
+	const orderChanged = beforeCommon.some((key, index) => afterCommon[index] !== key);
+	if (!added.length && !removed.length && !updated.length && !orderChanged) return void 0;
+	return Object.freeze({
+		kind: "incremental",
+		added: Object.freeze(added),
+		updated: Object.freeze(updated),
+		removed: Object.freeze(removed),
+		...orderChanged ? { order: Object.freeze({
+			before: Object.freeze([...previous.keys()]),
+			after: Object.freeze([...current.keys()])
+		}) } : {}
+	});
+};
+//#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;
+const isProjection = (value) => value !== null && typeof value === "object" && projections.has(value);
+const ownProjection = (projection, owner) => {
+	const producer = producerOf(projection);
+	if (producer.owner !== void 0 && producer.owner !== owner) throw new TypeError("Projection producer already belongs to another scope.");
+	if (producer.kind === "processor") 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.");
+	}
+	producer.owner = owner;
+	return projection;
+};
+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);
+};
+const sourceValue = (source) => source.kind === "value" ? source.value : snapshotCollectionView(source.read);
+const valueInput = (initial, equality = Object.is) => defineSource({
+	kind: "value-input",
+	initial,
+	equality
+}, {
+	kind: "value",
+	equality
+});
+const collectionInput = (initial = /* @__PURE__ */ new Map()) => {
+	const entries = /* @__PURE__ */ new Map();
+	for (const [key, value] of initial) {
+		if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+		entries.set(key, value);
+	}
+	return defineSource({
+		kind: "collection-input",
+		initial: entries
+	}, {
+		kind: "collection",
+		equality: Object.is
+	});
+};
+const input = Object.assign(valueInput, { collection: collectionInput });
+function observe(source, selector) {
+	if (isExternalSource(source)) return source.kind === "collection" ? defineSource({
+		kind: "external-collection",
+		source
+	}, {
+		kind: "collection",
+		equality: Object.is
+	}) : defineSource({
+		kind: "external-value",
+		source,
+		equality: Object.is
+	}, {
+		kind: "value",
+		equality: Object.is
+	});
+	if ("current" in source && typeof source.current === "function") return defineSource({
+		kind: "readable",
+		readable: source,
+		equality: Object.is
+	}, {
+		kind: "value",
+		equality: Object.is
+	});
+	const document = source;
+	if (!selector) return defineSource({
+		kind: "document-value",
+		document
+	}, {
+		kind: "value",
+		equality: Object.is
+	});
+	const selected = compilePath(accessOf(document).schema, "auto", selector);
+	return selected.kind === "collection" ? defineSource({
+		kind: "document-collection",
+		document,
+		selector: selected
+	}, {
+		kind: "collection",
+		equality: Object.is
+	}) : defineSource({
+		kind: "document-value",
+		document,
+		selector: selected
+	}, {
+		kind: "value",
+		equality: Object.is
+	});
+}
+const isExternalSource = (source) => {
+	if (!source || typeof source !== "object") return false;
+	const candidate = source;
+	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
+};
+function derive(dependencies, compute, equality = Object.is) {
+	const [projection] = defineProcessor({
+		dependencies,
+		outputs: [{
+			kind: "value",
+			equality
+		}],
+		create: () => ({ evaluate: (evaluation) => {
+			const output = evaluation.outputs[0];
+			if (output.kind !== "value") throw new Error("derive requires a value output.");
+			const next = compute(...evaluation.sources.map(sourceValue));
+			assertSynchronous(next);
+			output.output.set(next);
+		} })
+	});
+	return projection;
+}
+//#endregion
+//#region core/src/projection/advanced.ts
+const resetCollectionChange = Object.freeze({ kind: "reset" });
+const isRebuild = (value) => value !== null && typeof value === "object" && value.kind === "rebuild";
+const publicValue = (source) => source.kind === "value" ? source.value : collectionView(source.read);
+const publicInputs = (sources, reset) => ({
+	values: Object.freeze(sources.map(publicValue)),
+	changes: Object.freeze(sources.map((source) => source.kind === "collection" ? reset ? resetCollectionChange : source.change : void 0))
+});
+const validateDependencies = (dependencies) => {
+	if (!Array.isArray(dependencies)) throw new TypeError("Incremental dependencies must be projections.");
+	dependencies.forEach(projectionRef);
+};
+function createIncrementalValue(dependencies, processor) {
+	validateDependencies(dependencies);
+	const [projection] = defineProcessor({
+		dependencies,
+		outputs: [{
+			kind: "value",
+			equality: Object.is
+		}],
+		create: () => {
+			const state = Object.create(null);
+			return { evaluate: (evaluation) => {
+				const output = evaluation.outputs[0];
+				if (output.kind !== "value") throw new Error("Incremental value output is invalid.");
+				const publicInput = publicInputs(evaluation.sources, evaluation.reset);
+				const result = processor({
+					sources: publicInput.values,
+					changes: publicInput.changes,
+					previous: output.previous,
+					reset: evaluation.reset,
+					cause: evaluation.cause,
+					state
+				});
+				assertSynchronous(result);
+				if (isRebuild(result)) return result;
+				output.output.set(result);
+			} };
+		}
+	});
+	return projection;
+}
+function createIncrementalCollection(dependencies, processor) {
+	validateDependencies(dependencies);
+	const [projection] = defineProcessor({
+		dependencies,
+		outputs: [{
+			kind: "collection",
+			equality: Object.is
+		}],
+		create: () => {
+			const state = Object.create(null);
+			return { evaluate: (evaluation) => {
+				const output = evaluation.outputs[0];
+				if (output.kind !== "collection") throw new Error("Incremental collection output is invalid.");
+				const publicInput = publicInputs(evaluation.sources, evaluation.reset);
+				const result = processor({
+					sources: publicInput.values,
+					changes: publicInput.changes,
+					previous: output.previous,
+					next: output.next,
+					reset: evaluation.reset,
+					cause: evaluation.cause,
+					state,
+					output: output.output
+				});
+				assertSynchronous(result);
+				return isRebuild(result) ? result : void 0;
+			} };
+		}
+	});
+	return projection;
+}
+const groupOutputMetadata = /* @__PURE__ */ new WeakMap();
+const isPlainGroupNamespace = (value) => value !== null && typeof value === "object" && !groupOutputMetadata.has(value) && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+const compileGroupShape = (value, path, declaredOutputs, used, outputs) => {
+	if (value !== null && typeof value === "object") {
+		const metadata = groupOutputMetadata.get(value);
+		if (metadata) {
+			if (!declaredOutputs.has(value)) throw new TypeError("Incremental group outputs must be declared by this group.");
+			if (used.has(value)) throw new TypeError("An incremental group output cannot be reused.");
+			used.add(value);
+			const index = outputs.length;
+			outputs.push({
+				kind: metadata.kind,
+				equality: metadata.equality,
+				path: Object.freeze([...path])
+			});
+			return index;
+		}
+	}
+	if (!isPlainGroupNamespace(value)) throw new TypeError("Incremental group outputs must be a static object tree.");
+	for (const key of Reflect.ownKeys(value)) {
+		if (typeof key !== "string") throw new TypeError("Incremental group output names must be strings.");
+		if (!Object.prototype.propertyIsEnumerable.call(value, key)) throw new TypeError("Incremental group namespaces must contain enumerable properties.");
+	}
+	const keys = Object.keys(value);
+	if (!keys.length) throw new TypeError("Incremental group namespaces cannot be empty.");
+	const result = Object.create(null);
+	for (const key of keys) {
+		if (key === "__proto__" || key === "prototype" || key === "constructor") throw new TypeError(`Invalid incremental group output name: ${key}`);
+		const descriptor = Object.getOwnPropertyDescriptor(value, key);
+		if (!descriptor || !("value" in descriptor)) throw new TypeError("Incremental group namespaces cannot contain accessors.");
+		result[key] = compileGroupShape(descriptor.value, [...path, key], declaredOutputs, used, outputs);
+	}
+	return Object.freeze(result);
+};
+const hydrateGroupShape = (shape, values) => {
+	if (typeof shape === "number") return values[shape];
+	const result = {};
+	for (const [key, child] of Object.entries(shape)) result[key] = hydrateGroupShape(child, values);
+	return Object.freeze(result);
+};
+const hydrateGroupReads = (shape, outputs, next) => {
+	if (typeof shape === "number") {
+		const output = outputs[shape];
+		return next && output.kind === "value" ? output.next() : next ? output.next : output.previous;
+	}
+	const result = {};
+	for (const [key, child] of Object.entries(shape)) if (typeof child === "number" && next && outputs[child].kind === "value") Object.defineProperty(result, key, {
+		enumerable: true,
+		configurable: false,
+		get: () => outputs[child].next()
+	});
+	else result[key] = hydrateGroupReads(child, outputs, next);
+	return Object.freeze(result);
+};
+function createIncrementalGroup(dependencies, defineOutputs, processor) {
+	validateDependencies(dependencies);
+	if (typeof defineOutputs !== "function") throw new TypeError("Incremental group outputs must be declared by a callback.");
+	if (typeof processor !== "function") throw new TypeError("Incremental group processor must be a function.");
+	let active = true;
+	const declaredOutputs = /* @__PURE__ */ new Set();
+	const declared = defineOutputs({
+		collection: (equality = Object.is) => {
+			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
+			const descriptor = Object.freeze({});
+			groupOutputMetadata.set(descriptor, {
+				kind: "collection",
+				equality
+			});
+			declaredOutputs.add(descriptor);
+			return descriptor;
+		},
+		value: (equality = Object.is) => {
+			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
+			const descriptor = Object.freeze({});
+			groupOutputMetadata.set(descriptor, {
+				kind: "value",
+				equality
+			});
+			declaredOutputs.add(descriptor);
+			return descriptor;
+		}
+	});
+	assertSynchronous(declared);
+	active = false;
+	const outputs = [];
+	const used = /* @__PURE__ */ new Set();
+	const shape = compileGroupShape(declared, [], declaredOutputs, used, outputs);
+	if (typeof shape === "number") throw new TypeError("Incremental group declarations must return an output namespace.");
+	if (used.size === 0 || used.size !== declaredOutputs.size) throw new TypeError("Every incremental group output must be returned by the declaration.");
+	return hydrateGroupShape(shape, defineProcessor({
+		dependencies,
+		outputs,
+		create: () => {
+			const state = Object.create(null);
+			return { evaluate: (evaluation) => {
+				const publicInput = publicInputs(evaluation.sources, evaluation.reset);
+				const result = processor({
+					sources: publicInput.values,
+					changes: publicInput.changes,
+					previous: hydrateGroupReads(shape, evaluation.outputs, false),
+					next: hydrateGroupReads(shape, evaluation.outputs, true),
+					outputs: hydrateGroupShape(shape, evaluation.outputs.map((output) => output.output)),
+					reset: evaluation.reset,
+					cause: evaluation.cause,
+					state
+				});
+				assertSynchronous(result);
+				return isRebuild(result) ? result : void 0;
+			} };
+		},
+		name: `processor-group:${outputs.map((output) => output.path?.join(".") ?? "").join(",")}`
+	}));
+}
+const incremental = Object.assign(createIncrementalValue, {
+	collection: createIncrementalCollection,
+	group: createIncrementalGroup
+});
+//#endregion
+export { list as C, table as D, optional as E, tree as O, field as S, object as T, createScheduler as _, observe as a, collectionEntryNode as b, projectionRef as c, createCollectionOutput as d, mapRead as f, assertSynchronous as g, assertScope as h, isProjection as i, variant as k, collectionChangeBetween as l, stageCollectionRead as m, derive as n, ownProjection as o, snapshotCollectionView as p, input as r, producerOf as s, incremental as t, collectionView as u, ProjectionDisposedError as v, map as w, compilePath as x, ProjectionError as y };
+
+//# sourceMappingURL=advanced-COFJtWMT.js.map