doxum 0.1.7 → 0.1.9

package/dist/store-D7QH6Rzw.js

@@ -0,0 +1,2511 @@
+import { A as insert$2, C as validate, D as equal, E as afterRemove, I as valid, L as profile, M as keys, O as index, P as move$2, T as isRecord, a as compiledShape, b as contains, g as resolveLocated, i as AddressIndex, k as indexedKeys, m as resolveChild, n as fail, o as contains$1, u as nodeAt, w as isPlainObject, x as parent, y as children } from "./issue-DVaGQGeP.js";
+//#region core/src/schema-value.ts
+var ParseError = class extends TypeError {
+	issues;
+	constructor(issue) {
+		super(`${issue.message} at ${JSON.stringify(issue.address)}`);
+		this.name = "ParseError";
+		this.issues = Object.freeze([Object.freeze({
+			...issue,
+			address: Object.freeze([...issue.address])
+		})]);
+	}
+};
+const issue = (address, message, code = "invalid-value") => ({
+	address,
+	message,
+	code
+});
+const checkScalar = (validator, value, address, strict) => {
+	if (!validator) return strict ? issue(address, "A validator is required to parse an opaque value.", "missing-validator") : void 0;
+	try {
+		const result = typeof validator === "function" ? validator(value) : validator["~standard"].validate(value);
+		if (result && (typeof result === "object" || typeof result === "function") && "then" in result && typeof result.then === "function") return issue(address, "Validators must be synchronous.");
+		if (typeof validator !== "function") {
+			if (!isRecord(result)) return issue(address, "Malformed validator result.");
+			if (Array.isArray(result.issues)) {
+				const first = result.issues[0];
+				return issue([...address, ...(first?.path ?? []).map((part) => String(typeof part === "object" ? part.key : part))], first?.message ?? "Value validation failed.");
+			}
+			if (!Object.hasOwn(result, "value")) return issue(address, "Malformed validator result.");
+		}
+		return;
+	} catch (error) {
+		return issue(address, error instanceof Error ? error.message : "Value validation failed.");
+	}
+};
+const checkKey = (validator, value, address) => {
+	if (typeof value !== "string") return issue(address, "Collection keys must be strings.", "invalid-key");
+	const failure = checkScalar(validator, value, address, false);
+	return failure ? {
+		...failure,
+		code: "invalid-key"
+	} : void 0;
+};
+const checkValue = (node, value, address = [], strict = false) => {
+	if (node.optional && value === void 0) return void 0;
+	if (node.kind === "field") return checkScalar(node.validator, value, address, strict);
+	if (node.kind === "object" || node.kind === "variant") {
+		if (!isPlainObject(value)) return issue(address, "Expected an object.");
+		if (node.kind === "variant") {
+			const tag = value[node.tag];
+			if (!Object.hasOwn(value, node.tag) || typeof tag !== "string" || !Object.hasOwn(node.variants, tag)) return issue([...address, node.tag], "Unknown variant tag.");
+		}
+		const { members } = compiledShape(node, value);
+		for (const key of Reflect.ownKeys(value)) {
+			if (node.kind === "variant" && key === node.tag) continue;
+			if (typeof key !== "string" || !members.has(key)) return issue([...address, String(key)], "Property is not declared in the object schema.");
+		}
+		for (const [key, member] of members) {
+			const child = member.node;
+			if (!Object.prototype.hasOwnProperty.call(value, key) && !child.optional) return issue([...address, key], "Required property is missing.");
+			const failure = checkValue(child, value[key], [...address, key], strict);
+			if (failure) return failure;
+		}
+		return;
+	}
+	if (node.kind === "table" || node.kind === "map") {
+		if (!isPlainObject(value)) return issue(address, "Expected a collection object.");
+		const entries = node.kind === "table" ? value.byId : value;
+		if (!isPlainObject(entries)) return issue(address, "Expected a byId object.");
+		if (node.kind === "table") {
+			if (!Array.isArray(value.ids) || value.ids.length !== Object.keys(entries).length) return issue(address, "Table ids and entries must agree.");
+			const seen = /* @__PURE__ */ new Set();
+			for (const id of value.ids) {
+				const failure = checkKey(node.key, id, address);
+				if (failure) return failure;
+				if (seen.has(id) || !Object.prototype.hasOwnProperty.call(entries, id)) return issue(address, "Table ids must be unique and reference existing entries.");
+				seen.add(id);
+			}
+		}
+		for (const id of Object.keys(entries)) {
+			const failure = checkKey(node.key, id, [...address, id]) ?? checkValue(node.value, entries[id], [...address, id], strict);
+			if (failure) return failure;
+		}
+		return;
+	}
+	if (node.kind === "list") {
+		if (!Array.isArray(value)) return issue(address, "Expected a list.");
+		const seen = /* @__PURE__ */ new Set();
+		const order = keys(value, node.keyOf);
+		for (let i = 0; i < value.length; i++) {
+			const failure = checkValue(node.value, value[i], [...address, String(i)], strict);
+			if (failure) return failure;
+			let key;
+			try {
+				key = order.at(i);
+			} catch {
+				return issue(address, "List keyOf failed.");
+			}
+			if (typeof key !== "string" || seen.has(key)) return issue(address, "List keys must be unique strings.", "invalid-key");
+			seen.add(key);
+		}
+		return;
+	}
+	if (!validate(value)) return issue(address, "Invalid tree structure.", "invalid-tree");
+	if (isRecord(value) && isRecord(value.nodes)) for (const id of Object.keys(value.nodes)) {
+		const entry = value.nodes[id];
+		if (isRecord(entry) && Object.prototype.hasOwnProperty.call(entry, "value")) {
+			const failure = checkValue(node.value, entry.value, [...address, id], strict);
+			if (failure) return failure;
+		}
+	}
+};
+/** Copy editable structure; atomic payloads retain their immutable ownership contract. */
+const copyValue = (node, value) => {
+	if (value === void 0 || node.kind === "field") return value;
+	profile.copy.structure();
+	if ((node.kind === "object" || node.kind === "variant") && isRecord(value)) {
+		const result = Object.create(Object.getPrototypeOf(value));
+		const { members } = compiledShape(node, value);
+		for (const key of Object.getOwnPropertyNames(value)) Object.defineProperty(result, key, {
+			value: node.kind === "variant" && key === node.tag ? value[key] : copyValue(members.get(key).node, value[key]),
+			writable: true,
+			enumerable: Object.getOwnPropertyDescriptor(value, key)?.enumerable,
+			configurable: true
+		});
+		return result;
+	}
+	if ((node.kind === "table" || node.kind === "map") && isRecord(value)) {
+		const entries = node.kind === "table" ? value.byId : value;
+		const result = Object.fromEntries(Object.keys(entries).map((id) => [id, copyValue(node.value, entries[id])]));
+		return node.kind === "table" ? {
+			ids: [...value.ids],
+			byId: result
+		} : result;
+	}
+	if (node.kind === "list") return [...value];
+	if (node.kind === "tree" && isRecord(value)) {
+		const entries = value.nodes;
+		return {
+			...value,
+			nodes: Object.fromEntries(Object.entries(entries).map(([id, n]) => [id, {
+				...n,
+				children: [...n.children]
+			}]))
+		};
+	}
+	return value;
+};
+const equalValue = (node, left, right) => {
+	if (Object.is(left, right)) return true;
+	if (node.kind === "field" || left === void 0 || right === void 0) return false;
+	if ((node.kind === "object" || node.kind === "variant") && isRecord(left) && isRecord(right)) {
+		if (node.kind === "variant" && left[node.tag] !== right[node.tag]) return false;
+		for (const [key, member] of compiledShape(node, left).members) {
+			if (Object.hasOwn(left, key) !== Object.hasOwn(right, key)) return false;
+			if (!equalValue(member.node, left[key], right[key])) return false;
+		}
+		return true;
+	}
+	if (node.kind === "list" && Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((v, i) => equalValue(node.value, v, right[i]));
+	if (node.kind === "table" && isRecord(left) && isRecord(right)) return equal(left.ids, right.ids) && equalValue({
+		kind: "map",
+		value: node.value
+	}, left.byId, right.byId);
+	if (node.kind === "tree" && isRecord(left) && isRecord(right)) {
+		if (left.rootId !== right.rootId) return false;
+		const a = left.nodes, b = right.nodes;
+		return Object.keys(a).length === Object.keys(b).length && Object.keys(a).every((id) => Object.hasOwn(b, id) && a[id].parentId === b[id].parentId && equal(a[id].children, b[id].children) && Object.hasOwn(a[id], "value") === Object.hasOwn(b[id], "value") && equalValue(node.value, a[id].value, b[id].value));
+	}
+	if (node.kind === "map" && isRecord(left) && isRecord(right)) {
+		const keys = Object.keys(left);
+		return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && equalValue(node.value, left[key], right[key]));
+	}
+	return false;
+};
+const parse = (node, input) => {
+	const valueNode = node;
+	const failure = checkValue(valueNode, input, [], true);
+	if (failure) throw new ParseError(failure);
+	return copyValue(valueNode, input);
+};
+//#endregion
+//#region core/src/schema.ts
+const node$1 = (value) => Object.freeze(value);
+const field = (validator) => node$1({
+	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$1({
+		...value,
+		optional: true
+	});
+};
+const object = (shape) => node$1({
+	kind: "object",
+	shape: Object.freeze({ ...shape })
+});
+const variant = (tag, variants) => node$1({
+	kind: "variant",
+	tag,
+	variants: Object.freeze({ ...variants })
+});
+const table = (value, options) => node$1({
+	kind: "table",
+	value,
+	...options
+});
+const map = (value, options) => node$1({
+	kind: "map",
+	value,
+	...options
+});
+const list = (value, config) => node$1({
+	kind: "list",
+	keyOf: config.keyOf,
+	value
+});
+const tree = (value) => node$1({
+	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/mutation/operations/table.ts
+function create(session, container, entries, position) {
+	const { at, node, value } = container;
+	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
+	const table = value;
+	if (!valid(table.ids, position)) return fail(at, "invalid-anchor", "Unknown table anchor.");
+	const ids = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (Object.hasOwn(table.byId, entry.id) || ids.has(entry.id)) return fail(at, "duplicate-entity", "Table key already exists.");
+		ids.add(entry.id);
+	}
+	if (!entries.length) return;
+	const index$1 = index(table.ids, position);
+	for (const entry of entries) session.writeMember(container, entry.id, entry.value, "set");
+	const length = table.ids.length;
+	table.ids.length += entries.length;
+	table.ids.copyWithin(index$1 + entries.length, index$1, length);
+	for (let i = 0; i < entries.length; i++) table.ids[index$1 + i] = entries[i].id;
+}
+function remove$2(session, container, ids) {
+	const { at, node, value } = container;
+	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
+	const table = value;
+	for (const id of ids) if (!Object.hasOwn(table.byId, id)) return fail(at, "missing-entity", "Table key does not exist.");
+	if (!ids.length) return;
+	const removed = new Set(ids);
+	for (const id of removed) session.writeMember(container, id, void 0, "remove");
+	table.ids = table.ids.filter((id) => !removed.has(id));
+}
+//#endregion
+//#region core/src/mutation/operations/list.ts
+function insert$1(session, container, value, position) {
+	const { at, node, value: current } = container;
+	if (node.kind !== "list") return fail(at, "invalid-list-key", "Expected a list.");
+	session.validate(node.value, value, at);
+	const id = node.keyOf(value);
+	if (typeof id !== "string") return fail(at, "invalid-list-key", "List key must be a string.");
+	const items = current, keys$2 = keys(items, node.keyOf);
+	if (keys$2.index(id) >= 0) return fail(at, "duplicate-list-item", "List key already exists.");
+	if (!valid(keys$2, position)) return fail(at, "invalid-anchor", "Unknown list anchor.");
+	session.recorder.order(container);
+	session.recorder.member(container, id, session.definition(container, id), -1);
+	insert$2(items, index(keys$2, position), value);
+	session.invalidate();
+}
+function set$1(session, container, id, value) {
+	const { at, node, value: items } = container;
+	if (node.kind !== "list") return fail(at, "invalid-list-key", "Expected a list.");
+	const index = indexedKeys(items, node.keyOf).index(id);
+	if (index < 0) return fail(at, "missing-list-item", "List key does not exist.");
+	session.writeMember(container, id, value, "set", index);
+}
+function remove$1(session, container, id) {
+	const { at, node, value } = container;
+	if (node.kind !== "list") return fail(at, "missing-list-item", "List key does not exist.");
+	const index = keys(value, node.keyOf).index(id);
+	if (index < 0) return fail(at, "missing-list-item", "List key does not exist.");
+	session.writeMember(container, id, void 0, "remove", index);
+}
+//#endregion
+//#region core/src/mutation/operations/tree.ts
+const node = (tree, id) => Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
+const positionIndex = (index, length, at) => {
+	if (index !== void 0 && (!Number.isInteger(index) || index < 0)) return fail(at, "invalid-tree-index", "Tree index must be nonnegative.");
+	return Math.min(index ?? length, length);
+};
+const insert = (session, container, id, value, position) => {
+	const { at, node: schema, value: tree } = container;
+	if (typeof id !== "string") return fail(at, "invalid-key", "Tree keys must be strings.");
+	if (contains(tree, id)) return fail(at, "duplicate-tree-node", "Tree node already exists.");
+	const parentId = position?.parentId;
+	const parent = parentId === void 0 ? void 0 : node(tree, parentId);
+	if (tree.rootId !== void 0 && !parent || tree.rootId === void 0 && parentId !== void 0) return fail(at, "missing-tree-parent", "A nonempty tree requires an existing parent.");
+	const index = positionIndex(position?.index, parent?.children.length ?? 0, at);
+	session.validate(schema.value, value, at.concat(id));
+	session.recorder.tree(container, id);
+	if (parentId !== void 0) session.recorder.tree(container, parentId);
+	Object.defineProperty(tree.nodes, id, {
+		value: {
+			...parentId === void 0 ? {} : { parentId },
+			children: [],
+			value
+		},
+		writable: true,
+		configurable: true,
+		enumerable: true
+	});
+	if (parent) parent.children.splice(index, 0, id);
+	else tree.rootId = id;
+	session.invalidate();
+};
+const set = (session, container, id, value) => {
+	const { at, node: schema, value: tree } = container;
+	const entry = node(tree, id);
+	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
+	if (Object.is(entry.value, value) && Object.hasOwn(entry, "value")) return;
+	session.validate(schema.value, value, at.concat(id));
+	session.recorder.tree(container, id);
+	entry.value = value;
+};
+const remove = (session, container, id) => {
+	const { at, value: tree } = container;
+	const entry = node(tree, id);
+	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
+	const ids = [], stack = [id];
+	while (stack.length) {
+		const current = stack.pop();
+		ids.push(current);
+		for (const child of tree.nodes[current].children) stack.push(child);
+	}
+	for (const key of ids) session.recorder.tree(container, key);
+	if (entry.parentId !== void 0) session.recorder.tree(container, entry.parentId);
+	if (entry.parentId === void 0) delete tree.rootId;
+	else {
+		const children = tree.nodes[entry.parentId].children;
+		children.splice(children.indexOf(id), 1);
+	}
+	for (const key of ids) delete tree.nodes[key];
+	session.invalidate();
+};
+const move$1 = (session, container, id, position) => {
+	const { at, value: tree } = container;
+	const entry = node(tree, id), parentId = position?.parentId;
+	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
+	if (entry.parentId === void 0 || parentId === void 0 || !contains(tree, parentId)) return fail(at, "missing-tree-parent", "Moving requires a non-root node and an existing parent.");
+	for (let ancestor = parentId; ancestor !== void 0; ancestor = tree.nodes[ancestor].parentId) if (ancestor === id) return fail(at, "tree-cycle", "Cannot move a node under its descendant.");
+	const old = tree.nodes[entry.parentId], next = tree.nodes[parentId];
+	const index = positionIndex(position?.index, next.children.length - (old === next ? 1 : 0), at);
+	const previous = old.children.indexOf(id);
+	if (old === next && previous === index) return;
+	session.recorder.tree(container, id);
+	session.recorder.tree(container, entry.parentId);
+	session.recorder.tree(container, parentId);
+	old.children.splice(previous, 1);
+	next.children.splice(index, 0, id);
+	entry.parentId = parentId;
+	session.invalidate();
+};
+//#endregion
+//#region core/src/mutation/operations/order.ts
+function move(session, container, id, position) {
+	const { at, node, value } = container;
+	if (node.kind !== "table" && node.kind !== "list") return fail(at, "invalid-collection", "Expected an ordered container.");
+	const items = node.kind === "table" ? value.ids : value;
+	const keys$1 = node.kind === "table" ? items : keys(items, node.keyOf);
+	const index = node.kind === "table" ? items.indexOf(id) : keys$1.index(id);
+	if (index < 0) return fail(at, "missing-entity", "Ordered key does not exist.");
+	if (!valid(keys$1, position)) return fail(at, "invalid-anchor", "Unknown order anchor.");
+	const next = afterRemove(keys$1, index, position);
+	if (next === index) return;
+	session.recorder.order(container);
+	move$2(items, index, next);
+	session.invalidate();
+}
+//#endregion
+//#region core/src/access/scope.ts
+const locations = /* @__PURE__ */ new WeakMap();
+const locationOf = (value) => locations.get(value);
+const addressOf = (target) => {
+	if (target.at) return target.at;
+	profile.access("addresses");
+	return target.at = addressOf(target.parent).concat(target.key);
+};
+const assertActive = (context) => {
+	if (context.active && !context.active()) throw new Error("Document access scope has expired.");
+};
+const collect = (context, at, kind = "value", id) => {
+	context.dependencies?.record(kind === "value" ? {
+		kind,
+		at
+	} : {
+		kind,
+		at,
+		...id === void 0 ? {} : { id }
+	});
+};
+const snapshot = (value) => {
+	const location = value && typeof value === "object" ? locationOf(value) : void 0;
+	if (!location) return value;
+	const { context } = location;
+	const at = addressOf(location.target);
+	profile.access("snapshots");
+	collect(context, at);
+	const resolved = resolve(context, location.target);
+	if (!resolved.node) throw new Error("The selected schema address no longer exists.");
+	return copyValue(resolved.node, resolved.value);
+};
+/** TypeScript cannot express asymmetric index signatures for nested collection tools. */
+const assign = (container, key, value) => {
+	if (!locationOf(container)) throw new TypeError("assign requires scoped document access.");
+	if (typeof key !== "string") throw new TypeError("Document keys must be strings.");
+	Reflect.set(container, key, value);
+};
+const resolve = (context, target) => {
+	assertActive(context);
+	const generation = context.session?.generation ?? 0;
+	if (target.generation !== generation) {
+		profile.access("resolutions");
+		if (!target.parent && !target.at.length) {
+			target.node = context.state.schema;
+			target.value = context.state.document;
+		} else {
+			const parent = target.parent && resolve(context, target.parent);
+			const location = parent ? resolveChild(parent.node, parent.value, target.key) : resolveLocated(context.state.schema, context.state.document, target.at);
+			target.node = location?.node ?? nodeAt(context.state.schema, addressOf(target), context.state.document);
+			target.value = location && Object.hasOwn(location.parent, location.key) ? location.parent[location.key] : void 0;
+		}
+		target.generation = generation;
+	}
+	return target;
+};
+const createAccess = (context, initial = []) => {
+	profile.access("scopes");
+	const mutable = () => {
+		assertActive(context);
+		if (!context.session) throw new TypeError("Cannot modify read-only document access.");
+		return context.session;
+	};
+	const writableContainer = (target, session) => {
+		if (target.container?.generation === session.generation && "layout" in target.container) return target.container;
+		return target.container = session.bind(addressOf(target), target.node, target.value);
+	};
+	const childAt = (target, key) => {
+		profile.access("addresses");
+		return addressOf(target).concat(key);
+	};
+	const access = (target) => {
+		if (target.proxy) return target.proxy;
+		const proxy = new Proxy(target, handler);
+		profile.access("proxies");
+		locations.set(proxy, {
+			context,
+			target
+		});
+		target.proxy = proxy;
+		return proxy;
+	};
+	const createTarget = (at, parent, key) => ({
+		at,
+		parent,
+		key,
+		node: void 0,
+		value: void 0,
+		generation: -1,
+		children: void 0,
+		proxy: void 0
+	});
+	const childAccess = (target, member, node, value) => {
+		const key = typeof member === "string" ? member : member.key;
+		if (node.kind === "field" || value === void 0) {
+			if (context.dependencies) collect(context, childAt(target, key));
+			return value;
+		}
+		let children = target.children;
+		let child;
+		if (typeof member !== "string") {
+			if (children?.kind !== "fixed" || children.schema !== target.node) children = {
+				kind: "fixed",
+				schema: target.node,
+				slots: new Array(compiledShape(target.node, target.value).members.size)
+			};
+			child = children.slots[member.slot] ??= createTarget(void 0, target, key);
+		} else {
+			if (children?.kind !== "dynamic") children = {
+				kind: "dynamic",
+				keys: /* @__PURE__ */ new Map()
+			};
+			const retained = children.keys.get(key);
+			child = retained ?? createTarget(void 0, target, key);
+			if (!retained) children.keys.set(key, child);
+		}
+		target.children = children;
+		if (child.generation === target.generation) return child.proxy;
+		child.node = node;
+		child.value = value;
+		child.generation = target.generation;
+		return access(child);
+	};
+	const collectionValue = (target, node) => {
+		const current = resolve(context, target);
+		if (current.node !== node || current.value === void 0) throw new TypeError("The collection method belongs to a replaced schema branch.");
+		return current.value;
+	};
+	const writableCollection = (target, node) => {
+		const session = mutable();
+		collectionValue(target, node);
+		return writableContainer(target, session);
+	};
+	const writableTree = (target, node) => {
+		const session = mutable();
+		collectionValue(target, node);
+		if (target.container?.generation === session.generation && !("layout" in target.container)) return target.container;
+		return target.container = session.bindTree(addressOf(target), target.node, target.value);
+	};
+	const orderedMethod = (target, property, node) => {
+		const at = addressOf(target);
+		if (property === "ids") return () => {
+			const current = collectionValue(target, node);
+			collect(context, at, "collection");
+			return node.kind === "table" ? [...current.ids] : current.map(node.keyOf);
+		};
+		if (property === "has") return (id) => {
+			const current = collectionValue(target, node);
+			collect(context, at, "collection", id);
+			return node.kind === "table" ? Object.hasOwn(current.byId, id) : indexedKeys(current, node.keyOf).index(id) >= 0;
+		};
+		if (property === "get") return (id) => {
+			const current = collectionValue(target, node);
+			collect(context, at, "collection", id);
+			const location = resolveChild(node, current, id);
+			if (!location || !Object.hasOwn(location.parent, location.key)) return void 0;
+			return childAccess(target, id, location.node, location.parent[location.key]);
+		};
+		if (property === "move") return (id, position) => {
+			const writable = writableCollection(target, node);
+			move(context.session, writable, id, position);
+		};
+	};
+	const tableMethod = (target, property, node) => {
+		if (property === "create") return (input, position) => {
+			const writable = writableCollection(target, node);
+			create(context.session, writable, Array.isArray(input) ? input : [input], position);
+		};
+		if (property === "remove") return (ids) => {
+			const writable = writableCollection(target, node);
+			remove$2(context.session, writable, typeof ids === "string" ? [ids] : ids);
+		};
+		return orderedMethod(target, property, node);
+	};
+	const listMethod = (target, property, node) => {
+		const at = addressOf(target);
+		if (property === "insert") return (value, position) => {
+			const writable = writableCollection(target, node);
+			insert$1(context.session, writable, value, position);
+		};
+		if (property === "remove") return (id) => {
+			const writable = writableCollection(target, node);
+			remove$1(context.session, writable, id);
+		};
+		if (property === "set") return (id, value) => {
+			const writable = writableCollection(target, node);
+			set$1(context.session, writable, id, value);
+		};
+		if (property === "replace") return (value) => {
+			const session = mutable();
+			collectionValue(target, node);
+			session.replace(at, value);
+		};
+		return orderedMethod(target, property, node);
+	};
+	const treeMethod = (target, property, node) => {
+		const at = addressOf(target);
+		if (property === "insert") return (id, value, position) => {
+			const writable = writableTree(target, node);
+			insert(context.session, writable, id, value, position);
+		};
+		if (property === "set") return (id, value) => {
+			const writable = writableTree(target, node);
+			set(context.session, writable, id, value);
+		};
+		if (property === "remove") return (id) => {
+			const writable = writableTree(target, node);
+			remove(context.session, writable, id);
+		};
+		if (property === "move") return (id, position) => {
+			const writable = writableTree(target, node);
+			move$1(context.session, writable, id, position);
+		};
+		if (property === "replace") return (value) => {
+			const session = mutable();
+			collectionValue(target, node);
+			session.replace(at, value);
+		};
+		const current = () => {
+			collect(context, at);
+			return collectionValue(target, node);
+		};
+		if (property === "rootId") return () => current().rootId;
+		if (property === "get") return (id) => {
+			const value = current();
+			return contains(value, id) ? value.nodes[id].value : void 0;
+		};
+		if (property === "has") return (id) => contains(current(), id);
+		if (property === "parent") return (id) => parent(current(), id);
+		if (property === "children") return (id) => {
+			const children$1 = children(current(), id);
+			return children$1 ? [...children$1] : void 0;
+		};
+	};
+	const handler = {
+		get: (target, property) => {
+			const { node, value } = resolve(context, target);
+			if (!node || value === void 0) return void 0;
+			if (typeof property !== "string") return void 0;
+			if (node.kind === "map") {
+				if (context.dependencies) collect(context, addressOf(target), "collection", property);
+				if (!Object.hasOwn(value, property)) return void 0;
+				if (node.value.kind === "field") {
+					if (context.dependencies) collect(context, childAt(target, property));
+					return value[property];
+				}
+				return childAccess(target, property, node.value, value[property]);
+			}
+			if (node.kind === "table") return tableMethod(target, property, node);
+			if (node.kind === "list") return listMethod(target, property, node);
+			if (node.kind === "tree") return treeMethod(target, property, node);
+			if (node.kind === "variant" && property === node.tag) {
+				collect(context, childAt(target, property));
+				return value[property];
+			}
+			const member = compiledShape(node, value)?.members.get(property);
+			if (!member) return void 0;
+			if (member.field) {
+				if (context.dependencies) collect(context, childAt(target, property));
+				return value[property];
+			}
+			return childAccess(target, node.kind === "object" ? member : property, member.node, value[property]);
+		},
+		set: (target, property, value) => {
+			const session = mutable(), { node } = resolve(context, target);
+			if (typeof property !== "string" || !node || node.kind !== "object" && node.kind !== "variant" && node.kind !== "map") throw new TypeError("Invalid structural assignment.");
+			if (node.kind === "variant" && node.tag === property) throw new TypeError("Variant discriminants are read-only.");
+			session.assignMember(writableContainer(target, session), property, value);
+			return true;
+		},
+		deleteProperty: (target, property) => {
+			const session = mutable(), { node } = resolve(context, target);
+			if (typeof property !== "string" || node?.kind === "variant" && node.tag === property) throw new TypeError("Invalid structural deletion.");
+			session.removeMember(writableContainer(target, session), property);
+			return true;
+		},
+		has: (target, property) => {
+			const { node, value } = resolve(context, target);
+			if (typeof property !== "string") return false;
+			collect(context, addressOf(target), node?.kind === "map" ? "collection" : "value", node?.kind === "map" ? property : void 0);
+			return value !== void 0 && Object.hasOwn(value, property);
+		},
+		ownKeys: (target) => {
+			const { value } = resolve(context, target);
+			if (context.dependencies) collect(context, addressOf(target), "collection");
+			return value && typeof value === "object" ? Object.keys(value) : [];
+		},
+		getOwnPropertyDescriptor: (target, property) => {
+			const { value } = resolve(context, target);
+			return value && Object.hasOwn(value, property) ? {
+				enumerable: true,
+				configurable: true
+			} : void 0;
+		},
+		defineProperty: () => {
+			assertActive(context);
+			throw new TypeError("Use schema assignments.");
+		},
+		setPrototypeOf: () => {
+			assertActive(context);
+			throw new TypeError("Document prototypes are immutable.");
+		},
+		preventExtensions: () => {
+			assertActive(context);
+			throw new TypeError("Document access cannot be frozen.");
+		}
+	};
+	const root = resolve(context, createTarget(initial, void 0, ""));
+	if (!root.node || root.node.kind === "field" || root.value === void 0) {
+		if (context.dependencies) collect(context, initial);
+		return root.value;
+	}
+	return access(root);
+};
+const collectionAccess = (context, at) => {
+	const value = createAccess(context, at);
+	if (value === void 0) return {
+		get: () => {
+			assertActive(context);
+		},
+		has: () => {
+			assertActive(context);
+			return false;
+		},
+		ids: () => {
+			assertActive(context);
+			return [];
+		}
+	};
+	if (locations.get(value).target.node?.kind === "table") return value;
+	const map = value;
+	return {
+		get: (id) => map[id],
+		has: (id) => id in map,
+		ids: () => Object.keys(map)
+	};
+};
+//#endregion
+//#region core/src/impact-target.ts
+const address = (target) => "at" in target ? target.at : target.address;
+const id = (target) => target.kind === "collection" && "id" in target ? target.id : void 0;
+const belongs = (target, schema) => !("schema" in target) || target.schema === schema;
+const same = (left, right) => {
+	if (left.kind !== right.kind) return false;
+	if ("schema" in left && "schema" in right && left.schema !== right.schema) return false;
+	const leftAddress = address(left);
+	const rightAddress = address(right);
+	if (leftAddress.length !== rightAddress.length) return false;
+	for (let index = 0; index < leftAddress.length; index += 1) if (leftAddress[index] !== rightAddress[index]) return false;
+	return left.kind !== "collection" || id(left) === id(right);
+};
+const indexedAddress = (target) => {
+	const key = id(target);
+	return key === void 0 ? address(target) : [...address(target), key];
+};
+const affected = (target, values, orders) => {
+	const at = indexedAddress(target);
+	return id(target) !== void 0 ? values.hasAncestor(at) : values.overlaps(at) || orders.hasDescendant(at);
+};
+/** Targets are classified once; commit matching never builds a reverse impact index. */
+var SubscriptionIndex = class {
+	ordinary = new AddressIndex();
+	membership = new AddressIndex();
+	constructor(schema) {
+		this.schema = schema;
+	}
+	add(target, value) {
+		if (belongs(target, this.schema)) (id(target) === void 0 ? this.ordinary : this.membership).add(indexedAddress(target), value);
+	}
+	delete(target, value) {
+		if (belongs(target, this.schema)) (id(target) === void 0 ? this.ordinary : this.membership).delete(indexedAddress(target), value);
+	}
+	collect(changes, visit) {
+		const values = this.ordinary.query(visit);
+		const members = this.membership.query(visit, "descendants");
+		const orders = this.ordinary.query(visit, "ancestors");
+		for (const change of changes.changes) if (change.kind === "reset") {
+			values([]);
+			members([]);
+		} else if (change.kind === "members") {
+			values(change.at, change.members);
+			members(change.at, change.members);
+			if (change.order) orders(change.at);
+		} else {
+			values(change.at);
+			members(change.at);
+		}
+	}
+	clear() {
+		this.ordinary.clear();
+		this.membership.clear();
+	}
+};
+//#endregion
+//#region core/src/impact.ts
+const queries = /* @__PURE__ */ new WeakMap();
+const affectsTarget = (impact, value) => queries.get(impact).affects(value);
+const collectionImpact = (impact, selector) => queries.get(impact).collection(selector);
+const createImpact = (schema, changes) => {
+	const reset = changes.changes.some((change) => change.kind === "reset");
+	let values;
+	let orders;
+	const index = () => {
+		if (!values) {
+			profile.impact.index();
+			values = new AddressIndex();
+			orders = new AddressIndex();
+			for (const change of changes.changes) if (change.kind === "members") {
+				for (const member of change.members) values.add(change.at, true, member.key);
+				if (change.order) orders.add(change.at, true);
+			} else if (change.kind === "tree") values.add(change.at, true);
+		}
+		return values;
+	};
+	const cache = /* @__PURE__ */ new Map();
+	const implementation = {
+		affects(value) {
+			profile.impact.affects();
+			if (!belongs(value, schema)) return false;
+			if (reset) return true;
+			return affected(value, index(), orders);
+		},
+		collection(selector) {
+			if (selector.schema !== schema) throw new TypeError("Collection belongs to another root model.");
+			const key = JSON.stringify(selector.address), cached = cache.get(key);
+			if (cached) return cached;
+			if (reset) {
+				const result = { kind: "reset" };
+				cache.set(key, result);
+				return result;
+			}
+			const at = selector.address;
+			const added = /* @__PURE__ */ new Set(), removed = /* @__PURE__ */ new Set(), updated = /* @__PURE__ */ new Set();
+			let orderChanged = false;
+			for (const change of changes.changes) {
+				if (change.kind === "reset") continue;
+				if (change.kind === "members") {
+					if (change.at.length < at.length && contains$1(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$1(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$1(change.at, at)) {
+					const result = { kind: "reset" };
+					cache.set(key, result);
+					return result;
+				}
+				if (!contains$1(at, change.at)) continue;
+				if (change.at.length === at.length) continue;
+				const id = change.at[at.length];
+				updated.add(id);
+			}
+			added.forEach((id) => updated.delete(id));
+			removed.forEach((id) => updated.delete(id));
+			const result = {
+				kind: "incremental",
+				added,
+				removed,
+				updated,
+				orderChanged
+			};
+			cache.set(key, result);
+			return result;
+		}
+	};
+	const impact = Object.freeze({
+		kind: reset ? "reset" : "incremental",
+		affects: (pick) => implementation.affects(compilePath(schema, "value", pick)),
+		collection: (pick) => implementation.collection(compilePath(schema, "collection", pick))
+	});
+	queries.set(impact, implementation);
+	return impact;
+};
+//#endregion
+//#region core/src/runtime/contract.ts
+var DocumentReentrancyError = class extends Error {
+	constructor() {
+		super("Document writes cannot be re-entered during an update or notification.");
+		this.name = "DocumentReentrancyError";
+	}
+};
+var DocumentDisposedError = class extends Error {
+	constructor() {
+		super("Doxum runtime has been disposed.");
+		this.name = "DocumentDisposedError";
+	}
+};
+var TransactionRejected = class extends Error {
+	issues;
+	constructor(input) {
+		super("Document update rejected.");
+		this.name = "TransactionRejected";
+		const issues = Array.isArray(input) ? input : [input];
+		this.issues = Object.freeze(issues.map((issue) => Object.freeze({
+			code: issue.code,
+			message: issue.message,
+			source: "application",
+			...issue.address === void 0 ? {} : { address: Object.freeze([...issue.address]) }
+		})));
+	}
+};
+//#endregion
+//#region core/src/runtime/access.ts
+const states = /* @__PURE__ */ new WeakMap();
+const bindRuntimeAccess = (runtime, state) => {
+	states.set(runtime, state);
+};
+const accessOf = (runtime) => {
+	const state = states.get(runtime);
+	if (!state) throw new Error("Unknown Doxum runtime.");
+	return state;
+};
+const readWith = (runtime, run, dependencies) => {
+	const state = accessOf(runtime);
+	if (state.disposed) throw new DocumentDisposedError();
+	state.projectionLocks = (state.projectionLocks ?? 0) + 1;
+	try {
+		return run(createAccess({
+			state,
+			dependencies
+		}));
+	} finally {
+		state.projectionLocks--;
+	}
+};
+//#endregion
+//#region core/src/runtime/notification.ts
+const notifications = /* @__PURE__ */ new WeakMap();
+const readableOwners = /* @__PURE__ */ new WeakMap();
+const bindDocumentReadable = (readable, runtime) => {
+	readableOwners.set(readable, runtime);
+};
+const documentReadableOwner = (readable) => readableOwners.get(readable);
+const createNotification = (runtime) => {
+	const notification = {
+		root: /* @__PURE__ */ new Set(),
+		filtered: /* @__PURE__ */ new Set(),
+		index: new SubscriptionIndex(runtime.schema),
+		cleanups: /* @__PURE__ */ new Set(),
+		processors: [],
+		candidates: /* @__PURE__ */ new Set(),
+		rootSnapshot: [],
+		notifying: false
+	};
+	notifications.set(runtime, notification);
+	return notification;
+};
+const notificationOf = (runtime) => {
+	const value = notifications.get(runtime);
+	if (!value) throw new Error("Unknown Doxum runtime.");
+	return value;
+};
+const shareNotification = (source, target) => {
+	notifications.set(target, notificationOf(source));
+};
+const attachProjection = (runtime, processor) => {
+	const notification = notificationOf(runtime);
+	const entry = {
+		processor,
+		active: true
+	};
+	notification.processors.push(entry);
+	return () => {
+		if (!entry.active) return;
+		entry.active = false;
+		if (!notification.notifying) {
+			const index = notification.processors.indexOf(entry);
+			if (index >= 0) notification.processors.splice(index, 1);
+		}
+	};
+};
+const subscribeRoot = (notification, listener) => {
+	const entry = {
+		listener,
+		active: true
+	};
+	notification.root.add(entry);
+	return () => {
+		entry.active = false;
+		if (!notification.notifying) notification.root.delete(entry);
+		else notification.cleanups.add(() => {
+			notification.root.delete(entry);
+		});
+	};
+};
+const subscribeTargets = (notification, targets, listener) => {
+	const entry = {
+		targets: Object.freeze(targets.slice()),
+		listener,
+		active: true
+	};
+	notification.filtered.add(entry);
+	entry.targets.forEach((value) => notification.index.add(value, entry));
+	const remove = () => {
+		notification.filtered.delete(entry);
+		entry.targets.forEach((value) => notification.index.delete(value, entry));
+	};
+	return () => {
+		if (!entry.active) return;
+		entry.active = false;
+		if (notification.notifying) notification.cleanups.add(remove);
+		else remove();
+	};
+};
+const notify = (notification, commit, afterSettle) => {
+	notification.notifying = true;
+	const errors = [];
+	const call = (listener) => {
+		try {
+			listener(commit);
+		} catch (error) {
+			errors.push(Object.freeze({
+				phase: "listener",
+				error
+			}));
+		}
+	};
+	try {
+		const processorCount = notification.processors.length;
+		for (let index = 0; index < processorCount; index += 1) {
+			const entry = notification.processors[index];
+			if (!entry?.active) continue;
+			try {
+				entry.processor.capture(commit);
+			} catch (error) {
+				errors.push(Object.freeze({
+					phase: "processor",
+					error
+				}));
+			}
+		}
+		for (let index = 0; index < processorCount; index += 1) {
+			const entry = notification.processors[index];
+			if (!entry?.active) continue;
+			try {
+				entry.processor.settle();
+			} catch (error) {
+				errors.push(Object.freeze({
+					phase: "processor",
+					error
+				}));
+			}
+		}
+		for (let index = 0; index < processorCount; index += 1) {
+			const entry = notification.processors[index];
+			if (!entry?.active) continue;
+			try {
+				errors.push(...entry.processor.flush());
+			} catch (error) {
+				errors.push(Object.freeze({
+					phase: "flush",
+					error
+				}));
+			}
+		}
+		if (afterSettle) errors.push(...afterSettle());
+		const candidates = notification.candidates;
+		candidates.clear();
+		if (notification.filtered.size) notification.index.collect(commit.changes, (entry) => candidates.add(entry));
+		candidates.forEach((entry) => {
+			if (entry.active) call(entry.listener);
+		});
+		const rootSnapshot = notification.rootSnapshot;
+		rootSnapshot.length = 0;
+		notification.root.forEach((entry) => rootSnapshot.push(entry));
+		for (const entry of rootSnapshot) if (entry.active) call(entry.listener);
+	} finally {
+		notification.notifying = false;
+		let writeIndex = 0;
+		for (const entry of notification.processors) if (entry.active) notification.processors[writeIndex++] = entry;
+		notification.processors.length = writeIndex;
+		notification.cleanups.forEach((cleanup) => cleanup());
+		notification.cleanups.clear();
+	}
+	return Object.freeze(errors);
+};
+const subscribeDependencies = (runtime, targets, listener) => subscribeTargets(notificationOf(runtime), targets, listener);
+const disposeNotification = (notification) => {
+	const attachments = notification.processors.slice();
+	notification.root.clear();
+	notification.filtered.clear();
+	notification.index.clear();
+	notification.cleanups.clear();
+	notification.processors.length = 0;
+	notification.candidates.clear();
+	notification.rootSnapshot.length = 0;
+	const errors = [];
+	attachments.forEach((entry) => {
+		if (!entry.active) return;
+		try {
+			entry.processor.dispose();
+		} catch (error) {
+			errors.push(error);
+		}
+	});
+	if (errors.length) throw new AggregateError(errors, "Projection disposal notification failed.");
+};
+//#endregion
+//#region core/src/projection/definition.ts
+const definitions = /* @__PURE__ */ new WeakMap();
+const freezeSources = (sources) => Object.freeze({ ...sources });
+const define = (definition) => {
+	const handle = Object.freeze({});
+	definitions.set(handle, definition);
+	return handle;
+};
+const definitionOf = (projection) => {
+	const definition = definitions.get(projection);
+	if (!definition) throw new TypeError("Unknown projection definition.");
+	return definition;
+};
+const input = (initial, options) => define({
+	kind: "input",
+	initial,
+	isEqual: options?.isEqual
+});
+function project(first, second, third, fourth) {
+	if (first && typeof first === "object" && "kind" in first && (first.kind === "value" || first.kind === "collection")) {
+		const spec = first;
+		return define({
+			kind: spec.kind === "value" ? "advanced-value" : "advanced-collection",
+			sources: freezeSources(spec.sources),
+			build: spec.build,
+			isEqual: spec.isEqual,
+			name: spec.name
+		});
+	}
+	if (first && typeof first === "object" && "revision" in first && "subscribe" in first) {
+		if ("address" in first) {
+			const document = first;
+			if (!second) return define({
+				kind: "document",
+				document
+			});
+			if (Array.isArray(second)) return define({
+				kind: "document",
+				document,
+				targets: Object.freeze([...second])
+			});
+			if (typeof second !== "function") throw new TypeError("Invalid document projection.");
+			const source = define({
+				kind: "document-collection",
+				document,
+				pick: second
+			});
+			if (!third || typeof third !== "function") return source;
+			return define({
+				kind: "map",
+				source,
+				mapper: third,
+				isEqual: fourth?.isEqual
+			});
+		}
+		return define({
+			kind: "readable",
+			readable: first
+		});
+	}
+	if (second) {
+		if (typeof second !== "function") throw new TypeError("Invalid project declaration.");
+		if (definitions.has(first)) return define({
+			kind: "map",
+			source: first,
+			mapper: second,
+			isEqual: third?.isEqual
+		});
+		return define({
+			kind: "value",
+			sources: freezeSources(first),
+			compute: second,
+			isEqual: third?.isEqual
+		});
+	}
+	throw new TypeError("Invalid project declaration.");
+}
+//#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/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 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) => {
+			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) => {
+					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();
+			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 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 = (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;
+					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(),
+						...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);
+					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 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;
+	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 || !(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
+			});
+		},
+		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/runtime.ts
+const debug = /* @__PURE__ */ new WeakMap();
+const projectionEngineDebug = (runtime) => {
+	const read = debug.get(runtime);
+	if (!read) throw new Error("Unknown projection engine.");
+	return Object.freeze(read());
+};
+const createProjectionEngine = (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,
+		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();
+			}
+		}
+	};
+	debug.set(runtime, scheduler.debug);
+	return Object.freeze(runtime);
+};
+//#endregion
+//#region core/src/projection/store.ts
+const stores = /* @__PURE__ */ new WeakMap();
+const projectionStoreDebug = (store) => {
+	const runtime = stores.get(store);
+	if (!runtime) throw new Error("Unknown projection store.");
+	return projectionEngineDebug(runtime);
+};
+const createProjectionStore = (options) => {
+	const runtime = createProjectionEngine(options);
+	const instances = /* @__PURE__ */ new WeakMap();
+	const inputs = /* @__PURE__ */ new WeakMap();
+	const materialize = (projection) => {
+		const old = instances.get(projection);
+		if (old) return old;
+		const definition = definitionOf(projection);
+		let instance;
+		if (definition.kind === "input") {
+			const input = runtime.input(definition.initial, { isEqual: definition.isEqual });
+			inputs.set(projection, input);
+			instance = runtime.value({ input: input.source }, ({ input }) => input.value);
+		} else if (definition.kind === "readable") {
+			const source = runtime.fromReadable(definition.readable, { isEqual: definition.isEqual });
+			instance = runtime.value({ source }, ({ source }) => source.value);
+		} else if (definition.kind === "document") {
+			const document = runtime.document(definition.document);
+			instance = definition.targets?.length ? document.targets(...definition.targets) : document;
+		} else if (definition.kind === "document-collection") instance = runtime.document(definition.document).collection(definition.pick);
+		else if (definition.kind === "map") instance = runtime.map(materialize(definition.source), definition.mapper, { isEqual: definition.isEqual });
+		else {
+			const sources = Object.fromEntries(Object.entries(definition.sources).map(([key, source]) => [key, materialize(source)]));
+			if (definition.kind === "value") instance = runtime.value(sources, (events) => {
+				const values = Object.fromEntries(Object.entries(events).map(([key, event]) => [key, current(event)]));
+				return definition.compute(values);
+			}, { isEqual: definition.isEqual });
+			else if (definition.kind === "advanced-value") instance = runtime.value({
+				sources,
+				build: definition.build,
+				name: definition.name
+			}, { isEqual: definition.isEqual });
+			else instance = runtime.collection()({
+				sources,
+				build: definition.build,
+				isEqual: definition.isEqual,
+				name: definition.name
+			});
+		}
+		instances.set(projection, instance);
+		return instance;
+	};
+	const current = (event) => {
+		if (event && typeof event === "object") {
+			if ("value" in event) return event.value;
+			if ("read" in event) return event.read;
+		}
+		return event;
+	};
+	const store = {
+		get: ((projection) => {
+			const instance = materialize(projection);
+			if ("current" in instance && typeof instance.current === "function") return instance.current();
+			throw new TypeError("Projection is a source and has no published value.");
+		}),
+		set: (projection, value) => {
+			materialize(projection);
+			const target = inputs.get(projection);
+			if (!target) throw new TypeError("Projection is not an input.");
+			target.set(value);
+		},
+		subscribe: ((projection, listener) => {
+			const instance = materialize(projection);
+			if (!("subscribe" in instance)) throw new TypeError("Projection is a source and cannot be subscribed.");
+			return instance.subscribe(listener);
+		}),
+		revision: (projection) => {
+			const instance = materialize(projection);
+			if (!("revision" in instance) || typeof instance.revision !== "function") throw new TypeError("Projection has no published revision.");
+			return instance.revision();
+		},
+		rebuild: (projection) => {
+			const instance = materialize(projection);
+			if (!("rebuild" in instance) || typeof instance.rebuild !== "function") throw new TypeError("Projection cannot be rebuilt.");
+			instance.rebuild();
+		},
+		release: (projection) => {
+			const instance = instances.get(projection);
+			if (!instance) return;
+			if ("dispose" in instance && typeof instance.dispose === "function") instance.dispose();
+			instances.delete(projection);
+			inputs.delete(projection);
+		},
+		batch: runtime.batch,
+		dispose: runtime.dispose
+	};
+	stores.set(store, runtime);
+	return Object.freeze(store);
+};
+//#endregion
+export { object as A, parse as B, assign as C, field as D, compilePath as E, ParseError as F, checkKey as I, checkValue as L, table as M, tree as N, list as O, variant as P, copyValue as R, same as S, snapshot as T, readWith as _, input as a, TransactionRejected as b, createNotification as c, shareNotification as d, subscribeDependencies as f, bindRuntimeAccess as g, accessOf as h, ProjectionError as i, optional as j, map as k, disposeNotification as l, subscribeTargets as m, projectionStoreDebug as n, project as o, subscribeRoot as p, ProjectionDisposedError as r, bindDocumentReadable as s, createProjectionStore as t, notify as u, DocumentDisposedError as v, createAccess as w, createImpact as x, DocumentReentrancyError as y, equalValue as z };
+
+//# sourceMappingURL=store-D7QH6Rzw.js.map