doxum 0.1.4 → 0.1.6

package/dist/runtime-BJRXF0gq.js

@@ -0,0 +1,1735 @@
+import { t as __exportAll } from "./chunk-pbuEa-1d.js";
+import { i as isRecord$1, t as cloneValue, u as profile } from "./ownership-CduRygE7.js";
+//#region core/src/schema.ts
+const node = (value) => Object.freeze(value);
+const field = () => node({ kind: "field" });
+const optional = (value) => node({
+	...value,
+	optional: true
+});
+const object = (shape) => node({
+	kind: "object",
+	shape
+});
+const variant = (tag, variants) => node({
+	kind: "variant",
+	tag,
+	variants
+});
+const single = (value) => node({
+	kind: "single",
+	value
+});
+const table = (value) => node({
+	kind: "table",
+	value
+});
+const map = (value) => node({
+	kind: "map",
+	value
+});
+const record = () => node({ kind: "record" });
+const dict = () => node({ kind: "dict" });
+const list = (config) => ({
+	kind: "list",
+	keyOf: config.keyOf
+});
+const tree = () => node({ kind: "tree" });
+const pathProxy = (address) => new Proxy({ address }, { get: (_target, property) => {
+	if (property === "address") return address;
+	if (property === "item") return (id) => pathProxy([...address, id]);
+	if (typeof property === "symbol") return void 0;
+	return pathProxy([...address, property]);
+} });
+const select = (owner, kind, pick) => {
+	const selected = pick(pathProxy([]));
+	return Object.freeze({
+		kind,
+		schema: owner,
+		address: Object.freeze([...selected.address ?? []])
+	});
+};
+const schema = (shape) => {
+	const result = {
+		kind: "schema",
+		shape,
+		collection: (pick) => select(result, "collection", pick),
+		value: (pick) => select(result, "value", pick)
+	};
+	return Object.freeze(result);
+};
+//#endregion
+//#region core/src/address.ts
+const registries = /* @__PURE__ */ new WeakMap();
+const registryNode = () => ({ static: /* @__PURE__ */ new Map() });
+const registryFor = (schema) => {
+	const cached = registries.get(schema);
+	if (cached) return cached;
+	const registry = {
+		root: registryNode(),
+		nextPath: 0
+	};
+	registries.set(schema, registry);
+	return registry;
+};
+const hashText = (value, seed) => {
+	let hash = seed;
+	for (let index = 0; index < value.length; index += 1) hash = Math.imul(hash ^ value.charCodeAt(index), 16777619);
+	return hash >>> 0;
+};
+const appendAddressHash = (hash, segment) => hashText(segment, hashText("/", hash));
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const unwrap = (node) => {
+	let current = node;
+	while (current?.kind === "single") current = current.value;
+	return current;
+};
+const variantNode = (node, value) => {
+	const tag = isRecord(value) && typeof value[node.tag] === "string" ? value[node.tag] : void 0;
+	return node.variants[String(tag ?? Object.keys(node.variants)[0] ?? "")];
+};
+const schemaRoot$1 = (schema) => ({
+	kind: "object",
+	shape: schema.shape
+});
+const step = (nodeInput, value, segment) => {
+	let node = unwrap(nodeInput);
+	if (!node) return {
+		node: void 0,
+		dynamic: false
+	};
+	if (node.kind === "variant") node = unwrap(variantNode(node, value));
+	if (!node) return {
+		node: void 0,
+		dynamic: false
+	};
+	if (node.kind === "object") return {
+		node: node.shape[segment],
+		dynamic: false
+	};
+	if (node.kind === "table" || node.kind === "map") return {
+		node: node.value,
+		dynamic: true
+	};
+	if (node.kind === "record" || node.kind === "dict" || node.kind === "list" || node.kind === "tree") return {
+		node,
+		dynamic: true
+	};
+	return {
+		node: void 0,
+		dynamic: false
+	};
+};
+const pathFor = (schema, address, document) => {
+	const registry = registryFor(schema);
+	let trie = registry.root;
+	let node = schemaRoot$1(schema);
+	let value = document;
+	for (const segment of address) {
+		profile.address.schemaStep();
+		profile.address.documentStep();
+		const resolved = step(node, value, segment);
+		if (!resolved.node) return void 0;
+		trie = resolved.dynamic ? trie.dynamic ??= registryNode() : (() => {
+			const existing = trie.static.get(segment);
+			if (existing) return existing;
+			const created = registryNode();
+			trie.static.set(segment, created);
+			return created;
+		})();
+		node = resolved.node;
+		value = readSegment(value, segment);
+	}
+	if (trie.path === void 0) trie.path = registry.nextPath++;
+	return trie.path;
+};
+const resolveAddress = (schema, address, document) => {
+	if (!Array.isArray(address)) return void 0;
+	for (const segment of address) if (typeof segment !== "string") return void 0;
+	profile.address.arrayCopied();
+	const owned = Object.freeze(address.slice());
+	const path = pathFor(schema, owned, document);
+	return path === void 0 ? void 0 : {
+		path,
+		address: owned
+	};
+};
+const nodeAt = (schema, address, document) => {
+	let node = schemaRoot$1(schema);
+	let value = document;
+	for (const segment of address) {
+		node = step(node, value, segment).node;
+		value = readSegment(value, segment);
+		if (!node) return void 0;
+	}
+	return unwrap(node);
+};
+const readSegment = (value, segment) => {
+	if (!isRecord(value) && !Array.isArray(value)) return void 0;
+	if (isRecord(value) && "byId" in value && isRecord(value.byId)) {
+		const entity = value.byId[segment];
+		if (entity !== void 0 || Object.prototype.hasOwnProperty.call(value.byId, segment)) return entity;
+	}
+	return value[segment];
+};
+const read = (root, address) => {
+	let value = root;
+	for (const segment of address) {
+		value = readSegment(value, segment);
+		if (value === void 0) return void 0;
+	}
+	return value;
+};
+/** Resolves schema and document location in one address traversal. */
+const resolveLocated = (schema, root, address) => {
+	if (address.length === 0) return void 0;
+	let node = schemaRoot$1(schema);
+	let current = root;
+	let collection;
+	let addressHash = 2166136261;
+	for (let index = 0; index < address.length - 1; index += 1) {
+		profile.address.schemaStep();
+		profile.address.documentStep();
+		const resolved = step(node, current, address[index]);
+		if (!resolved.node) return void 0;
+		if (node?.kind === "table" || node?.kind === "map") collection = {
+			address: address.slice(0, index),
+			addressHash,
+			id: address[index],
+			...collection ? { parent: collection } : {}
+		};
+		addressHash = appendAddressHash(addressHash, address[index]);
+		node = resolved.node;
+		current = readSegment(current, address[index]);
+		if (!node) return void 0;
+	}
+	profile.address.schemaStep();
+	profile.address.documentStep();
+	const last = address[address.length - 1];
+	const resolved = step(node, current, last);
+	if (!resolved.node || !isRecord(current) && !Array.isArray(current)) return void 0;
+	if (node?.kind === "table" || node?.kind === "map") collection = {
+		address: address.slice(0, -1),
+		addressHash,
+		id: last,
+		...collection ? { parent: collection } : {}
+	};
+	addressHash = appendAddressHash(addressHash, last);
+	if (isRecord(current) && "byId" in current && isRecord(current.byId) && last in current.byId) return {
+		addressHash,
+		node: resolved.node,
+		parent: current.byId,
+		key: last,
+		value: current.byId[last],
+		...collection ? { collection } : {}
+	};
+	return {
+		addressHash,
+		node: resolved.node,
+		parent: current,
+		key: Array.isArray(current) && /^\d+$/.test(last) ? Number(last) : last,
+		value: readSegment(current, last),
+		...collection ? { collection } : {}
+	};
+};
+const locate = (root, address) => {
+	if (address.length === 0) return void 0;
+	let current = root;
+	for (let index = 0; index < address.length - 1; index += 1) current = readSegment(current, address[index]);
+	if (!isRecord(current) && !Array.isArray(current)) return void 0;
+	const last = address[address.length - 1];
+	if (isRecord(current) && "byId" in current && isRecord(current.byId) && last in current.byId) return {
+		parent: current.byId,
+		key: last,
+		value: current.byId[last]
+	};
+	return {
+		parent: current,
+		key: Array.isArray(current) && /^\d+$/.test(last) ? Number(last) : last,
+		value: readSegment(current, last)
+	};
+};
+const set = (root, address, value) => {
+	const target = locate(root, address);
+	if (!target) return false;
+	target.parent[target.key] = value;
+	return true;
+};
+const contains = (parent, child) => {
+	profile.address.prefixComparison();
+	if (parent.length > child.length) return false;
+	for (let index = 0; index < parent.length; index += 1) {
+		profile.address.segmentCompared();
+		if (parent[index] !== child[index]) return false;
+	}
+	return true;
+};
+const overlaps = (a, b) => contains(a, b) || contains(b, a);
+const debugKey = (address) => {
+	let result = "";
+	for (let index = 0; index < address.length; index += 1) {
+		if (index > 0) result += "/";
+		result += address[index].replaceAll("~", "~~").replaceAll("/", "~/");
+	}
+	return result;
+};
+//#endregion
+//#region core/src/impact-target.ts
+var impact_target_exports = /* @__PURE__ */ __exportAll({
+	address: () => address,
+	belongs: () => belongs,
+	bucket: () => bucket,
+	id: () => id,
+	same: () => same
+});
+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 bucket = (target) => address(target)[0];
+//#endregion
+//#region core/src/access/reader.ts
+const schemaRoot = (schema) => object(schema.shape);
+const assertActive = (context) => {
+	if (!context.active()) throw new Error("Document reader is no longer active.");
+};
+const readAt = (context, address) => {
+	assertActive(context);
+	profile.reader.lookup();
+	return read(context.root(), address);
+};
+const collectValue = (context, address) => {
+	context.dependencies?.record({
+		kind: "value",
+		at: address
+	});
+};
+const collectCollection = (context, address, id) => {
+	const target = {
+		kind: "collection",
+		at: address,
+		...id === void 0 ? {} : { id }
+	};
+	context.dependencies?.record(target);
+};
+const readerFor = (node, context, address = []) => {
+	if (node.kind === "field") return { get: () => {
+		collectValue(context, address);
+		return readAt(context, address);
+	} };
+	if (node.kind === "dict" || node.kind === "record") return { get: () => {
+		collectValue(context, address);
+		profile.reader.structuralSnapshot();
+		return cloneValue(readAt(context, address), "reader");
+	} };
+	if (node.kind === "list") return {
+		values: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(Array.isArray(value) ? value : [], "reader");
+		},
+		length: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return Array.isArray(value) ? value.length : 0;
+		},
+		at: (index) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(Array.isArray(value) ? value[index] : void 0, "reader");
+		}
+	};
+	if (node.kind === "tree") return {
+		rootId: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return isRecord$1(value) && typeof value.rootId === "string" ? value.rootId : void 0;
+		},
+		has: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return isRecord$1(value) && isRecord$1(value.nodes) && Object.prototype.hasOwnProperty.call(value.nodes, id);
+		},
+		value: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(isRecord$1(value) && isRecord$1(value.nodes) && isRecord$1(value.nodes[id]) ? value.nodes[id].value : void 0, "reader");
+		},
+		parent: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			const entry = isRecord$1(value) && isRecord$1(value.nodes) ? value.nodes[id] : void 0;
+			return isRecord$1(entry) && typeof entry.parentId === "string" ? entry.parentId : void 0;
+		},
+		children: (id) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			const entry = isRecord$1(value) && isRecord$1(value.nodes) ? value.nodes[id] : void 0;
+			return isRecord$1(entry) && Array.isArray(entry.children) ? [...entry.children] : [];
+		}
+	};
+	if (node.kind === "table" || node.kind === "map") {
+		let items;
+		return {
+			ids: () => {
+				collectCollection(context, address);
+				const value = readAt(context, address);
+				const ids = node.kind === "table" && isRecord$1(value) && Array.isArray(value.ids) ? [...value.ids] : isRecord$1(value) ? Object.keys(value) : [];
+				profile.reader.collectionIds(ids.length);
+				return ids;
+			},
+			has: (id) => {
+				collectCollection(context, address, id);
+				const value = readAt(context, address);
+				const byId = node.kind === "table" && isRecord$1(value) && isRecord$1(value.byId) ? value.byId : value;
+				return isRecord$1(byId) && Object.prototype.hasOwnProperty.call(byId, id);
+			},
+			get: (id) => {
+				collectCollection(context, address, id);
+				const value = readAt(context, address);
+				const byId = node.kind === "table" && isRecord$1(value) && isRecord$1(value.byId) ? value.byId : value;
+				if (!isRecord$1(byId) || !Object.prototype.hasOwnProperty.call(byId, id)) return void 0;
+				const cached = items?.get(id);
+				if (cached) return cached;
+				const reader = readerFor(node.value, context, [...address, id]);
+				(items ??= /* @__PURE__ */ new Map()).set(id, reader);
+				return reader;
+			}
+		};
+	}
+	if (node.kind === "single") return readerFor(node.value, context, address);
+	if (node.kind === "variant") return new Proxy({}, { get: (_target, property) => {
+		if (typeof property === "symbol") return void 0;
+		const value = readAt(context, address);
+		const tag = isRecord$1(value) && typeof value[node.tag] === "string" ? String(value[node.tag]) : void 0;
+		const child = (tag ? node.variants[tag] : void 0)?.shape[property];
+		return child ? readerFor(child, context, [...address, property]) : void 0;
+	} });
+	let children;
+	return new Proxy({}, { get: (_target, property) => {
+		if (typeof property === "symbol") return void 0;
+		const child = node.shape[property];
+		if (!child) return void 0;
+		const cached = children?.get(property);
+		if (cached) return cached;
+		const reader = readerFor(child, context, [...address, property]);
+		(children ??= /* @__PURE__ */ new Map()).set(property, reader);
+		return reader;
+	} });
+};
+const documentReader = (schema, root, active, dependencies) => {
+	profile.reader.session();
+	return readerFor(schemaRoot(schema), {
+		root,
+		active,
+		dependencies
+	});
+};
+//#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";
+	}
+};
+//#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();
+	let active = true;
+	const reader = documentReader(state.schema, () => state.document, () => active, dependencies);
+	try {
+		return run(reader);
+	} finally {
+		active = false;
+	}
+};
+//#endregion
+//#region core/src/runtime/notification.ts
+const ROOT_BUCKET = Symbol("document-root");
+const notifications = /* @__PURE__ */ new WeakMap();
+const key = (value) => bucket(value) ?? ROOT_BUCKET;
+const createNotification = (runtime) => {
+	const notification = {
+		root: /* @__PURE__ */ new Set(),
+		filtered: /* @__PURE__ */ new Set(),
+		buckets: /* @__PURE__ */ new Map(),
+		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);
+	};
+};
+const subscribeTargets = (notification, targets, listener) => {
+	const entry = {
+		targets: Object.freeze(targets.slice()),
+		listener,
+		active: true
+	};
+	notification.filtered.add(entry);
+	const keys = new Set(targets.map(key));
+	keys.forEach((key) => {
+		const bucket = notification.buckets.get(key) ?? /* @__PURE__ */ new Set();
+		bucket.add(entry);
+		notification.buckets.set(key, bucket);
+	});
+	return () => {
+		if (!entry.active) return;
+		entry.active = false;
+		if (notification.notifying) return;
+		notification.filtered.delete(entry);
+		keys.forEach((key) => {
+			const bucket = notification.buckets.get(key);
+			bucket?.delete(entry);
+			if (bucket?.size === 0) notification.buckets.delete(key);
+		});
+	};
+};
+const notify = (notification, commit) => {
+	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
+				}));
+			}
+		}
+		const candidates = notification.candidates;
+		candidates.clear();
+		if (commit.impact.kind === "reset") notification.filtered.forEach((entry) => candidates.add(entry));
+		else for (const operation of commit.operations) {
+			const key = operation.at[0] ?? ROOT_BUCKET;
+			notification.buckets.get(key)?.forEach((entry) => candidates.add(entry));
+			notification.buckets.get(ROOT_BUCKET)?.forEach((entry) => candidates.add(entry));
+		}
+		candidates.forEach((entry) => {
+			if (entry.active && entry.targets.some(commit.impact.affects)) 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.root.forEach((entry) => {
+			if (!entry.active) notification.root.delete(entry);
+		});
+		notification.filtered.forEach((entry) => {
+			if (!entry.active) notification.filtered.delete(entry);
+		});
+		notification.buckets.forEach((bucket, key) => {
+			bucket.forEach((entry) => {
+				if (!entry.active) bucket.delete(entry);
+			});
+			if (bucket.size === 0) notification.buckets.delete(key);
+		});
+	}
+	return Object.freeze(errors);
+};
+const disposeNotification = (notification) => {
+	const attachments = notification.processors.slice();
+	notification.root.clear();
+	notification.filtered.clear();
+	notification.buckets.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 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;
+	};
+	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(callback) {
+			assertIdle();
+			depth++;
+			let failed = false;
+			try {
+				const value = callback();
+				assertSynchronous(value);
+				return value;
+			} catch (error) {
+				failed = true;
+				throw error;
+			} finally {
+				depth--;
+				if (!depth) if (failed) try {
+					run();
+				} catch {}
+				else run();
+			}
+		},
+		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/source.ts
+const createSources = (scheduler) => {
+	const documents = /* @__PURE__ */ new Map();
+	const readables = /* @__PURE__ */ new Map();
+	const collections = /* @__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 = [];
+		const make = (targets, 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 = [];
+			const record = {
+				consumers: /* @__PURE__ */ new Set(),
+				disposed: false,
+				fault: void 0,
+				revision: runtime.revision,
+				reset: () => commits.some((commit) => commit.kind === "replace"),
+				clear: () => {
+					commits = [];
+				},
+				context: (active) => {
+					assertScope(active);
+					if (state.disposed) throw new Error("Document has been disposed.");
+					const read = collection ? readerFor(nodeAt(state.schema, collection.address), {
+						root: () => state.document,
+						active
+					}, collection.address) : documentReader(state.schema, () => state.document, active);
+					return Object.freeze({
+						read,
+						target: collection,
+						revision: runtime.revision(),
+						commits: Object.freeze(commits.slice()),
+						reset: record.reset()
+					});
+				}
+			};
+			const handle = collection ? {} : {
+				collection: (pick) => {
+					scheduler.assertIdle();
+					const selector = state.schema.collection(pick);
+					const node = nodeAt(state.schema, selector.address);
+					if (node?.kind !== "table" && node?.kind !== "map") throw new TypeError("Expected a table or map collection path.");
+					return make([selector], selector);
+				},
+				targets: (...selected) => {
+					scheduler.assertIdle();
+					if (!selected.length) throw new TypeError("Expected at least one target.");
+					return make(selected);
+				}
+			};
+			Object.freeze(handle);
+			bindings.push({
+				handle,
+				targets,
+				record
+			});
+			if (collection) collections.set(handle, {
+				source: handle,
+				target: collection
+			});
+			scheduler.register(handle, record);
+			receivers.set(record, (commit) => {
+				commits.push(commit);
+			});
+			return handle;
+		};
+		const receivers = /* @__PURE__ */ new Map();
+		const handle = make([]);
+		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(commit.impact.affects)) {
+					receivers.get(binding.record)(commit);
+					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;
+		const handle = Object.freeze({});
+		const record = {
+			consumers: /* @__PURE__ */ new Set(),
+			disposed: false,
+			fault: void 0,
+			revision: () => revision,
+			reset: () => false,
+			clear: () => {
+				previous = value;
+			},
+			context: (active) => {
+				assertScope(active);
+				return Object.freeze({
+					value,
+					previous,
+					revision,
+					changed: !equal(previous, value),
+					reset: false
+				});
+			}
+		};
+		scheduler.register(handle, record);
+		const accept = (next) => {
+			scheduler.assertIdle();
+			const recovering = record.fault !== void 0;
+			if (equal(value, next) && !recovering) return;
+			record.fault = void 0;
+			value = next;
+			revision++;
+			scheduler.capture(record);
+		};
+		return {
+			source: handle,
+			accept,
+			set(next) {
+				accept(next);
+				scheduler.run();
+			}
+		};
+	};
+	return {
+		dispose: () => {
+			documents.clear();
+			readables.clear();
+		},
+		document,
+		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 old = readables.get(readable);
+			if (old) return old;
+			const input = valueSource(readable.current(), options?.isEqual ?? Object.is);
+			const receive = () => {
+				if (!scheduler.active) return;
+				try {
+					input.accept(readable.current());
+				} catch (cause) {
+					const record = scheduler.source(input.source);
+					record.fault = new ProjectionError("source", "external readable", [readable.revision()], cause);
+					scheduler.capture(record);
+				}
+				scheduler.run();
+			};
+			let unsubscribe;
+			try {
+				unsubscribe = readable.subscribe(receive);
+				input.accept(readable.current());
+			} catch (error) {
+				try {
+					unsubscribe?.();
+				} finally {
+					scheduler.unregisterSource(input.source);
+				}
+				throw error;
+			}
+			scheduler.cleanups.add(unsubscribe);
+			readables.set(readable, input.source);
+			scheduler.run();
+			return input.source;
+		},
+		collectionTarget: (handle) => {
+			scheduler.source(handle);
+			const value = collections.get(handle);
+			if (!value) throw new Error("map requires a document collection source.");
+			return value.target;
+		}
+	};
+};
+//#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 inputs = Object.fromEntries(entries.map(([key, source]) => [key, source.context(() => active)]));
+				return behavior.evaluate(inputs, build, () => active);
+			} 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/value.ts
+const createValue = (scheduler, spec) => {
+	let instance;
+	let value;
+	let next;
+	let previous;
+	let initialized = false;
+	let revision = 0;
+	let changed = false;
+	let reset = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const owner = createNode(scheduler, spec, {
+		evaluate: (sources, build) => {
+			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 || !(spec.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
+			});
+		},
+		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;
+		},
+		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/collection.ts
+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 all;
+	const itemVersions = /* @__PURE__ */ new Map();
+	const items = /* @__PURE__ */ new Map();
+	const itemListeners = /* @__PURE__ */ new Map();
+	const idsListeners = /* @__PURE__ */ new Set();
+	const allListeners = /* @__PURE__ */ new Set();
+	const listeners = /* @__PURE__ */ new Set();
+	const changedKeys = /* @__PURE__ */ new Set();
+	let orderChanged = false;
+	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) => {
+			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);
+			}
+			reset = build;
+			return change !== void 0;
+		},
+		context: (active) => {
+			const input = {
+				get: (key) => {
+					assertScope(active);
+					return getNext(key);
+				},
+				has: (key) => {
+					assertScope(active);
+					return hasNext(key);
+				},
+				ids: () => {
+					assertScope(active);
+					return nextIds;
+				},
+				change,
+				revision: revision + (change ? 1 : 0),
+				reset
+			};
+			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) => {
+					if (items.has(key)) itemVersions.set(key, (itemVersions.get(key) ?? 0) + (initialized ? 1 : 0));
+				});
+			}
+			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));
+			const keys = !change || fault || owner.node.statusChanged ? itemListeners.keys() : changedKeys;
+			for (const key of keys) Array.from(itemListeners.get(key) ?? []).forEach((listener) => call(listener));
+		},
+		clear: () => {
+			staged.clear();
+			nextIds = ids;
+			change = void 0;
+			reset = false;
+			changedKeys.clear();
+			orderChanged = false;
+		},
+		release: () => {
+			values.clear();
+			staged.clear();
+			items.clear();
+			itemVersions.clear();
+			itemListeners.clear();
+			idsListeners.clear();
+			allListeners.clear();
+			listeners.clear();
+			ids = nextIds = Object.freeze([]);
+			all = void 0;
+			instance = void 0;
+		}
+	});
+	const handle = {
+		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;
+			itemVersions.set(key, 0);
+			const readable = Object.freeze({
+				current: () => {
+					owner.check();
+					return values.get(key);
+				},
+				revision: () => {
+					owner.check();
+					return itemVersions.get(key) ?? 0;
+				},
+				subscribe: (listener) => {
+					owner.check();
+					const set = itemListeners.get(key) ?? /* @__PURE__ */ new Set();
+					set.add(listener);
+					itemListeners.set(key, set);
+					return () => {
+						set.delete(listener);
+						if (!set.size) itemListeners.delete(key);
+					};
+				}
+			});
+			projectionHandles.add(readable);
+			items.set(key, readable);
+			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);
+	owner.install(handle);
+	return Object.freeze(handle);
+};
+//#endregion
+//#region core/src/projection/runtime.ts
+const debug = /* @__PURE__ */ new WeakMap();
+const projectionDebug = (runtime) => {
+	const read = debug.get(runtime);
+	if (!read) throw new Error("Unknown projection runtime.");
+	return Object.freeze(read());
+};
+const createProjectionRuntime = (options) => {
+	const scheduler = createScheduler(options.onError);
+	const sources = createSources(scheduler);
+	const runtime = {
+		document: sources.document,
+		input: sources.input,
+		fromReadable: sources.fromReadable,
+		value: (spec) => createValue(scheduler, spec),
+		collection: (spec) => createCollection(scheduler, spec),
+		map: (source, mapper, options) => {
+			sources.collectionTarget(source);
+			return createCollection(scheduler, {
+				sources: { source },
+				isEqual: options?.isEqual,
+				build: ({ sources, writer }) => {
+					const ids = sources.source.read.ids();
+					profile.collectionView.idsScanned(ids.length);
+					for (const id of ids) {
+						profile.collectionView.mapped();
+						writer.set(id, mapper(id, sources.source.read.get(id)));
+					}
+					writer.order(ids);
+					return { update: ({ sources, writer }) => {
+						const input = sources.source;
+						const keys = /* @__PURE__ */ new Set();
+						let structural = false;
+						for (const commit of input.commits) {
+							const impact = commit.impact.collection(input.target);
+							if (impact.kind === "reset") return { kind: "rebuild" };
+							impact.added.forEach((key) => keys.add(key));
+							impact.removed.forEach((key) => keys.add(key));
+							impact.updated.forEach((key) => keys.add(key));
+							structural ||= Boolean(impact.added.size || impact.removed.size || impact.orderChanged);
+						}
+						for (const key of keys) {
+							const entry = input.read.get(key);
+							if (!entry) writer.remove(key);
+							else {
+								profile.collectionView.mapped();
+								writer.set(key, mapper(key, entry));
+							}
+						}
+						if (structural) {
+							const ids = input.read.ids();
+							profile.collectionView.idsScanned(ids.length);
+							writer.order(ids);
+						}
+					} };
+				}
+			});
+		},
+		batch: scheduler.batch,
+		dispose: () => {
+			try {
+				scheduler.dispose();
+			} finally {
+				if (!scheduler.active) sources.dispose();
+			}
+		}
+	};
+	debug.set(runtime, scheduler.debug);
+	return Object.freeze(runtime);
+};
+//#endregion
+export { dict as A, tree as B, debugKey as C, resolveAddress as D, read as E, optional as F, record as I, schema as L, list as M, map as N, resolveLocated as O, object as P, single as R, contains as S, overlaps as T, variant as V, address as _, createNotification as a, impact_target_exports as b, shareNotification as c, accessOf as d, bindRuntimeAccess as f, documentReader as g, DocumentReentrancyError as h, ProjectionError as i, field as j, set as k, subscribeRoot as l, DocumentDisposedError as m, projectionDebug as n, disposeNotification as o, readWith as p, ProjectionDisposedError as r, notify as s, createProjectionRuntime as t, subscribeTargets as u, belongs as v, locate as w, same as x, id as y, table as z };
+
+//# sourceMappingURL=runtime-BJRXF0gq.js.map