doxum 0.1.13 → 0.1.15

package/dist/index.js

@@ -1,7 +1,194 @@
 import { A as insert, D as equal, F as remove, L as profile, M as keys, N as matches, _ as resolveTreeContainer, a as compiledShape, c as debugKey, d as overlaps, f as read$1, g as resolveLocated, h as resolveContainer, i as AddressIndex, j as install, l as memberKey, n as fail, o as contains, p as resolveAddress, r as invalidValue, s as createAddressResolver, t as MutationRejected, v as resolveValue } from "./issue-DVaGQGeP.js";
-import { _ as copyValue, c as input, d as createAccess, f as replace, g as checkValue, h as checkKey, l as observe, m as ParseError, p as snapshot, s as derive, v as equalValue, y as parse } from "./definition-DXrKMVs7.js";
-import { A as variant, C as field, D as optional, E as object, O as table, S as compilePath, T as map, _ as DocumentDisposedError, a as ProjectionError, b as createImpact, c as disposeNotification, f as subscribeRoot, g as readWith, h as bindRuntimeAccess, i as ProjectionDisposedError, k as tree, l as notify, m as accessOf, o as bindDocumentReadable, p as subscribeTargets, s as createNotification, t as createProjectionRuntime, u as shareNotification, v as DocumentReentrancyError, w as list, y as TransactionRejected } from "./store-CtgvCVFg.js";
+import { a as ParseError, c as copyValue, i as snapshot, l as equalValue, n as createAccess, o as checkKey, r as replace, s as checkValue, t as collectionAccess, u as parse } from "./scope-d-L87NeC.js";
+import { _ as affected, a as documentReadableOwner, d as accessOf, f as bindRuntimeAccess, g as TransactionRejected, h as DocumentReentrancyError, i as disposeNotification, l as subscribeRoot, m as DocumentDisposedError, n as bindDocumentReadable, o as notify, p as readWith, r as createNotification, s as shareNotification, t as attachProjection, u as subscribeTargets, v as belongs, y as same } from "./notification-IQIJyH3Q.js";
 import { n as bindRuntimeDriver, o as decodeChanges, r as disposeRuntimeDriver, s as sealChanges, t as assertRuntimeWritable } from "./driver-CSnhMjbP.js";
+import { a as input, i as derive, o as observe, r as definitionOf } from "./definition-c6XQXzvK.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.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/history.ts
 const createHistory = (input) => {
 	let undos = [];
@@ -916,6 +1103,1818 @@ const asReadable = (runtime) => {
 //#region core/src/projection/select.ts
 const read = (runtime, selector) => readWith(runtime, selector);
 //#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 = (impact) => {
+			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.change);
+					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
+let activeTracker;
+const trackKey = (key) => {
+	activeTracker?.keys.add(key);
+};
+const trackStructure = () => {
+	if (!activeTracker) return;
+	activeTracker.structure = true;
+};
+const trackAll = () => {
+	if (!activeTracker) return;
+	activeTracker.all = true;
+};
+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() {
+			trackStructure();
+			return source.size;
+		},
+		keys: () => {
+			trackStructure();
+			return source.keys();
+		},
+		values: () => {
+			trackAll();
+			return source.values();
+		},
+		entries: () => {
+			trackAll();
+			return source.entries();
+		},
+		forEach: (callback, thisArg) => {
+			trackAll();
+			source.forEach((value, key) => callback.call(thisArg, value, key, view));
+		},
+		[Symbol.iterator]: () => {
+			trackAll();
+			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 sameSelection = (left, right) => {
+	if (left.all !== right.all || left.structure !== right.structure || left.keys.size !== right.keys.size) return false;
+	for (const key of left.keys) if (!right.keys.has(key)) return false;
+	return true;
+};
+const selectionAffects = (selection, change) => {
+	if (!change || change.kind === "reset") return true;
+	if (selection.all && (change.added.size || change.removed.size || change.updated.size || change.orderChanged)) return true;
+	if (selection.structure && (change.added.size || change.removed.size || change.orderChanged)) return true;
+	for (const key of selection.keys) if (change.added.has(key) || change.removed.has(key) || change.updated.has(key)) return true;
+	return false;
+};
+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$1(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;
+	};
+	function readable(projection, selector, equality = Object.is) {
+		if (!selector) return Object.freeze({
+			current: () => get(projection),
+			revision: () => materialize(projection).revision(),
+			subscribe: (listener) => materialize(projection).subscribe(listener)
+		});
+		let initialized = false;
+		let value;
+		let selectedRevision = 0;
+		let sourceRevision = -1;
+		let selection = Object.freeze({
+			keys: /* @__PURE__ */ new Set(),
+			all: true,
+			structure: false
+		});
+		let previousCollection;
+		let unsubscribeSource;
+		const listeners = /* @__PURE__ */ new Set();
+		const updateCollectionSnapshot = () => {
+			const current = get(projection);
+			previousCollection = isMapLike(current) ? current : void 0;
+		};
+		const evaluate = () => {
+			const tracker = {
+				keys: /* @__PURE__ */ new Set(),
+				all: false,
+				structure: false
+			};
+			const previousTracker = activeTracker;
+			activeTracker = tracker;
+			let source;
+			let next;
+			try {
+				source = get(projection);
+				next = selector(source);
+			} finally {
+				activeTracker = previousTracker;
+			}
+			const nextSelection = Object.freeze({
+				keys: new Set(tracker.keys),
+				all: tracker.all || isMapLike(source) && tracker.keys.size === 0,
+				structure: tracker.structure
+			});
+			const changed = !initialized || !equality(value, next);
+			if (changed) {
+				if (initialized) selectedRevision++;
+				value = next;
+			}
+			selection = nextSelection;
+			initialized = true;
+			sourceRevision = materialize(projection).revision();
+			updateCollectionSnapshot();
+			return changed;
+		};
+		const ensureCurrent = () => {
+			const revision = materialize(projection).revision();
+			if (!initialized || !unsubscribeSource && sourceRevision !== revision) evaluate();
+			return value;
+		};
+		const onProjectionChange = (incoming) => {
+			let change = incoming;
+			if (!change && previousCollection) {
+				const current = get(projection);
+				if (isMapLike(current)) {
+					change = mapChange(previousCollection, current);
+					previousCollection = current;
+					if (!change) {
+						sourceRevision = materialize(projection).revision();
+						return;
+					}
+				} else previousCollection = void 0;
+			}
+			if (!selectionAffects(selection, change)) {
+				sourceRevision = materialize(projection).revision();
+				updateCollectionSnapshot();
+				return;
+			}
+			const previousSelection = selection;
+			const changed = evaluate();
+			if (unsubscribeSource && !sameSelection(previousSelection, selection)) {
+				unsubscribeSource();
+				unsubscribeSource = materialize(projection).subscribe(onProjectionChange);
+			}
+			if (changed) Array.from(listeners).forEach((listener) => listener());
+		};
+		const installSource = () => {
+			if (!unsubscribeSource) unsubscribeSource = materialize(projection).subscribe(onProjectionChange);
+		};
+		return Object.freeze({
+			current: ensureCurrent,
+			revision: () => {
+				ensureCurrent();
+				return selectedRevision;
+			},
+			subscribe: (listener) => {
+				ensureCurrent();
+				listeners.add(listener);
+				installSource();
+				return () => {
+					listeners.delete(listener);
+					if (!listeners.size && unsubscribeSource) {
+						unsubscribeSource();
+						unsubscribeSource = void 0;
+					}
+				};
+			}
+		});
+	}
+	const store = {
+		get,
+		readable,
+		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
+	};
+	return Object.freeze(store);
+};
+//#endregion
 export { DocumentDisposedError, DocumentReentrancyError, ParseError, ProjectionDisposedError, ProjectionError, TransactionRejected, asReadable, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, snapshot, table, tree, variant };
 
 //# sourceMappingURL=index.js.map