doxum 0.1.13 → 0.1.15

package/dist/store-CtgvCVFg.js

@@ -1,2222 +0,0 @@
-import { L as profile, f as read, i as AddressIndex, o as contains } from "./issue-DVaGQGeP.js";
-import { d as createAccess, h as checkKey, o as definitionOf, p as snapshot, u as collectionAccess } from "./definition-DXrKMVs7.js";
-//#region core/src/schema.ts
-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) => node.kind === "table" || node.kind === "map") && 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) => node.value), [...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.");
-	if (kind === "collection" && !selected.nodes.every((node) => node.kind === "table" || node.kind === "map")) throw new TypeError("Collection selectors require a table or map path.");
-	return Object.freeze({
-		kind,
-		schema: owner,
-		address: Object.freeze([...selected.address])
-	});
-};
-//#endregion
-//#region core/src/impact-target.ts
-const address = (target) => "at" in target ? target.at : target.address;
-const id = (target) => target.kind === "collection" && "id" in target ? target.id : void 0;
-const belongs = (target, schema) => !("schema" in target) || target.schema === schema;
-const same = (left, right) => {
-	if (left.kind !== right.kind) return false;
-	if ("schema" in left && "schema" in right && left.schema !== right.schema) return false;
-	const leftAddress = address(left);
-	const rightAddress = address(right);
-	if (leftAddress.length !== rightAddress.length) return false;
-	for (let index = 0; index < leftAddress.length; index += 1) if (leftAddress[index] !== rightAddress[index]) return false;
-	return left.kind !== "collection" || id(left) === id(right);
-};
-const indexedAddress = (target) => {
-	const key = id(target);
-	return key === void 0 ? address(target) : [...address(target), key];
-};
-const affected = (target, values, orders) => {
-	const at = indexedAddress(target);
-	return id(target) !== void 0 ? values.hasAncestor(at) : values.overlaps(at) || orders.hasDescendant(at);
-};
-/** Targets are classified once; commit matching never builds a reverse impact index. */
-var SubscriptionIndex = class {
-	ordinary = new AddressIndex();
-	membership = new AddressIndex();
-	constructor(schema) {
-		this.schema = schema;
-	}
-	add(target, value) {
-		if (belongs(target, this.schema)) (id(target) === void 0 ? this.ordinary : this.membership).add(indexedAddress(target), value);
-	}
-	delete(target, value) {
-		if (belongs(target, this.schema)) (id(target) === void 0 ? this.ordinary : this.membership).delete(indexedAddress(target), value);
-	}
-	collect(changes, visit) {
-		const values = this.ordinary.query(visit);
-		const members = this.membership.query(visit, "descendants");
-		const orders = this.ordinary.query(visit, "ancestors");
-		for (const change of changes.changes) if (change.kind === "reset") {
-			values([]);
-			members([]);
-		} else if (change.kind === "members") {
-			values(change.at, change.members);
-			members(change.at, change.members);
-			if (change.order) orders(change.at);
-		} else {
-			values(change.at);
-			members(change.at);
-		}
-	}
-	clear() {
-		this.ordinary.clear();
-		this.membership.clear();
-	}
-};
-//#endregion
-//#region core/src/impact.ts
-const queries = /* @__PURE__ */ new WeakMap();
-const affectsTarget = (impact, value) => queries.get(impact).affects(value);
-const collectionImpact = (impact, selector) => queries.get(impact).collection(selector);
-const createImpact = (schema, changes) => {
-	const reset = changes.changes.some((change) => change.kind === "reset");
-	let values;
-	let orders;
-	const index = () => {
-		if (!values) {
-			profile.impact.index();
-			values = new AddressIndex();
-			orders = new AddressIndex();
-			for (const change of changes.changes) if (change.kind === "members") {
-				for (const member of change.members) values.add(change.at, true, member.key);
-				if (change.order) orders.add(change.at, true);
-			} else if (change.kind === "tree") values.add(change.at, true);
-		}
-		return values;
-	};
-	const cache = /* @__PURE__ */ new Map();
-	const implementation = {
-		affects(value) {
-			profile.impact.affects();
-			if (!belongs(value, schema)) return false;
-			if (reset) return true;
-			return affected(value, index(), orders);
-		},
-		collection(selector) {
-			if (selector.schema !== schema) throw new TypeError("Collection belongs to another root model.");
-			const key = JSON.stringify(selector.address), cached = cache.get(key);
-			if (cached) return cached;
-			if (reset) {
-				const result = { kind: "reset" };
-				cache.set(key, result);
-				return result;
-			}
-			const at = selector.address;
-			const added = /* @__PURE__ */ new Set(), removed = /* @__PURE__ */ new Set(), updated = /* @__PURE__ */ new Set();
-			let orderChanged = false;
-			for (const change of changes.changes) {
-				if (change.kind === "reset") continue;
-				if (change.kind === "members") {
-					if (change.at.length < at.length && contains(change.at, at)) {
-						if (change.members.some((member) => member.key === at[change.at.length])) {
-							const result = { kind: "reset" };
-							cache.set(key, result);
-							return result;
-						}
-					} else if (contains(at, change.at)) if (change.at.length === at.length) {
-						if (change.order) {
-							const positions = new Map(change.order.after.map((id, i) => [id, i]));
-							let previous = -1;
-							for (const id of change.order.before) {
-								const position = positions.get(id);
-								if (position === void 0) continue;
-								if (position < previous) orderChanged = true;
-								previous = position;
-							}
-						}
-						for (const member of change.members) if (member.kind === "added") added.add(member.key);
-						else if (member.kind === "removed") removed.add(member.key);
-						else updated.add(member.key);
-					} else updated.add(change.at[at.length]);
-					continue;
-				}
-				if (change.kind === "tree" && contains(change.at, at)) {
-					const result = { kind: "reset" };
-					cache.set(key, result);
-					return result;
-				}
-				if (!contains(at, change.at)) continue;
-				if (change.at.length === at.length) continue;
-				const id = change.at[at.length];
-				updated.add(id);
-			}
-			added.forEach((id) => updated.delete(id));
-			removed.forEach((id) => updated.delete(id));
-			const result = {
-				kind: "incremental",
-				added,
-				removed,
-				updated,
-				orderChanged
-			};
-			cache.set(key, result);
-			return result;
-		}
-	};
-	const impact = Object.freeze({
-		kind: reset ? "reset" : "incremental",
-		affects: (pick) => implementation.affects(compilePath(schema, "value", pick)),
-		collection: (pick) => implementation.collection(compilePath(schema, "collection", pick))
-	});
-	queries.set(impact, implementation);
-	return impact;
-};
-//#endregion
-//#region core/src/runtime/contract.ts
-var DocumentReentrancyError = class extends Error {
-	constructor() {
-		super("Document writes cannot be re-entered during an update or notification.");
-		this.name = "DocumentReentrancyError";
-	}
-};
-var DocumentDisposedError = class extends Error {
-	constructor() {
-		super("Doxum runtime has been disposed.");
-		this.name = "DocumentDisposedError";
-	}
-};
-var TransactionRejected = class extends Error {
-	issues;
-	constructor(input) {
-		super("Document update rejected.");
-		this.name = "TransactionRejected";
-		const issues = Array.isArray(input) ? input : [input];
-		this.issues = Object.freeze(issues.map((issue) => Object.freeze({
-			code: issue.code,
-			message: issue.message,
-			source: "application",
-			...issue.address === void 0 ? {} : { address: Object.freeze([...issue.address]) }
-		})));
-	}
-};
-//#endregion
-//#region core/src/runtime/access.ts
-const states = /* @__PURE__ */ new WeakMap();
-const bindRuntimeAccess = (runtime, state) => {
-	states.set(runtime, state);
-};
-const accessOf = (runtime) => {
-	const state = states.get(runtime);
-	if (!state) throw new Error("Unknown Doxum runtime.");
-	return state;
-};
-const readWith = (runtime, run, dependencies) => {
-	const state = accessOf(runtime);
-	if (state.disposed) throw new DocumentDisposedError();
-	state.projectionLocks = (state.projectionLocks ?? 0) + 1;
-	try {
-		return run(createAccess({
-			state,
-			dependencies
-		}));
-	} finally {
-		state.projectionLocks--;
-	}
-};
-//#endregion
-//#region core/src/runtime/notification.ts
-const notifications = /* @__PURE__ */ new WeakMap();
-const readableOwners = /* @__PURE__ */ new WeakMap();
-const bindDocumentReadable = (readable, runtime) => {
-	readableOwners.set(readable, runtime);
-};
-const documentReadableOwner = (readable) => readableOwners.get(readable);
-const createNotification = (runtime) => {
-	const notification = {
-		root: /* @__PURE__ */ new Set(),
-		filtered: /* @__PURE__ */ new Set(),
-		index: new SubscriptionIndex(runtime.schema),
-		cleanups: /* @__PURE__ */ new Set(),
-		processors: [],
-		candidates: /* @__PURE__ */ new Set(),
-		rootSnapshot: [],
-		notifying: false
-	};
-	notifications.set(runtime, notification);
-	return notification;
-};
-const notificationOf = (runtime) => {
-	const value = notifications.get(runtime);
-	if (!value) throw new Error("Unknown Doxum runtime.");
-	return value;
-};
-const shareNotification = (source, target) => {
-	notifications.set(target, notificationOf(source));
-};
-const attachProjection = (runtime, processor) => {
-	const notification = notificationOf(runtime);
-	const entry = {
-		processor,
-		active: true
-	};
-	notification.processors.push(entry);
-	return () => {
-		if (!entry.active) return;
-		entry.active = false;
-		if (!notification.notifying) {
-			const index = notification.processors.indexOf(entry);
-			if (index >= 0) notification.processors.splice(index, 1);
-		}
-	};
-};
-const subscribeRoot = (notification, listener) => {
-	const entry = {
-		listener,
-		active: true
-	};
-	notification.root.add(entry);
-	return () => {
-		entry.active = false;
-		if (!notification.notifying) notification.root.delete(entry);
-		else notification.cleanups.add(() => {
-			notification.root.delete(entry);
-		});
-	};
-};
-const subscribeTargets = (notification, targets, listener) => {
-	const entry = {
-		targets: Object.freeze(targets.slice()),
-		listener,
-		active: true
-	};
-	notification.filtered.add(entry);
-	entry.targets.forEach((value) => notification.index.add(value, entry));
-	const remove = () => {
-		notification.filtered.delete(entry);
-		entry.targets.forEach((value) => notification.index.delete(value, entry));
-	};
-	return () => {
-		if (!entry.active) return;
-		entry.active = false;
-		if (notification.notifying) notification.cleanups.add(remove);
-		else remove();
-	};
-};
-const notify = (notification, commit, afterSettle) => {
-	notification.notifying = true;
-	const errors = [];
-	const call = (listener) => {
-		try {
-			listener(commit);
-		} catch (error) {
-			errors.push(Object.freeze({
-				phase: "listener",
-				error
-			}));
-		}
-	};
-	try {
-		const processorCount = notification.processors.length;
-		for (let index = 0; index < processorCount; index += 1) {
-			const entry = notification.processors[index];
-			if (!entry?.active) continue;
-			try {
-				entry.processor.capture(commit);
-			} catch (error) {
-				errors.push(Object.freeze({
-					phase: "processor",
-					error
-				}));
-			}
-		}
-		for (let index = 0; index < processorCount; index += 1) {
-			const entry = notification.processors[index];
-			if (!entry?.active) continue;
-			try {
-				entry.processor.settle();
-			} catch (error) {
-				errors.push(Object.freeze({
-					phase: "processor",
-					error
-				}));
-			}
-		}
-		for (let index = 0; index < processorCount; index += 1) {
-			const entry = notification.processors[index];
-			if (!entry?.active) continue;
-			try {
-				errors.push(...entry.processor.flush());
-			} catch (error) {
-				errors.push(Object.freeze({
-					phase: "flush",
-					error
-				}));
-			}
-		}
-		if (afterSettle) errors.push(...afterSettle());
-		const candidates = notification.candidates;
-		candidates.clear();
-		if (notification.filtered.size) notification.index.collect(commit.changes, (entry) => candidates.add(entry));
-		candidates.forEach((entry) => {
-			if (entry.active) call(entry.listener);
-		});
-		const rootSnapshot = notification.rootSnapshot;
-		rootSnapshot.length = 0;
-		notification.root.forEach((entry) => rootSnapshot.push(entry));
-		for (const entry of rootSnapshot) if (entry.active) call(entry.listener);
-	} finally {
-		notification.notifying = false;
-		let writeIndex = 0;
-		for (const entry of notification.processors) if (entry.active) notification.processors[writeIndex++] = entry;
-		notification.processors.length = writeIndex;
-		notification.cleanups.forEach((cleanup) => cleanup());
-		notification.cleanups.clear();
-	}
-	return Object.freeze(errors);
-};
-const subscribeDependencies = (runtime, targets, listener) => subscribeTargets(notificationOf(runtime), targets, listener);
-const disposeNotification = (notification) => {
-	const attachments = notification.processors.slice();
-	notification.root.clear();
-	notification.filtered.clear();
-	notification.index.clear();
-	notification.cleanups.clear();
-	notification.processors.length = 0;
-	notification.candidates.clear();
-	notification.rootSnapshot.length = 0;
-	const errors = [];
-	attachments.forEach((entry) => {
-		if (!entry.active) return;
-		try {
-			entry.processor.dispose();
-		} catch (error) {
-			errors.push(error);
-		}
-	});
-	if (errors.length) throw new AggregateError(errors, "Projection disposal notification failed.");
-};
-//#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 projectionHandles = /* @__PURE__ */ new WeakSet();
-const createScheduler = (onError) => {
-	let disposed = false;
-	let depth = 0;
-	let batchSequence = 0;
-	let activeBatch;
-	let phase = "idle";
-	let sequence = 0;
-	const records = /* @__PURE__ */ new Map();
-	const nodes = /* @__PURE__ */ new Set();
-	const pending = /* @__PURE__ */ new Set();
-	const heap = [];
-	const queued = /* @__PURE__ */ new Set();
-	const completed = [];
-	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 = (node) => {
-		if (node.disposed || queued.has(node)) return;
-		queued.add(node);
-		profile.projection("scheduledNodes");
-		let i = heap.length;
-		heap.push(node);
-		while (i > 0) {
-			const p = i - 1 >> 1;
-			if (heap[p].order < node.order) break;
-			heap[i] = heap[p];
-			i = p;
-		}
-		heap[i] = node;
-	};
-	const pop = () => {
-		const first = heap[0];
-		const last = heap.pop();
-		if (heap.length) {
-			let i = 0;
-			while (i * 2 + 1 < heap.length) {
-				let c = i * 2 + 1;
-				if (c + 1 < heap.length && heap[c + 1].order < heap[c].order) c++;
-				if (last.order < heap[c].order) break;
-				heap[i] = heap[c];
-				i = c;
-			}
-			heap[i] = last;
-		}
-		return first;
-	};
-	const errorFor = (node, cause, kind = "processor") => new ProjectionError(kind, node.name, node.sources.map((source) => source.revision()), cause);
-	const capture = (source) => {
-		if (disposed) return;
-		if (phase !== "idle") {
-			source.fault = new ProjectionError("source", "reentrant source", [source.revision()], /* @__PURE__ */ new Error("Source changed while projection was running."));
-			errors.push(source.fault);
-			throw source.fault;
-		}
-		pending.add(source);
-		profile.projection("sourceEvents");
-		if (source.fault) errors.push(source.fault);
-	};
-	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
-		phase = "compute";
-		lock(true);
-		try {
-			pending.forEach((source) => source.consumers.forEach(enqueue));
-			while (heap.length) {
-				const node = pop();
-				if (node.disposed) continue;
-				const wasFaulted = node.fault !== void 0;
-				profile.projection("processedNodes");
-				let changed = false;
-				const blocked = node.sources.find((source) => source.fault || source.disposed);
-				if (blocked) node.fault = errorFor(node, blocked.fault ?? new ProjectionDisposedError(), "blocked");
-				else {
-					const build = node.forced || wasFaulted || node.sources.some((source) => source.reset());
-					try {
-						changed = node.evaluate(build);
-						const failure = node.sources.find((source) => source.fault)?.fault;
-						if (failure) throw failure;
-						node.fault = void 0;
-					} catch (cause) {
-						const error = errorFor(node, cause);
-						errors.push(error);
-						node.fault = error;
-						if (!build) try {
-							changed = node.evaluate(true);
-							const failure = node.sources.find((source) => source.fault)?.fault;
-							if (failure) throw failure;
-							node.fault = void 0;
-						} catch (cause) {
-							node.fault = errorFor(node, cause);
-							errors.push(node.fault);
-						}
-					}
-				}
-				node.forced = false;
-				node.statusChanged = wasFaulted !== (node.fault !== void 0);
-				completed.push(node);
-				if (changed || wasFaulted || node.fault) {
-					profile.projection("publishedNodes");
-					emissions.add(node);
-					node.consumers.forEach(enqueue);
-				}
-			}
-			completed.forEach((node) => node.publish());
-		} finally {
-			lock(false);
-			phase = "idle";
-		}
-	};
-	const flush = () => {
-		if (disposed || depth) return [];
-		if (pending.size || completed.length) profile.projection("flushes");
-		phase = "notify";
-		lock(true);
-		const reportFailures = [];
-		try {
-			emissions.forEach((node) => node.emit((listener) => {
-				try {
-					listener();
-				} catch (cause) {
-					errors.push(errorFor(node, 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 {
-			pending.forEach((source) => source.clear());
-			completed.forEach((node) => node.clear());
-			pending.clear();
-			queued.clear();
-			completed.length = 0;
-			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;
-			}
-		}
-	};
-	return {
-		assertActive,
-		assertIdle,
-		capture,
-		settle,
-		flush,
-		run,
-		records,
-		guards,
-		cleanups,
-		get active() {
-			return !disposed;
-		},
-		register(handle, record) {
-			assertIdle();
-			records.set(handle, record);
-			projectionHandles.add(handle);
-		},
-		unregisterSource(handle) {
-			const record = records.get(handle);
-			if (record) {
-				record.disposed = true;
-				pending.delete(record);
-				record.clear();
-				records.delete(handle);
-			}
-		},
-		source(handle) {
-			assertActive();
-			const source = records.get(handle);
-			if (!source || source.disposed) throw new Error("Unknown, disposed, or foreign projection source.");
-			return source;
-		},
-		addNode(node) {
-			nodes.add(node);
-			node.sources.forEach((source) => source.consumers.add(node));
-		},
-		order: () => sequence++,
-		initialize(run) {
-			assertIdle();
-			phase = "compute";
-			lock(true);
-			try {
-				return run();
-			} finally {
-				lock(false);
-				phase = "idle";
-			}
-		},
-		rebuild(node) {
-			assertIdle();
-			if (node.disposed) throw new ProjectionDisposedError();
-			node.forced = true;
-			enqueue(node);
-			run();
-		},
-		disposeNode(node) {
-			if (node.disposed) return;
-			assertIdle();
-			if (node.consumers.size) throw new Error("Cannot dispose a projection node with downstream consumers.");
-			node.disposed = true;
-			node.sources.forEach((source) => source.consumers.delete(node));
-			nodes.delete(node);
-			node.release();
-			for (const [handle, record] of records) if (record === node) records.delete(handle);
-		},
-		batch,
-		batchContext: () => activeBatch,
-		dispose() {
-			if (disposed) return;
-			assertIdle();
-			disposed = true;
-			const failures = [];
-			cleanups.forEach((cleanup) => {
-				try {
-					cleanup();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			cleanups.clear();
-			nodes.forEach((node) => {
-				node.disposed = true;
-				node.release();
-				node.consumers.clear();
-			});
-			records.forEach((source) => {
-				source.disposed = true;
-				source.consumers.clear();
-				source.clear();
-			});
-			nodes.clear();
-			records.clear();
-			pending.clear();
-			heap.length = 0;
-			completed.length = 0;
-			queued.clear();
-			emissions.clear();
-			guards.clear();
-			errors.length = 0;
-			reportingFailures = [];
-			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
-		},
-		debug: () => ({
-			nodes: nodes.size,
-			sources: records.size - nodes.size,
-			subscriptions: cleanups.size,
-			pending: pending.size + heap.length
-		})
-	};
-};
-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/node.ts
-const createNode = (scheduler, spec, behavior) => {
-	scheduler.assertIdle();
-	const entries = Object.entries(spec.sources).map(([key, handle]) => [key, scheduler.source(handle)]);
-	const order = scheduler.order();
-	const node = {
-		...behavior,
-		publish: () => {
-			if (node.fault) behavior.clear();
-			else behavior.publish();
-		},
-		order,
-		name: spec.name ? `${spec.name} (${order})` : `projection-${order}`,
-		sources: entries.map(([, source]) => source),
-		consumers: /* @__PURE__ */ new Set(),
-		disposed: false,
-		fault: void 0,
-		forced: false,
-		statusChanged: false,
-		evaluate: (build) => {
-			let active = true;
-			try {
-				const scopeActive = () => active;
-				const inputs = Object.fromEntries(entries.map(([key, source]) => [key, source.context(scopeActive)]));
-				return behavior.evaluate(inputs, build, scopeActive);
-			} finally {
-				active = false;
-			}
-		}
-	};
-	scheduler.initialize(() => {
-		const invalid = node.sources.find((source) => source.fault || source.disposed);
-		if (invalid) throw invalid.fault ?? new ProjectionDisposedError();
-		node.evaluate(true);
-		node.publish();
-		node.clear();
-	});
-	const check = () => {
-		if (node.disposed || !scheduler.active) throw new ProjectionDisposedError();
-		if (node.fault) throw node.fault;
-	};
-	return {
-		node,
-		check,
-		install(handle) {
-			scheduler.register(handle, node);
-			scheduler.addNode(node);
-		},
-		rebuild: () => scheduler.rebuild(node),
-		dispose: () => scheduler.disposeNode(node)
-	};
-};
-//#endregion
-//#region core/src/projection/collection.ts
-const collectionHandles = /* @__PURE__ */ new WeakSet();
-const readonlySet = (values) => {
-	const set = new Set(values);
-	const view = Object.freeze({
-		get size() {
-			return set.size;
-		},
-		has: (value) => set.has(value),
-		entries: () => set.entries(),
-		keys: () => set.keys(),
-		values: () => set.values(),
-		[Symbol.iterator]: () => set.values(),
-		forEach: (callback, thisArg) => set.forEach((value) => callback.call(thisArg, value, value, view))
-	});
-	return view;
-};
-const createCollection = (scheduler, spec) => {
-	const values = /* @__PURE__ */ new Map();
-	let ids = Object.freeze([]);
-	let staged = /* @__PURE__ */ new Map();
-	let nextIds = ids;
-	let change;
-	let instance;
-	let initialized = false;
-	let reset = false;
-	let revision = 0;
-	let idsRevision = 0;
-	let batch;
-	let cause;
-	let publishedTransitions = Object.freeze([]);
-	let all;
-	const items = /* @__PURE__ */ new Map();
-	const subscribedItems = /* @__PURE__ */ new Set();
-	const idsListeners = /* @__PURE__ */ new Set();
-	const allListeners = /* @__PURE__ */ new Set();
-	const listeners = /* @__PURE__ */ new Set();
-	const changedKeys = /* @__PURE__ */ new Set();
-	let orderChanged = false;
-	const current = Object.freeze({
-		get: (key) => {
-			owner.check();
-			return values.get(key);
-		},
-		has: (key) => {
-			owner.check();
-			return values.has(key);
-		},
-		ids: () => {
-			owner.check();
-			return ids;
-		}
-	});
-	const hasNext = (key) => staged.has(key) ? staged.get(key).present : values.has(key);
-	const getNext = (key) => {
-		const entry = staged.get(key);
-		return entry ? entry.present ? entry.value : void 0 : values.get(key);
-	};
-	const owner = createNode(scheduler, spec, {
-		evaluate: (sources, build, active) => {
-			const metadata = Object.values(sources).find((value) => value && typeof value === "object" && ("batch" in value && value.batch !== void 0 || "cause" in value && value.cause !== void 0));
-			batch = scheduler.batchContext() ?? metadata?.batch;
-			cause = metadata?.cause ?? batch?.cause;
-			staged = /* @__PURE__ */ new Map();
-			nextIds = ids;
-			change = void 0;
-			changedKeys.clear();
-			let explicitOrder;
-			let cleared = false;
-			const nextHas = (key) => staged.has(key) ? staged.get(key).present : !cleared && values.has(key);
-			const nextGet = (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(nextHas);
-				for (const [key, entry] of staged) if (entry.present && (cleared || !values.has(key))) result.push(key);
-				return result;
-			};
-			const read = (next) => ({
-				get: (key) => {
-					assertScope(active);
-					return next ? nextGet(key) : values.get(key);
-				},
-				has: (key) => {
-					assertScope(active);
-					return next ? nextHas(key) : values.has(key);
-				},
-				ids: () => {
-					assertScope(active);
-					return next ? Object.freeze(explicitOrder ? explicitOrder.slice() : deriveIds()) : ids;
-				}
-			});
-			const writer = {
-				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 = order.slice();
-				},
-				replace: (entries) => {
-					assertScope(active);
-					staged.clear();
-					cleared = true;
-					const order = [];
-					for (const [key, value] of entries) {
-						if (staged.has(key)) throw new TypeError("Duplicate projection key.");
-						writer.set(key, value);
-						order.push(key);
-					}
-					explicitOrder = order;
-				}
-			};
-			const input = {
-				sources,
-				previous: read(false),
-				next: read(true),
-				writer
-			};
-			if (build || !instance) {
-				profile.materialized.rebuilt();
-				instance = void 0;
-				cleared = true;
-				const built = spec.build(input);
-				assertSynchronous(built);
-				instance = built;
-			} else {
-				profile.materialized.updated();
-				const result = instance.update(input);
-				assertSynchronous(result);
-				if (result?.kind === "rebuild") {
-					staged.clear();
-					cleared = true;
-					explicitOrder = void 0;
-					instance = void 0;
-					const built = spec.build(input);
-					assertSynchronous(built);
-					instance = built;
-					build = true;
-				}
-			}
-			if (cleared) {
-				for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
-			}
-			const added = /* @__PURE__ */ new Set();
-			const removed = /* @__PURE__ */ new Set();
-			const updated = /* @__PURE__ */ new Set();
-			profile.projection("touchedKeys", staged.size);
-			for (const [key, entry] of staged) {
-				const existed = values.has(key);
-				if (entry.present) if (!existed) added.add(key);
-				else if (!(spec.isEqual ?? Object.is)(values.get(key), entry.value)) updated.add(key);
-				else 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, i) => key === order[i]) ? ids : Object.freeze(order.slice());
-			}
-			orderChanged = nextIds !== ids;
-			if (added.size || removed.size || updated.size || 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, i) => after[i] !== key);
-				}
-				change = Object.freeze({
-					kind: "incremental",
-					added: readonlySet(added),
-					removed: readonlySet(removed),
-					updated: readonlySet(updated),
-					orderChanged: commonOrderChanged
-				});
-				[
-					...added,
-					...removed,
-					...updated
-				].forEach((key) => changedKeys.add(key));
-				profile.projection("changedKeys", changedKeys.size);
-			}
-			publishedTransitions = Object.freeze([...changedKeys].flatMap((key) => {
-				const beforePresent = values.has(key);
-				const afterPresent = hasNext(key);
-				if (beforePresent === afterPresent) {
-					if (!beforePresent) return [];
-					if ((spec.isEqual ?? Object.is)(values.get(key), getNext(key))) return [];
-				}
-				return [{
-					key,
-					kind: !beforePresent ? "added" : !afterPresent ? "removed" : "updated",
-					before: beforePresent ? values.get(key) : void 0,
-					after: afterPresent ? getNext(key) : void 0
-				}];
-			}));
-			reset = build;
-			return change !== void 0;
-		},
-		context: (active) => {
-			const transitions = (keys) => {
-				assertScope(active);
-				const selected = keys ? new Set(keys) : void 0;
-				return Object.freeze(publishedTransitions.filter((transition) => !selected || selected.has(transition.key)));
-			};
-			const input = {
-				get: (key) => {
-					assertScope(active);
-					return getNext(key);
-				},
-				has: (key) => {
-					assertScope(active);
-					return hasNext(key);
-				},
-				ids: () => {
-					assertScope(active);
-					return nextIds;
-				},
-				previous: Object.freeze({
-					get: (key) => {
-						assertScope(active);
-						return values.get(key);
-					},
-					has: (key) => {
-						assertScope(active);
-						return values.has(key);
-					},
-					ids: () => {
-						assertScope(active);
-						return ids;
-					}
-				}),
-				change,
-				revision: revision + (change ? 1 : 0),
-				reset,
-				transitions,
-				batch,
-				cause
-			};
-			return Object.freeze(input);
-		},
-		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
-			else values.delete(key);
-			if (change) {
-				if (initialized) revision++;
-				if (orderChanged && initialized) idsRevision++;
-				all = void 0;
-				changedKeys.forEach((key) => {
-					const item = items.get(key);
-					if (item && initialized) item.revision++;
-				});
-			}
-			ids = nextIds;
-			initialized = true;
-		},
-		emit: (call) => {
-			profile.materialized.notification();
-			const fault = owner.node.fault !== void 0;
-			const resetEvent = Object.freeze({ kind: "reset" });
-			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
-			if (orderChanged || !change || fault || owner.node.statusChanged) Array.from(idsListeners).forEach((listener) => call(listener));
-			Array.from(allListeners).forEach((listener) => call(listener));
-			if (!change || fault || owner.node.statusChanged) for (const item of subscribedItems) Array.from(item.listeners ?? []).forEach((listener) => call(listener));
-			else for (const key of changedKeys) Array.from(items.get(key)?.listeners ?? []).forEach((listener) => call(listener));
-		},
-		clear: () => {
-			staged.clear();
-			nextIds = ids;
-			change = void 0;
-			reset = false;
-			changedKeys.clear();
-			publishedTransitions = Object.freeze([]);
-			batch = void 0;
-			cause = void 0;
-			orderChanged = false;
-		},
-		release: () => {
-			values.clear();
-			staged.clear();
-			items.clear();
-			subscribedItems.clear();
-			idsListeners.clear();
-			allListeners.clear();
-			listeners.clear();
-			ids = nextIds = Object.freeze([]);
-			all = void 0;
-			instance = void 0;
-		}
-	});
-	const handle = {
-		current: () => {
-			owner.check();
-			return current;
-		},
-		ids: {
-			current: () => {
-				owner.check();
-				return ids;
-			},
-			revision: () => {
-				owner.check();
-				return idsRevision;
-			},
-			subscribe: (listener) => {
-				owner.check();
-				idsListeners.add(listener);
-				return () => {
-					idsListeners.delete(listener);
-				};
-			}
-		},
-		all: {
-			current: () => {
-				owner.check();
-				if (!all) {
-					profile.collectionView.arrayCopied();
-					all = Object.freeze(ids.map((key) => values.get(key)));
-				}
-				return all;
-			},
-			revision: () => {
-				owner.check();
-				return revision;
-			},
-			subscribe: (listener) => {
-				owner.check();
-				allListeners.add(listener);
-				return () => {
-					allListeners.delete(listener);
-				};
-			}
-		},
-		item: (key) => {
-			owner.check();
-			const old = items.get(key);
-			if (old) return old.readable;
-			const readable = Object.freeze({
-				current: () => {
-					owner.check();
-					return values.get(key);
-				},
-				revision: () => {
-					owner.check();
-					return item.revision;
-				},
-				subscribe: (listener) => {
-					owner.check();
-					const set = item.listeners ??= /* @__PURE__ */ new Set();
-					set.add(listener);
-					subscribedItems.add(item);
-					return () => {
-						set.delete(listener);
-						if (!set.size) subscribedItems.delete(item);
-					};
-				}
-			});
-			const item = {
-				readable,
-				revision: 0
-			};
-			projectionHandles.add(readable);
-			items.set(key, item);
-			return readable;
-		},
-		revision: () => {
-			owner.check();
-			return revision;
-		},
-		subscribe: (listener) => {
-			owner.check();
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		},
-		rebuild: owner.rebuild,
-		dispose: owner.dispose
-	};
-	projectionHandles.add(handle.ids);
-	projectionHandles.add(handle.all);
-	collectionHandles.add(handle);
-	owner.install(handle);
-	return Object.freeze(handle);
-};
-//#endregion
-//#region core/src/projection/source.ts
-const createSources = (scheduler) => {
-	const documents = /* @__PURE__ */ new Map();
-	const readables = /* @__PURE__ */ new Map();
-	const collections = /* @__PURE__ */ new WeakSet();
-	const externalSources = /* @__PURE__ */ new WeakMap();
-	const document = (runtime) => {
-		scheduler.assertIdle();
-		const state = accessOf(runtime);
-		if (state.disposed) throw new Error("Document has been disposed.");
-		const existing = documents.get(state);
-		if (existing) return existing;
-		const bindings = [];
-		let batch;
-		const make = (input) => {
-			const collection = "collection" in input ? input.collection : void 0;
-			const targets = "targets" in input ? input.targets : [input.collection];
-			if (state.disposed) throw new Error("Document has been disposed.");
-			targets.forEach((value) => {
-				if (!belongs(value, state.schema)) throw new Error("Projection target belongs to another schema.");
-			});
-			const old = bindings.find((entry) => Boolean(collection) === collections.has(entry.handle) && entry.targets.length === targets.length && entry.targets.every((value, i) => same(value, targets[i])));
-			if (old) return old.handle;
-			let commits = [];
-			let reset = false;
-			let orderDirty = false;
-			const keys = /* @__PURE__ */ new Set();
-			let candidates;
-			const record = {
-				consumers: /* @__PURE__ */ new Set(),
-				disposed: false,
-				fault: void 0,
-				revision: runtime.revision,
-				reset: () => reset,
-				clear: () => {
-					commits = [];
-					reset = orderDirty = false;
-					batch = void 0;
-					keys.clear();
-					candidates = void 0;
-				},
-				context: (active) => {
-					assertScope(active);
-					if (state.disposed) throw new Error("Document has been disposed.");
-					const context = {
-						state,
-						active
-					};
-					const read = collection ? collectionAccess(context, collection.address) : createAccess(context);
-					return Object.freeze({
-						read,
-						revision: runtime.revision(),
-						commits: Object.freeze(commits.slice()),
-						reset: record.reset(),
-						batch,
-						cause: batch?.cause,
-						...collection ? { candidates: candidates ??= Object.freeze({
-							keys: Object.freeze([...keys]),
-							orderDirty
-						}) } : {}
-					});
-				}
-			};
-			const handle = collection ? {} : {
-				collection: (pick) => {
-					scheduler.assertIdle();
-					return make({ collection: compilePath(state.schema, "collection", pick) });
-				},
-				targets: (...selected) => {
-					scheduler.assertIdle();
-					if (!selected.length) throw new TypeError("Expected at least one target.");
-					return make({ targets: selected.map((pick) => compilePath(state.schema, "value", pick)) });
-				}
-			};
-			Object.freeze(handle);
-			if (collection) collections.add(handle);
-			scheduler.register(handle, record);
-			const receive = (commit) => {
-				commits.push(commit);
-				reset ||= commit.impact.kind === "reset";
-				if (collection) {
-					const change = collectionImpact(commit.impact, collection);
-					if (change.kind === "reset") reset = true;
-					else {
-						change.added.forEach((key) => keys.add(key));
-						change.removed.forEach((key) => keys.add(key));
-						change.updated.forEach((key) => keys.add(key));
-						orderDirty ||= Boolean(change.added.size || change.removed.size || change.orderChanged);
-					}
-					candidates = void 0;
-				}
-			};
-			bindings.push({
-				handle,
-				targets,
-				record,
-				receive
-			});
-			return handle;
-		};
-		const handle = make({ targets: [] });
-		const guard = (locked) => {
-			state.projectionLocks = (state.projectionLocks ?? 0) + (locked ? 1 : -1);
-		};
-		scheduler.guards.add(guard);
-		const unsubscribe = attachProjection(runtime, {
-			capture: (commit) => {
-				for (const binding of bindings) if (!binding.targets.length || binding.targets.some((value) => affectsTarget(commit.impact, value))) {
-					binding.receive(commit);
-					batch = scheduler.batchContext();
-					scheduler.capture(binding.record);
-				}
-			},
-			settle: scheduler.settle,
-			flush: scheduler.flush,
-			dispose: () => {
-				bindings.forEach(({ record }) => {
-					record.fault = new ProjectionError("source", "document disposed", [runtime.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
-					scheduler.capture(record);
-				});
-				scheduler.run();
-			}
-		});
-		scheduler.cleanups.add(() => {
-			unsubscribe();
-			scheduler.guards.delete(guard);
-		});
-		documents.set(state, handle);
-		return handle;
-	};
-	const valueSource = (initial, equal) => {
-		let value = initial;
-		let previous = initial;
-		let revision = 0;
-		let detail;
-		let cause;
-		let batch;
-		let reset = false;
-		let pending = false;
-		const handle = Object.freeze({});
-		const record = {
-			consumers: /* @__PURE__ */ new Set(),
-			disposed: false,
-			fault: void 0,
-			revision: () => revision,
-			reset: () => reset,
-			clear: () => {
-				previous = value;
-				pending = false;
-				detail = void 0;
-				cause = void 0;
-				batch = void 0;
-				reset = false;
-			},
-			context: (active) => {
-				assertScope(active);
-				return Object.freeze({
-					value,
-					previous,
-					revision,
-					changed: !equal(previous, value),
-					reset,
-					detail,
-					cause,
-					batch
-				});
-			}
-		};
-		scheduler.register(handle, record);
-		const accept = (next, metadata) => {
-			scheduler.assertIdle();
-			const recovering = record.fault !== void 0;
-			const eventful = metadata !== void 0 && (metadata.reset === true || metadata.revision !== void 0 && metadata.revision !== revision || metadata.detail !== void 0 || metadata.cause !== void 0 || metadata.batch !== void 0);
-			if (equal(value, next) && !recovering && !eventful) return;
-			record.fault = void 0;
-			if (!pending) previous = value;
-			value = next;
-			revision = metadata?.revision ?? revision + 1;
-			detail = metadata?.detail;
-			cause = metadata?.cause ?? cause;
-			batch = scheduler.batchContext() ?? metadata?.batch ?? batch;
-			reset ||= metadata?.reset ?? false;
-			scheduler.capture(record);
-			pending = true;
-		};
-		return {
-			source: handle,
-			accept,
-			set(next) {
-				accept(next);
-				scheduler.run();
-			}
-		};
-	};
-	const externalValueSource = (port, equal) => {
-		scheduler.assertIdle();
-		const old = externalSources.get(port);
-		if (old) return old;
-		const input = valueSource(port.current(), equal);
-		const fail = (cause) => {
-			const record = scheduler.source(input.source);
-			record.fault = new ProjectionError("source", "external source", [record.revision()], cause);
-			scheduler.capture(record);
-		};
-		let unsubscribe;
-		try {
-			unsubscribe = port.subscribe((event) => {
-				try {
-					input.accept(event.value, {
-						revision: event.revision,
-						reset: event.reset,
-						detail: event.detail,
-						cause: event.cause,
-						batch: event.batch
-					});
-				} catch (cause) {
-					fail(cause);
-				}
-				scheduler.run();
-			});
-		} catch (cause) {
-			unsubscribe?.();
-			scheduler.unregisterSource(input.source);
-			throw cause;
-		}
-		scheduler.cleanups.add(() => unsubscribe?.());
-		externalSources.set(port, input.source);
-		return input.source;
-	};
-	const externalCollectionSource = (port) => {
-		scheduler.assertIdle();
-		const old = externalSources.get(port);
-		if (old) return old;
-		let read = port.current();
-		let previous = read;
-		let revision = port.revision();
-		let change;
-		let reset = false;
-		let detail;
-		let cause;
-		let batch;
-		let publishedTransitions = Object.freeze([]);
-		let transitionKeys = /* @__PURE__ */ new Set();
-		let pending = false;
-		const handle = Object.freeze({});
-		const record = {
-			consumers: /* @__PURE__ */ new Set(),
-			disposed: false,
-			fault: void 0,
-			revision: () => revision,
-			reset: () => reset,
-			clear: () => {
-				previous = read;
-				pending = false;
-				change = void 0;
-				reset = false;
-				detail = void 0;
-				cause = void 0;
-				batch = void 0;
-				publishedTransitions = Object.freeze([]);
-				transitionKeys.clear();
-			},
-			context: (active) => {
-				assertScope(active);
-				const currentRead = Object.freeze({
-					get: (key) => {
-						assertScope(active);
-						return read.get(key);
-					},
-					has: (key) => {
-						assertScope(active);
-						return read.has(key);
-					},
-					ids: () => {
-						assertScope(active);
-						return read.ids();
-					}
-				});
-				const previousRead = Object.freeze({
-					get: (key) => {
-						assertScope(active);
-						return previous.get(key);
-					},
-					has: (key) => {
-						assertScope(active);
-						return previous.has(key);
-					},
-					ids: () => {
-						assertScope(active);
-						return previous.ids();
-					}
-				});
-				return Object.freeze({
-					...currentRead,
-					previous: previousRead,
-					change,
-					revision,
-					reset,
-					transitions: (keys) => {
-						assertScope(active);
-						const selected = keys ? new Set(keys) : void 0;
-						return Object.freeze(publishedTransitions.filter((transition) => !selected || selected.has(transition.key)));
-					},
-					detail,
-					cause,
-					batch
-				});
-			}
-		};
-		scheduler.register(handle, record);
-		collections.add(handle);
-		const fail = (error) => {
-			record.fault = new ProjectionError("source", "external collection source", [revision], error);
-			scheduler.capture(record);
-		};
-		const addTransitionKeys = (event) => {
-			event.transitions().forEach((transition) => transitionKeys.add(transition.key));
-			const impact = event.change;
-			if (impact?.kind === "incremental") {
-				impact.added.forEach((key) => transitionKeys.add(key));
-				impact.removed.forEach((key) => transitionKeys.add(key));
-				impact.updated.forEach((key) => transitionKeys.add(key));
-			}
-		};
-		const recomputeTransitions = () => {
-			const transitions = [];
-			for (const key of transitionKeys) {
-				const beforePresent = previous.has(key);
-				const afterPresent = read.has(key);
-				const before = beforePresent ? previous.get(key) : void 0;
-				const after = afterPresent ? read.get(key) : void 0;
-				if (beforePresent === afterPresent && Object.is(before, after)) continue;
-				transitions.push({
-					key,
-					kind: !beforePresent ? "added" : !afterPresent ? "removed" : "updated",
-					before,
-					after
-				});
-			}
-			publishedTransitions = Object.freeze(transitions);
-		};
-		const deriveChange = () => {
-			if (reset) return Object.freeze({ kind: "reset" });
-			const added = /* @__PURE__ */ new Set();
-			const removed = /* @__PURE__ */ new Set();
-			const updated = /* @__PURE__ */ new Set();
-			publishedTransitions.forEach((transition) => {
-				if (transition.kind === "added") added.add(transition.key);
-				else if (transition.kind === "removed") removed.add(transition.key);
-				else updated.add(transition.key);
-			});
-			const beforeIds = previous.ids();
-			const afterIds = read.ids();
-			const beforeCommon = beforeIds.filter((key) => read.has(key));
-			const afterCommon = afterIds.filter((key) => previous.has(key));
-			const orderChanged = beforeCommon.length !== afterCommon.length || beforeCommon.some((key, index) => afterCommon[index] !== key);
-			if (!added.size && !removed.size && !updated.size && !orderChanged) return void 0;
-			return Object.freeze({
-				kind: "incremental",
-				added,
-				removed,
-				updated,
-				orderChanged
-			});
-		};
-		let unsubscribe;
-		try {
-			unsubscribe = port.subscribe((event) => {
-				try {
-					scheduler.assertIdle();
-					if (!pending) previous = event.previous;
-					read = port.current();
-					revision = event.revision;
-					addTransitionKeys(event);
-					reset ||= event.reset || event.change?.kind === "reset";
-					detail = event.detail;
-					cause = event.cause ?? cause;
-					batch = scheduler.batchContext() ?? event.batch;
-					recomputeTransitions();
-					change = deriveChange();
-					record.fault = void 0;
-					scheduler.capture(record);
-					pending = true;
-				} catch (error) {
-					fail(error);
-				}
-				scheduler.run();
-			});
-		} catch (error) {
-			unsubscribe?.();
-			scheduler.unregisterSource(handle);
-			throw error;
-		}
-		scheduler.cleanups.add(() => unsubscribe?.());
-		externalSources.set(port, handle);
-		return handle;
-	};
-	return {
-		dispose: () => {
-			documents.clear();
-			readables.clear();
-		},
-		document,
-		fromSource: (source, options) => externalValueSource(source, options?.isEqual ?? Object.is),
-		fromCollectionSource: (source) => externalCollectionSource(source),
-		input: (initial, options) => {
-			const { source, set } = valueSource(initial, options?.isEqual ?? Object.is);
-			return Object.freeze({
-				source,
-				set
-			});
-		},
-		fromReadable: (readable, options) => {
-			scheduler.assertIdle();
-			if (projectionHandles.has(readable)) throw new Error("Projection nodes must be declared directly as sources.");
-			const equal = options?.isEqual ?? Object.is;
-			let bindings = readables.get(readable);
-			const old = bindings?.get(equal);
-			if (old) return old.source;
-			const input = valueSource(readable.current(), equal);
-			if (bindings) {
-				bindings.set(equal, {
-					source: input.source,
-					accept: (value) => input.accept(value)
-				});
-				return input.source;
-			}
-			bindings = new Map([[equal, {
-				source: input.source,
-				accept: (value) => input.accept(value)
-			}]]);
-			const members = bindings;
-			const receive = (settle = true) => {
-				if (!scheduler.active) return;
-				let value;
-				try {
-					value = readable.current();
-				} catch (cause) {
-					for (const member of members.values()) {
-						const record = scheduler.source(member.source);
-						record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
-						scheduler.capture(record);
-					}
-					if (settle) scheduler.run();
-					return;
-				}
-				for (const member of members.values()) try {
-					member.accept(value);
-				} catch (cause) {
-					const record = scheduler.source(member.source);
-					record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
-					scheduler.capture(record);
-				}
-				if (settle) scheduler.run();
-			};
-			let unsubscribe;
-			let detach;
-			try {
-				const owner = documentReadableOwner(readable);
-				if (owner) {
-					document(owner);
-					detach = attachProjection(owner, {
-						capture: () => receive(false),
-						settle: scheduler.settle,
-						flush: scheduler.flush,
-						dispose: () => {
-							for (const member of members.values()) {
-								const record = scheduler.source(member.source);
-								record.fault = new ProjectionError("source", "document readable disposed", [record.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
-								scheduler.capture(record);
-							}
-							scheduler.run();
-						}
-					});
-				}
-				unsubscribe = readable.subscribe(() => receive());
-				input.accept(readable.current());
-			} catch (error) {
-				try {
-					unsubscribe?.();
-					detach?.();
-				} finally {
-					scheduler.unregisterSource(input.source);
-				}
-				throw error;
-			}
-			scheduler.cleanups.add(unsubscribe);
-			if (detach) scheduler.cleanups.add(detach);
-			readables.set(readable, bindings);
-			scheduler.run();
-			return input.source;
-		},
-		assertCollection: (handle) => {
-			scheduler.source(handle);
-			if (!collections.has(handle) && !collectionHandles.has(handle)) throw new Error("map requires a collection source.");
-		}
-	};
-};
-//#endregion
-//#region core/src/projection/value.ts
-const createValue = (scheduler, spec, options) => {
-	let instance;
-	let value;
-	let next;
-	let previous;
-	let initialized = false;
-	let revision = 0;
-	let changed = false;
-	let reset = false;
-	let batch;
-	let cause;
-	const listeners = /* @__PURE__ */ new Set();
-	const owner = createNode(scheduler, spec, {
-		evaluate: (sources, build) => {
-			const metadata = Object.values(sources).find((value) => value && typeof value === "object" && ("batch" in value && value.batch !== void 0 || "cause" in value && value.cause !== void 0));
-			batch = scheduler.batchContext() ?? metadata?.batch;
-			cause = metadata?.cause ?? batch?.cause;
-			let candidate;
-			if (build || !instance) {
-				profile.materialized.rebuilt();
-				instance = void 0;
-				const built = spec.build(sources);
-				assertSynchronous(built);
-				instance = built;
-				candidate = built.value;
-			} else {
-				profile.materialized.updated();
-				const result = instance.update(sources);
-				assertSynchronous(result);
-				if (result.kind === "rebuild") {
-					instance = void 0;
-					const built = spec.build(sources);
-					assertSynchronous(built);
-					instance = built;
-					candidate = built.value;
-					build = true;
-				} else candidate = result.kind === "changed" ? result.value : value;
-			}
-			previous = value;
-			changed = !initialized || !(options?.isEqual ?? Object.is)(value, candidate);
-			next = changed ? candidate : value;
-			reset = build;
-			return changed;
-		},
-		context: (active) => {
-			assertScope(active);
-			return Object.freeze({
-				value: next,
-				previous,
-				changed,
-				revision: revision + (changed ? 1 : 0),
-				reset,
-				cause,
-				batch
-			});
-		},
-		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			if (changed && initialized) revision++;
-			value = next;
-			initialized = true;
-		},
-		emit: (call) => {
-			profile.materialized.notification();
-			Array.from(listeners).forEach((listener) => call(listener));
-		},
-		clear: () => {
-			next = value;
-			previous = value;
-			changed = false;
-			reset = false;
-			batch = void 0;
-			cause = void 0;
-		},
-		release: () => {
-			listeners.clear();
-			instance = void 0;
-			value = next = previous = void 0;
-		}
-	});
-	const handle = Object.freeze({
-		current: () => {
-			owner.check();
-			return value;
-		},
-		revision: () => {
-			owner.check();
-			return revision;
-		},
-		subscribe: (listener) => {
-			owner.check();
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		},
-		rebuild: owner.rebuild,
-		dispose: owner.dispose
-	});
-	owner.install(handle);
-	return handle;
-};
-//#endregion
-//#region core/src/projection/runtime.ts
-const createRuntimeExecutor = (options) => {
-	const scheduler = createScheduler(options.onError);
-	const sources = createSources(scheduler);
-	function value(input, computeOrOptions, options) {
-		if (typeof computeOrOptions !== "function") return createValue(scheduler, input, computeOrOptions);
-		const compute = (input) => {
-			const result = computeOrOptions(input);
-			assertSynchronous(result);
-			return result;
-		};
-		return createValue(scheduler, {
-			sources: input,
-			build: (input) => ({
-				value: compute(input),
-				update: (input) => ({
-					kind: "changed",
-					value: compute(input)
-				})
-			})
-		}, options);
-	}
-	const map = (source, mapper, options) => {
-		sources.assertCollection(source);
-		const calculate = (id, entry) => {
-			const value = mapper(id, entry);
-			assertSynchronous(value);
-			return value;
-		};
-		return createCollection(scheduler, {
-			sources: { source },
-			isEqual: options?.isEqual,
-			build: ({ sources, writer }) => {
-				const input = sources.source;
-				const read = "read" in input ? input.read : input;
-				const ids = read.ids();
-				profile.collectionView.idsScanned(ids.length);
-				for (const id of ids) {
-					profile.collectionView.mapped();
-					writer.set(id, calculate(id, read.get(id)));
-				}
-				writer.order(ids);
-				return { update: ({ sources, writer }) => {
-					const input = sources.source;
-					if (input.reset) return { kind: "rebuild" };
-					const read = "read" in input ? input.read : input;
-					let keys;
-					let structural;
-					if ("candidates" in input) {
-						keys = input.candidates.keys;
-						structural = input.candidates.orderDirty;
-					} else {
-						const change = input.change;
-						if (!change) return;
-						if (change.kind === "reset") return { kind: "rebuild" };
-						keys = new Set([
-							...change.added,
-							...change.removed,
-							...change.updated
-						]);
-						structural = Boolean(change.added.size || change.removed.size || change.orderChanged);
-					}
-					for (const key of keys) if (!read.has(key)) writer.remove(key);
-					else {
-						profile.collectionView.mapped();
-						writer.set(key, calculate(key, read.get(key)));
-					}
-					if (structural) {
-						const ids = read.ids();
-						profile.collectionView.idsScanned(ids.length);
-						writer.order(ids);
-					}
-				} };
-			}
-		});
-	};
-	const runtime = {
-		document: sources.document,
-		fromSource: (source, options) => sources.fromSource(source, options),
-		fromCollectionSource: (source) => sources.fromCollectionSource(source),
-		input: sources.input,
-		fromReadable: sources.fromReadable,
-		value,
-		collection: () => (spec) => createCollection(scheduler, spec),
-		map,
-		batch: scheduler.batch,
-		dispose: () => {
-			try {
-				scheduler.dispose();
-			} finally {
-				if (!scheduler.active) sources.dispose();
-			}
-		}
-	};
-	return Object.freeze(runtime);
-};
-//#endregion
-//#region core/src/projection/store.ts
-const runtimeStates = /* @__PURE__ */ new WeakMap();
-let activeTracker;
-const trackKey = (key) => {
-	activeTracker?.keys.add(key);
-};
-const trackAll = (structure = false) => {
-	if (!activeTracker) return;
-	activeTracker.all = true;
-	activeTracker.structure ||= structure;
-};
-const mapView = (read) => {
-	const keys = read.ids();
-	const source = /* @__PURE__ */ new Map();
-	for (const key of keys) source.set(key, read.get(key));
-	const view = {
-		get: (key) => {
-			trackKey(key);
-			return source.get(key);
-		},
-		has: (key) => {
-			trackKey(key);
-			return source.has(key);
-		},
-		get size() {
-			trackAll(true);
-			return source.size;
-		},
-		keys: () => {
-			trackAll(true);
-			return source.keys();
-		},
-		values: () => {
-			trackAll(true);
-			return source.values();
-		},
-		entries: () => {
-			trackAll(true);
-			return source.entries();
-		},
-		forEach: (callback, thisArg) => {
-			trackAll(true);
-			source.forEach((value, key) => callback.call(thisArg, value, key, view));
-		},
-		[Symbol.iterator]: () => {
-			trackAll(true);
-			return source[Symbol.iterator]();
-		}
-	};
-	return Object.freeze(view);
-};
-const isMapLike = (value) => value instanceof Map || value !== null && typeof value === "object" && typeof value.get === "function" && typeof value.keys === "function" && typeof value.entries === "function";
-const mapRead = (value) => ({
-	get: (key) => value.get(key),
-	has: (key) => value.has(key),
-	ids: () => Object.freeze([...value.keys()])
-});
-const mapChange = (previous, current) => {
-	const added = /* @__PURE__ */ new Set();
-	const removed = /* @__PURE__ */ new Set();
-	const updated = /* @__PURE__ */ new Set();
-	for (const key of previous.keys()) if (!current.has(key)) removed.add(key);
-	else if (!Object.is(previous.get(key), current.get(key))) updated.add(key);
-	for (const key of current.keys()) if (!previous.has(key)) added.add(key);
-	const before = [...previous.keys()].filter((key) => current.has(key));
-	const after = [...current.keys()].filter((key) => previous.has(key));
-	const orderChanged = before.length !== after.length || before.some((key, index) => key !== after[index]);
-	if (!added.size && !removed.size && !updated.size && !orderChanged) return void 0;
-	return {
-		kind: "incremental",
-		added,
-		removed,
-		updated,
-		orderChanged
-	};
-};
-const currentValue = (event) => {
-	if (!event || typeof event !== "object") return event;
-	if ("value" in event) return event.value;
-	if ("read" in event) return snapshot(event.read);
-	if ("ids" in event && typeof event.ids === "function") return mapView(event);
-	return event;
-};
-const sourceOf = (instance) => instance;
-const createProjectionRuntime = (options) => {
-	const runtime = createRuntimeExecutor({ onError: options?.onError ?? (() => void 0) });
-	const instances = /* @__PURE__ */ new WeakMap();
-	const inputs = /* @__PURE__ */ new WeakMap();
-	const collections = /* @__PURE__ */ new WeakMap();
-	const materialize = (projection) => {
-		const old = instances.get(projection);
-		if (old) return old;
-		const definition = definitionOf(projection);
-		let instance;
-		switch (definition.kind) {
-			case "input": {
-				const input = runtime.input(definition.initial, { isEqual: definition.isEqual });
-				inputs.set(projection, input);
-				instance = runtime.value({ input: input.source }, ({ input }) => input.value);
-				break;
-			}
-			case "readable": {
-				const source = runtime.fromReadable(definition.readable, { isEqual: definition.isEqual });
-				instance = runtime.value({ source }, ({ source }) => source.value);
-				break;
-			}
-			case "source-value":
-				{
-					const source = runtime.fromSource(definition.source);
-					instance = runtime.value({ source }, ({ source }) => source.value);
-				}
-				break;
-			case "source-collection": {
-				const source = runtime.fromCollectionSource(definition.source);
-				instance = runtime.map(source, (_key, value) => value);
-				break;
-			}
-			case "document": {
-				const document = runtime.document(definition.document);
-				if (!definition.selector) {
-					instance = runtime.value({ document }, ({ document }) => snapshot(document.read));
-					break;
-				}
-				const state = accessOf(definition.document);
-				try {
-					const collection = document.collection(definition.selector);
-					instance = runtime.map(collection, (_id, entry) => snapshot(entry));
-					break;
-				} catch {
-					const selected = document.targets(definition.selector);
-					const address = compilePath(state.schema, "value", definition.selector).address;
-					instance = runtime.value({ selected }, () => {
-						return read(snapshot(state.document), address, state.schema);
-					});
-				}
-				break;
-			}
-			case "derive": {
-				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency))]));
-				instance = runtime.value(sources, (values) => definition.compute(...Object.values(values).map(currentValue)), { isEqual: definition.isEqual });
-				break;
-			}
-			case "incremental-value": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
-				instance = runtime.value({
-					sources,
-					build: definition.build
-				}, { isEqual: definition.isEqual });
-				break;
-			}
-			case "incremental-collection": {
-				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
-				instance = runtime.collection()({
-					sources,
-					build: definition.build,
-					isEqual: definition.isEqual,
-					name: definition.name
-				});
-				break;
-			}
-		}
-		instances.set(projection, instance);
-		return instance;
-	};
-	const get = (projection) => {
-		const instance = materialize(projection);
-		const current = instance.current();
-		if (current && typeof current === "object" && "ids" in current && typeof current.ids === "function") {
-			const existing = collections.get(instance);
-			const revision = instance.revision();
-			if (existing?.revision === revision) return existing.value;
-			const value = mapView(current);
-			collections.set(instance, {
-				revision,
-				value
-			});
-			return value;
-		}
-		if (isMapLike(current)) {
-			const existing = collections.get(instance);
-			const revision = instance.revision();
-			if (existing?.revision === revision) return existing.value;
-			const value = mapView(mapRead(current));
-			collections.set(instance, {
-				revision,
-				value
-			});
-			return value;
-		}
-		return current;
-	};
-	const store = {
-		get,
-		subscribe: ((projection, listener) => {
-			return materialize(projection).subscribe(listener);
-		}),
-		set: ((input, value) => {
-			materialize(input);
-			const target = inputs.get(input);
-			if (!target) throw new TypeError("Projection is not an input.");
-			target.set(value);
-		}),
-		batch: runtime.batch,
-		dispose: runtime.dispose
-	};
-	runtimeStates.set(store, {
-		materialize,
-		get
-	});
-	return Object.freeze(store);
-};
-const trackProjection = (owner, projection, selector) => {
-	const state = runtimeStates.get(owner);
-	if (!state) throw new TypeError("Unknown projection runtime.");
-	const tracker = {
-		keys: /* @__PURE__ */ new Set(),
-		all: false,
-		structure: false
-	};
-	const previous = activeTracker;
-	activeTracker = tracker;
-	try {
-		return {
-			value: selector(state.get(projection)),
-			selection: Object.freeze({
-				keys: new Set(tracker.keys),
-				all: tracker.all,
-				structure: tracker.structure
-			})
-		};
-	} finally {
-		activeTracker = previous;
-	}
-};
-const subscribeProjection = (owner, projection, selection, listener) => {
-	const state = runtimeStates.get(owner);
-	if (!state) throw new TypeError("Unknown projection runtime.");
-	const instance = state.materialize(projection);
-	let previousCollection;
-	const initialValue = state.get(projection);
-	if (isMapLike(initialValue)) previousCollection = initialValue;
-	return instance.subscribe(((change) => {
-		if (!change && previousCollection) {
-			const current = state.get(projection);
-			if (isMapLike(current)) {
-				change = mapChange(previousCollection, current);
-				previousCollection = current;
-				if (!change) return;
-			} else previousCollection = void 0;
-		}
-		if (!change || change.kind === "reset") {
-			listener();
-			return;
-		}
-		if (selection.all && (selection.structure || change.added.size || change.removed.size || change.updated.size)) {
-			listener();
-			return;
-		}
-		for (const key of selection.keys) if (change.added.has(key) || change.removed.has(key) || change.updated.has(key)) {
-			listener();
-			return;
-		}
-	}));
-};
-//#endregion
-export { variant as A, field as C, optional as D, object as E, table as O, compilePath as S, map as T, DocumentDisposedError as _, ProjectionError as a, createImpact as b, disposeNotification as c, subscribeDependencies as d, subscribeRoot as f, readWith as g, bindRuntimeAccess as h, ProjectionDisposedError as i, tree as k, notify as l, accessOf as m, subscribeProjection as n, bindDocumentReadable as o, subscribeTargets as p, trackProjection as r, createNotification as s, createProjectionRuntime as t, shareNotification as u, DocumentReentrancyError as v, list as w, same as x, TransactionRejected as y };
-
-//# sourceMappingURL=store-CtgvCVFg.js.map