doxum 0.1.23 → 0.1.26

package/dist/index.js

@@ -1,15 +1,431 @@
-import { A as checkValue, B as insert$2, C as optional, D as ParseError, E as variant, F as parse, G as listSequence, H as installKeys, I as compiledLayout, J as toArray, K as matches, L as compiledShape, M as copyValue, N as equalTreeNode, O as checkKey, P as equalValue, R as equal, S as object, T as tree, U as installList, V as install, W as keys, Y as profile, _ as collectionEntryNode, a as observe, b as list, c as projectionRef, d as createScheduler, f as ProjectionDisposedError, g as snapshotCollectionView, h as mapRead, i as isProjection, j as copyTreeNode, k as checkTreePayload, l as assertScope, m as collectionView, n as derive, o as ownProjection, p as ProjectionError, q as remove$4, r as input, s as producerOf, t as incremental, u as assertSynchronous, v as compilePath, w as table, x as map, y as field, z as indexedKeys } from "./advanced-CRNHfJBu.js";
-import { a as is, c as validate, d as isRecord, i as contains$1, l as installOwn, n as contextOf, o as parent, r as children, t as bindContext } from "./context-DFEaDUv5.js";
-import { a as sealChanges, c as fail, i as decodeChanges, l as invalidValue, o as AddressIndex, s as MutationRejected, t as assertRuntimeWritable } from "./driver-yFfvDMX5.js";
-//#region core/src/address/resolve.ts
-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] ?? "")];
+import { a as ProjectionError, c as snapshotCollectionView, d as isProjection, f as ownProjections, h as profile, i as ProjectionDisposedError, l as defineProcessor, m as projectionRef, n as assertSynchronous, o as collectionView, p as producerOf, r as createScheduler, s as mapRead, t as assertScope, u as defineSource } from "./scheduler--137L3j-.js";
+import { n as isPlainObject, r as isRecord, t as installOwn } from "./record-B2yRhYsc.js";
+import { c as AddressIndex, d as invalidValue, f as children, g as validate, h as parent, i as contextOf, l as MutationRejected, m as is, o as decodeChanges, p as contains$1, r as bindContext, s as sealChanges, t as assertRuntimeWritable, u as fail } from "./driver-B5vdPohL.js";
+//#region core/src/schema/model.ts
+const schemaNodeOf = (schema) => schema;
+const collectionEntryNode = (node) => node.kind === "map" || node.kind === "table" || node.kind === "list" ? node.value : void 0;
+const node$2 = (value) => Object.freeze(value);
+const field = (validator) => node$2({
+	kind: "field",
+	...validator ? { validator } : {}
+});
+function optional(value) {
+	const concrete = schemaNodeOf(value);
+	if (![
+		"field",
+		"variant",
+		"map",
+		"list",
+		"tree"
+	].includes(concrete.kind)) throw new TypeError("Only field, variant, map, list and tree nodes support optional presence.");
+	return node$2({
+		...concrete,
+		optional: true
+	});
+}
+const object = (shape) => node$2({
+	kind: "object",
+	shape: Object.freeze(Object.fromEntries(Object.entries(shape).map(([key, value]) => [key, schemaNodeOf(value)])))
+});
+const variant = (tag, variants) => node$2({
+	kind: "variant",
+	tag,
+	variants: Object.freeze(Object.fromEntries(Object.entries(variants).map(([key, value]) => [key, schemaNodeOf(value)])))
+});
+const table = (value, options) => node$2({
+	kind: "table",
+	value: schemaNodeOf(value),
+	...options
+});
+const map = (value, options) => node$2({
+	kind: "map",
+	value: schemaNodeOf(value),
+	...options
+});
+const list = (value, config) => node$2({
+	kind: "list",
+	keyOf: config.keyOf,
+	value: schemaNodeOf(value)
+});
+function tree(value) {
+	return Object.freeze({
+		kind: "tree",
+		value: schemaNodeOf(value)
+	});
+}
+//#endregion
+//#region core/src/order/sequence.ts
+const length$1 = (keys) => keys.length;
+const keyAt = (keys, index) => Array.isArray(keys) ? keys[index] : keys.at(index);
+const equal = (left, right) => {
+	profile.equality.call();
+	if (left === right) return true;
+	profile.equality.container();
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index++) if (left[index] !== keyAt(right, index)) return false;
+	return true;
+};
+const keys = (values, keyOf) => ({
+	length: values.length,
+	at: (index) => index >= 0 && index < values.length ? keyOf(values[index]) : void 0,
+	index: (key) => {
+		for (let index = 0; index < values.length; index += 1) if (keyOf(values[index]) === key) return index;
+		return -1;
+	}
+});
+const listIndexes = /* @__PURE__ */ new WeakMap();
+const knownKeys = (values) => {
+	let positions;
+	return {
+		length: values.length,
+		at: (index) => values[index],
+		index: (key) => {
+			if (!positions) {
+				positions = /* @__PURE__ */ new Map();
+				for (let index = 0; index < values.length; index++) positions.set(values[index], index);
+				profile.address.listIndex(values.length);
+			}
+			return positions.get(key) ?? -1;
+		}
+	};
+};
+const cacheKnownKeys = (values, keyOf, order) => {
+	listIndexes.set(values, {
+		keyOf,
+		order: knownKeys(order)
+	});
+};
+/** Canonical lists keep their key positions until a structural write invalidates them. */
+const indexedKeys = (values, keyOf) => {
+	const cached = listIndexes.get(values);
+	if (cached?.keyOf === keyOf) return cached.order;
+	let positions;
+	const order = {
+		length: values.length,
+		at: (index) => index >= 0 && index < values.length ? keyOf(values[index]) : void 0,
+		index: (key) => {
+			if (!positions) {
+				positions = /* @__PURE__ */ new Map();
+				for (let index = 0; index < values.length; index++) positions.set(keyOf(values[index]), index);
+				profile.address.listIndex(values.length);
+			}
+			return positions.get(key) ?? -1;
+		}
+	};
+	listIndexes.set(values, {
+		keyOf,
+		order
+	});
+	return order;
+};
+const toArray = (keys) => {
+	const result = new Array(length$1(keys));
+	for (let index = 0; index < result.length; index++) result[index] = keyAt(keys, index);
+	return result;
+};
+/** One operation-local list scan provides both stable keys and item association. */
+const listSequence = (values, keyOf) => {
+	const current = indexedKeys(values, keyOf);
+	const order = new Array(values.length);
+	const byKey = /* @__PURE__ */ new Map();
+	for (let index = 0; index < values.length; index++) {
+		const key = current.at(index);
+		order[index] = key;
+		byKey.set(key, values[index]);
+	}
+	cacheKnownKeys(values, keyOf, order);
+	return {
+		order,
+		values: byKey
+	};
+};
+/** Structural sequence writes own invalidation, including rollback writes. */
+const insert$2 = (values, index, value) => {
+	values.splice(index, 0, value);
+	listIndexes.delete(values);
+};
+const remove$3 = (values, index) => {
+	values.splice(index, 1);
+	listIndexes.delete(values);
+};
+/** Installs an exact string-key sequence such as table ids in one structural write. */
+const installKeys = (values, order) => {
+	values.length = order.length;
+	for (let index = 0; index < order.length; index++) values[index] = order[index];
+};
+/** Installs a pre-resolved list sequence without running keyOf again. */
+const installList = (values, keyOf, sequence, order) => {
+	values.length = order.length;
+	for (let index = 0; index < order.length; index++) values[index] = sequence.values.get(order[index]);
+	cacheKnownKeys(values, keyOf, order);
+};
+const install = (values, keyOf, order) => {
+	installList(values, keyOf, listSequence(values, keyOf), order);
+};
+const matches = (order, members) => {
+	if (order.length !== members.length) return false;
+	const ids = new Set(order);
+	return ids.size === order.length && members.every((id) => ids.has(id));
+};
+//#endregion
+//#region core/src/schema/layout.ts
+const compiledObjects = /* @__PURE__ */ new WeakMap();
+const compiledEntries = /* @__PURE__ */ new WeakMap();
+const variantBranch = (node, discriminator) => node.variants[discriminator ?? Object.keys(node.variants)[0] ?? ""];
+const objectBranch = (node, value) => {
+	if (node.kind === "object") return node;
+	if (node.kind !== "variant" || typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const rawTag = value[node.tag];
+	return variantBranch(node, typeof rawTag === "string" ? rawTag : void 0);
+};
+const compiledShape = (node, value) => {
+	const branch = objectBranch(node, value);
+	if (!branch) return void 0;
+	const shape = branch.shape;
+	let layout = compiledObjects.get(shape);
+	if (!layout) {
+		const members = /* @__PURE__ */ new Map();
+		for (const key of Object.keys(shape).sort()) {
+			profile.address.schemaStep();
+			members.set(key, {
+				kind: "fixed",
+				key,
+				node: shape[key],
+				field: shape[key].kind === "field",
+				slot: members.size
+			});
+		}
+		layout = {
+			kind: "fixed",
+			members
+		};
+		compiledObjects.set(shape, layout);
+	}
+	return layout;
+};
+const compiledLayout = (node, value) => {
+	if (node.kind !== "map" && node.kind !== "table" && node.kind !== "list") return compiledShape(node, value);
+	let layout = compiledEntries.get(node);
+	if (!layout) {
+		layout = {
+			kind: "dynamic",
+			entry: {
+				kind: "entry",
+				node: node.value,
+				field: node.value.kind === "field"
+			}
+		};
+		compiledEntries.set(node, layout);
+	}
+	return layout;
+};
+//#endregion
+//#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 (result === false) return issue(address, "Value validation failed.");
+			if (result !== void 0 && result !== true) return issue(address, "Function validators must return boolean or undefined.");
+		} else {
+			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.");
+			if (!Object.is(result.value, value)) return issue(address, "Validators must not transform values.");
+		}
+		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");
+	for (const id of Object.keys(value.nodes)) {
+		const failure = checkTreePayload(node.value, value.nodes[id], [...address, id], strict);
+		if (failure) return failure;
+	}
+};
+const checkTreePayload = (node, value, address, strict = false) => {
+	if (!isRecord(value)) return issue(address, "Invalid tree node.", "invalid-tree");
+	const present = Object.prototype.hasOwnProperty.call(value, "value");
+	if (!present && !node.optional) return issue(address, "Tree node value is required.");
+	return present ? checkValue(node, value.value, address, strict) : void 0;
+};
+const copyTreeNode = (value) => {
+	profile.copy.treeNode();
+	return {
+		...value,
+		children: [...value.children]
+	};
+};
+const equalTreeNode = (left, right) => {
+	if (left === right) return true;
+	if (!left || !right) return false;
+	return left.parentId === right.parentId && equal(left.children, right.children) && Object.hasOwn(left, "value") === Object.hasOwn(right, "value") && Object.is(left.value, right.value);
+};
+/** 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, copyTreeNode(n)]))
+		};
+	}
+	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) && equalTreeNode(a[id], b[id]));
+	}
+	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 = (schema, input) => {
+	const valueNode = schemaNodeOf(schema);
+	const failure = checkValue(valueNode, input, [], true);
+	if (failure) throw new ParseError(failure);
+	return copyValue(valueNode, input);
+};
+//#endregion
+//#region core/src/address/resolve.ts
 const step = (nodeInput, value, segment) => {
 	let node = nodeInput;
 	if (!node) return void 0;
-	if (node.kind === "variant") node = variantNode(node, value);
+	if (node.kind === "variant") {
+		const rawTag = isRecord(value) ? value[node.tag] : void 0;
+		node = variantBranch(node, typeof rawTag === "string" ? rawTag : void 0);
+	}
 	if (!node) return void 0;
 	if (node.kind === "object") return Object.hasOwn(node.shape, segment) ? node.shape[segment] : void 0;
 	if (node.kind === "table" || node.kind === "map") return node.value;
@@ -137,16 +553,6 @@ const resolveChild = (node, current, last) => {
 	};
 };
 //#endregion
-//#region core/src/mutation/operations/map.ts
-function put(session, container, id, value) {
-	if (container.node.kind !== "map") return fail(container.at, "invalid-collection", "Expected a map.");
-	session.writeMember(container, id, value, "set");
-}
-function remove$3(session, container, id) {
-	if (container.node.kind !== "map") return fail(container.at, "invalid-collection", "Expected a map.");
-	session.writeMember(container, id, void 0, "remove");
-}
-//#endregion
 //#region core/src/order/anchor.ts
 const length = (keys) => keys.length;
 const keyIndex = (keys, key) => Array.isArray(keys) ? keys.indexOf(key) : keys.index(key);
@@ -410,13 +816,17 @@ const sameTreeTarget = (left, right) => {
 	return left.kind !== "node" || right.kind === "node" && left.id === right.id;
 };
 const same = (left, right) => {
+	profile.dependency.comparison();
 	if ("schema" in left && "schema" in right && left.schema !== right.schema) return false;
 	if (!sameTreeTarget(treeTarget(left), treeTarget(right))) return false;
 	if (left.kind !== right.kind) 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;
+	for (let index = 0; index < leftAddress.length; index += 1) {
+		profile.dependency.segmentCompared();
+		if (leftAddress[index] !== rightAddress[index]) return false;
+	}
 	return left.kind !== "collection" || id(left) === id(right);
 };
 const indexedAddress = (target) => {
@@ -444,6 +854,12 @@ const indexedAddress = (target) => {
 		key
 	];
 };
+/**
+* Coarse identity for dependency de-duplication. Schema is intentionally excluded because
+* schema-bound and schema-free targets may compare equal; callers must still use same()
+* inside a bucket for the final equality decision.
+*/
+const dependencyBucket = (target) => JSON.stringify([target.kind, indexedAddress(target)]);
 const visitChangedLocations = (changes, value, order) => {
 	for (const change of changes.changes) {
 		if (change.kind === "reset") continue;
@@ -682,12 +1098,14 @@ const createAccess = (context, initial = []) => {
 			return childAccess(target, id, node.value, current[id]);
 		};
 		if (property === "put") return (id, value) => {
+			const session = mutable();
 			const writable = writableCollection(target, node);
-			put(context.session, writable, id, value);
+			session.writeMember(writable, id, value, "set");
 		};
 		if (property === "remove") return (id) => {
+			const session = mutable();
 			const writable = writableCollection(target, node);
-			remove$3(context.session, writable, id);
+			session.writeMember(writable, id, void 0, "remove");
 		};
 		if (property === "replace") return (value) => replaceCollection(target, node, value);
 	};
@@ -888,6 +1306,62 @@ const createAccess = (context, initial = []) => {
 	return access(root);
 };
 //#endregion
+//#region core/src/schema/path.ts
+const paths = /* @__PURE__ */ new WeakMap();
+const pathProxy = (nodes, address, owner, treeSelection) => {
+	const proxy = new Proxy({}, { get: (_target, property) => {
+		if (typeof property !== "string") return void 0;
+		const trees = nodes.every((node) => node.kind === "tree");
+		if (!treeSelection && trees && property === "rootId") return pathProxy(nodes, address, owner, { kind: "root" });
+		if (!treeSelection && trees && property === "nodes") return pathProxy(nodes, address, owner, { kind: "nodes" });
+		if (treeSelection?.kind === "nodes" && property === "item") return (id) => {
+			if (typeof id !== "string") throw new TypeError("Tree node keys must be strings.");
+			return pathProxy(nodes, address, owner, {
+				kind: "node",
+				id
+			});
+		};
+		if (treeSelection) throw new TypeError(`Invalid tree path segment: ${property}`);
+		if (nodes.every((node) => collectionEntryNode(node) !== void 0) && property === "item") return (id) => {
+			if (typeof id !== "string") throw new TypeError("Collection keys must be strings.");
+			for (const node of nodes) if (node.kind === "table" || node.kind === "map") {
+				const invalid = checkKey(node.key, id, [...address, id]);
+				if (invalid) throw new TypeError(invalid.message);
+			}
+			return pathProxy(nodes.map((node) => collectionEntryNode(node)), [...address, id], owner);
+		};
+		const children = nodes.flatMap((node) => {
+			if (node.kind === "object") return Object.hasOwn(node.shape, property) ? [node.shape[property]] : [];
+			if (node.kind !== "variant") return [];
+			if (property === node.tag) return [Object.freeze({ kind: "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,
+		...treeSelection ? { tree: treeSelection } : {}
+	});
+	return proxy;
+};
+const compilePath = (owner, kind, pick) => {
+	const scope = {};
+	const value = pick(pathProxy([owner], [], scope));
+	const selected = typeof value === "object" && value !== null ? paths.get(value) : void 0;
+	if (!selected || selected.owner !== scope) throw new TypeError("Selector must return a path from its callback.");
+	const collection = selected.tree?.kind === "nodes" || selected.nodes.every((node) => collectionEntryNode(node) !== void 0);
+	if (kind === "collection" && !collection) throw new TypeError("Collection selectors require a map, table, list or tree nodes path.");
+	return Object.freeze({
+		kind: kind === "auto" ? collection ? "collection" : "value" : kind,
+		schema: owner,
+		address: Object.freeze([...selected.address]),
+		...selected.tree ? { tree: Object.freeze({ ...selected.tree }) } : {}
+	});
+};
+//#endregion
 //#region core/src/address/relation.ts
 const contains = (parent, child) => {
 	profile.address.prefixComparison();
@@ -1194,7 +1668,7 @@ const installMember = (parent, key, present, value) => {
 		const index = Number(key);
 		if (present) if (index < 0) insert$2(parent, parent.length, value);
 		else parent[index] = value;
-		else if (index >= 0) remove$4(parent, index);
+		else if (index >= 0) remove$3(parent, index);
 	} else installOwn(parent, key, present, value);
 };
 const orderOf = (node, value) => {
@@ -1749,6 +2223,16 @@ function apply(session, changes, direction) {
 	}
 }
 //#endregion
+//#region core/src/runtime/readable.ts
+const readonlyDocument = (runtime) => {
+	const readable = {
+		revision: runtime.revision,
+		subscribe: runtime.subscribe
+	};
+	bindContext(readable, contextOf(runtime));
+	return Object.freeze(readable);
+};
+//#endregion
 //#region core/src/runtime/notification.ts
 const attachProjection = (notification, processor) => {
 	const entry = {
@@ -1912,18 +2396,19 @@ const createNotificationCenter = (schema) => {
 //#endregion
 //#region core/src/runtime.ts
 const createDocument = (input) => {
-	if (input.schema.kind !== "object") throw new TypeError("Document schema must be a root object node.");
-	const invalid = checkValue(input.schema, input.initial);
+	const schema = schemaNodeOf(input.schema);
+	const invalid = checkValue(schema, input.initial);
 	if (invalid) throw new ParseError(invalid);
 	const state = {
-		schema: input.schema,
-		document: copyValue(input.schema, input.initial),
+		schema,
+		document: copyValue(schema, input.initial),
 		disposed: false,
 		projectionLocks: 0
 	};
 	let revision = 0, busy = false;
-	const notifications = createNotificationCenter(input.schema);
+	const notifications = createNotificationCenter(schema);
 	let runtime, context;
+	let readonlyAlias;
 	const idle = () => {
 		if (state.disposed) throw new DocumentDisposedError();
 		if (busy || state.projectionLocks) throw new DocumentReentrancyError();
@@ -1956,7 +2441,7 @@ const createDocument = (input) => {
 			revision: ++revision,
 			source,
 			changes,
-			impact: createImpact(input.schema, changes)
+			impact: createImpact(schema, changes)
 		};
 		if (source === "remote") history.invalidate();
 		else if (recordHistory && (source === "local" || source === "system")) history.record(changes);
@@ -2003,6 +2488,7 @@ const createDocument = (input) => {
 	runtime = {
 		schema: input.schema,
 		revision: () => revision,
+		readonly: () => readonlyAlias ??= readonlyDocument(runtime),
 		update: (run, options) => {
 			const source = options?.source ?? "local";
 			let value;
@@ -2021,13 +2507,16 @@ const createDocument = (input) => {
 				value
 			};
 		},
-		apply: (inputChanges, options) => mutate({
-			kind: "apply",
-			source: options?.source ?? "local"
-		}, options?.history ?? true, (session) => {
-			if (!options || options.expectedRevision !== revision) fail([], "baseline-mismatch", "apply requires the current expectedRevision.");
-			apply(session, decodeChanges(inputChanges), "forward");
-		}),
+		apply: (inputChanges, options) => {
+			const source = options?.source ?? "local";
+			return mutate({
+				kind: "apply",
+				source
+			}, source === "remote" ? false : options?.history ?? true, (session) => {
+				if (!options || options.expectedRevision !== revision) fail([], "baseline-mismatch", "apply requires the current expectedRevision.");
+				apply(session, decodeChanges(inputChanges), "forward");
+			});
+		},
 		replace: (value, options) => {
 			const source = options?.source ?? "system";
 			return mutate({
@@ -2037,14 +2526,14 @@ const createDocument = (input) => {
 		},
 		snapshot: () => {
 			if (state.disposed) throw new DocumentDisposedError();
-			return copyValue(input.schema, state.document);
+			return copyValue(schema, state.document);
 		},
 		subscribe: ((pick, listener) => {
 			if (state.disposed) throw new DocumentDisposedError();
 			if (!listener) return notifications.subscribe(pick);
 			const picks = Array.isArray(pick) ? pick : [pick];
 			if (!picks.length) throw new TypeError("Expected at least one subscription path.");
-			return notifications.subscribeTargets(picks.map((p) => compilePath(input.schema, "value", p)), listener);
+			return notifications.subscribeTargets(picks.map((p) => compilePath(schema, "value", p)), listener);
 		}),
 		history: history.api,
 		dispose: () => {
@@ -2071,22 +2560,20 @@ const createDocument = (input) => {
 	return runtime;
 };
 //#endregion
-//#region core/src/runtime/readable.ts
-const asReadable = (runtime) => {
-	const readable = {
-		revision: runtime.revision,
-		subscribe: runtime.subscribe
-	};
-	bindContext(readable, contextOf(runtime));
-	return Object.freeze(readable);
-};
-//#endregion
 //#region core/src/access/dependency.ts
 const createDependencyTracker = () => {
 	const targets = [];
+	const buckets = /* @__PURE__ */ new Map();
 	return {
 		record: (value) => {
-			if (!targets.some((entry) => same(entry, value))) targets.push(value);
+			const key = dependencyBucket(value);
+			let entries = buckets.get(key);
+			if (!entries) {
+				entries = [];
+				buckets.set(key, entries);
+			} else if (entries.some((entry) => same(entry, value))) return;
+			entries.push(value);
+			targets.push(value);
 		},
 		snapshot: () => Object.freeze(targets.slice())
 	};
@@ -2175,6 +2662,281 @@ const select = (document, selector, equality = Object.is) => {
 	});
 };
 //#endregion
+//#region core/src/projection/input.ts
+const valueInput = (initial, equality = Object.is) => defineSource({
+	kind: "value-input",
+	initial,
+	equality
+}, {
+	kind: "value",
+	equality
+});
+const collectionInput = (initial = /* @__PURE__ */ new Map(), equality = Object.is) => {
+	const entries = /* @__PURE__ */ new Map();
+	for (const [key, value] of initial) {
+		if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+		entries.set(key, value);
+	}
+	return defineSource({
+		kind: "collection-input",
+		initial: entries,
+		equality
+	}, {
+		kind: "collection",
+		equality
+	});
+};
+const input = Object.assign(valueInput, { collection: collectionInput });
+//#endregion
+//#region core/src/projection/observe.ts
+function observe(source, selector) {
+	if (isExternalSource(source)) return source.kind === "collection" ? defineSource({
+		kind: "external-collection",
+		source
+	}, {
+		kind: "collection",
+		equality: Object.is
+	}) : defineSource({
+		kind: "external-value",
+		source,
+		equality: Object.is
+	}, {
+		kind: "value",
+		equality: Object.is
+	});
+	if ("current" in source && typeof source.current === "function") return defineSource({
+		kind: "readable",
+		readable: source,
+		equality: Object.is
+	}, {
+		kind: "value",
+		equality: Object.is
+	});
+	const document = source;
+	const state = contextOf(document).state;
+	const selected = selector ? compilePath(state.schema, "auto", selector) : Object.freeze({
+		kind: "value",
+		schema: state.schema,
+		address: Object.freeze([])
+	});
+	return defineSource({
+		kind: "document",
+		document,
+		selector: selected
+	}, {
+		kind: selected.kind,
+		equality: Object.is
+	});
+}
+const isExternalSource = (source) => {
+	if (!source || typeof source !== "object") return false;
+	const candidate = source;
+	return (candidate.kind === "value" || candidate.kind === "collection") && typeof candidate.current === "function" && typeof candidate.revision === "function" && typeof candidate.subscribe === "function";
+};
+//#endregion
+//#region core/src/projection/derive.ts
+const sourceValue = (source) => source.kind === "value" ? source.value : snapshotCollectionView(source.read);
+const outputKind = (projection) => {
+	const ref = projectionRef(projection);
+	const definition = ref.producer;
+	const output = definition.kind === "source" ? definition.output : definition.outputs[ref.output];
+	if (!output) throw new TypeError("Projection output does not exist.");
+	return output.kind;
+};
+const assertKeyedProjection = (projection, role) => {
+	if (outputKind(projection) !== "collection") throw new TypeError(`${role} must be a keyed collection projection.`);
+};
+const isKeyedDependency = (value) => {
+	if (!value || typeof value !== "object" || isProjection(value)) return false;
+	const candidate = value;
+	return isProjection(candidate.source) && typeof candidate.key === "function";
+};
+const bindKey = (index, outputKey, sourceKey) => {
+	const previous = index.forward.get(outputKey);
+	if (previous === sourceKey) return;
+	if (previous !== void 0) {
+		const dependents = index.reverse.get(previous);
+		dependents?.delete(outputKey);
+		if (dependents?.size === 0) index.reverse.delete(previous);
+		index.forward.delete(outputKey);
+	}
+	if (sourceKey === void 0) return;
+	index.forward.set(outputKey, sourceKey);
+	const dependents = index.reverse.get(sourceKey);
+	if (dependents) dependents.add(outputKey);
+	else index.reverse.set(sourceKey, new Set([outputKey]));
+};
+const unbindKey = (indexes, outputKey) => {
+	for (const index of indexes) bindKey(index, outputKey, void 0);
+};
+const createBindingIndex = () => ({
+	forward: /* @__PURE__ */ new Map(),
+	reverse: /* @__PURE__ */ new Map()
+});
+function createValueDerive(dependencies, compute, equality = Object.is) {
+	if (!isPlainObject(dependencies) || isProjection(dependencies)) throw new TypeError("Derive dependencies must be a plain object.");
+	const names = Object.keys(dependencies);
+	const ordered = names.map((name) => dependencies[name]);
+	ordered.forEach(projectionRef);
+	const [projection] = defineProcessor({
+		dependencies: ordered,
+		outputs: [{
+			kind: "value",
+			equality
+		}],
+		create: () => ({ evaluate: (evaluation) => {
+			const output = evaluation.outputs[0];
+			if (output.kind !== "value") throw new Error("derive requires a value output.");
+			const values = Object.create(null);
+			for (let index = 0; index < names.length; index++) values[names[index]] = sourceValue(evaluation.sources[index]);
+			const next = compute(Object.freeze(values));
+			assertSynchronous(next);
+			output.output.set(next);
+		} })
+	});
+	return projection;
+}
+function createKeyedDerive(source, dependenciesOrSelect, selectOrEquality, maybeEquality) {
+	assertKeyedProjection(source, "Keyed derive source");
+	const dependencySpecs = typeof dependenciesOrSelect === "function" ? void 0 : dependenciesOrSelect;
+	const select = dependencySpecs === void 0 ? dependenciesOrSelect : selectOrEquality;
+	const equality = dependencySpecs === void 0 ? selectOrEquality : maybeEquality;
+	if (typeof select !== "function") throw new TypeError("Keyed derive requires a selector.");
+	const dependencies = [source];
+	const dependencyNames = [];
+	const keyed = [];
+	if (dependencySpecs !== void 0) {
+		if (!isPlainObject(dependencySpecs) || isProjection(dependencySpecs)) throw new TypeError("Keyed derive dependencies must be a plain object.");
+		for (const name of Reflect.ownKeys(dependencySpecs)) {
+			if (typeof name !== "string") throw new TypeError("Keyed derive dependency names must be strings.");
+			const descriptor = Object.getOwnPropertyDescriptor(dependencySpecs, name);
+			if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError("Keyed derive dependencies must be enumerable data properties.");
+			const dependency = descriptor.value;
+			dependencyNames.push(name);
+			if (isProjection(dependency)) {
+				dependencies.push(dependency);
+				keyed.push(void 0);
+				continue;
+			}
+			if (!isKeyedDependency(dependency)) throw new TypeError("Keyed derive dependencies must be projections or keyed lookups.");
+			assertKeyedProjection(dependency.source, "Dynamic keyed dependency source");
+			dependencies.push(dependency.source);
+			keyed.push(dependency);
+		}
+	}
+	const [projection] = defineProcessor({
+		dependencies,
+		outputs: [{
+			kind: "collection",
+			equality: equality ?? Object.is
+		}],
+		create: () => {
+			const bindings = keyed.map((dependency) => dependency ? createBindingIndex() : void 0);
+			const bindingIndexes = bindings.filter((index) => index !== void 0);
+			const globalValues = keyed.map(() => void 0);
+			let revisions = Object.freeze([]);
+			const clearBindings = () => {
+				for (const index of bindings) {
+					index?.forward.clear();
+					index?.reverse.clear();
+				}
+			};
+			return {
+				evaluate: (evaluation) => {
+					const driver = evaluation.sources[0];
+					const output = evaluation.outputs[0];
+					if (driver.kind !== "collection" || output.kind !== "collection") throw new Error("Keyed derive requires collection input and output.");
+					const currentRevisions = evaluation.sources.map((current) => current.revision);
+					for (let index = 0; index < keyed.length; index++) {
+						if (keyed[index]) continue;
+						if (evaluation.reset || revisions[index + 1] !== currentRevisions[index + 1]) globalValues[index] = sourceValue(evaluation.sources[index + 1]);
+					}
+					const project = (key) => {
+						if (!driver.read.has(key)) return;
+						const value = driver.read.get(key);
+						const dependencyValues = Object.create(null);
+						for (let index = 0; index < keyed.length; index++) {
+							const dependency = keyed[index];
+							if (!dependency) {
+								dependencyValues[dependencyNames[index]] = globalValues[index];
+								continue;
+							}
+							const sourceContext = evaluation.sources[index + 1];
+							if (sourceContext.kind !== "collection") throw new TypeError("Dynamic keyed dependency resolved to a non-collection source.");
+							const selectedKey = dependency.key(value, key);
+							assertSynchronous(selectedKey);
+							if (selectedKey !== void 0 && typeof selectedKey !== "string") throw new TypeError("Dynamic keyed dependency keys must be strings or undefined.");
+							bindKey(bindings[index], key, selectedKey);
+							dependencyValues[dependencyNames[index]] = selectedKey === void 0 ? void 0 : sourceContext.read.get(selectedKey);
+						}
+						const next = dependencySpecs === void 0 ? select(value, key) : select(value, key, Object.freeze(dependencyValues));
+						assertSynchronous(next);
+						output.output.set(key, next);
+					};
+					if (evaluation.reset) {
+						clearBindings();
+						const ids = driver.read.ids();
+						for (const key of ids) project(key);
+						output.output.order(ids);
+						revisions = Object.freeze(currentRevisions);
+						return;
+					}
+					const dirty = /* @__PURE__ */ new Set();
+					let all = false;
+					let updateOrder = false;
+					if (revisions[0] !== currentRevisions[0]) {
+						const change = driver.change;
+						if (!change || change.kind === "reset") {
+							all = true;
+							updateOrder = true;
+						} else {
+							for (const entry of change.removed) {
+								output.output.remove(entry.key);
+								unbindKey(bindingIndexes, entry.key);
+								dirty.delete(entry.key);
+							}
+							for (const entry of change.added) dirty.add(entry.key);
+							for (const entry of change.updated) dirty.add(entry.key);
+							updateOrder = Boolean(change.added.length || change.removed.length || change.order);
+						}
+					}
+					for (let index = 0; index < keyed.length; index++) {
+						if (revisions[index + 1] === currentRevisions[index + 1]) continue;
+						if (!keyed[index]) {
+							all = true;
+							continue;
+						}
+						const sourceContext = evaluation.sources[index + 1];
+						if (sourceContext.kind !== "collection" || !sourceContext.change) {
+							all = true;
+							continue;
+						}
+						if (sourceContext.change.kind === "reset") {
+							all = true;
+							continue;
+						}
+						const reverse = bindings[index].reverse;
+						for (const transition of sourceContext.change.added) for (const outputKey of reverse.get(transition.key) ?? []) dirty.add(outputKey);
+						for (const transition of sourceContext.change.updated) for (const outputKey of reverse.get(transition.key) ?? []) dirty.add(outputKey);
+						for (const transition of sourceContext.change.removed) for (const outputKey of reverse.get(transition.key) ?? []) dirty.add(outputKey);
+					}
+					if (all) for (const key of driver.read.ids()) dirty.add(key);
+					for (const key of dirty) if (driver.read.has(key)) project(key);
+					if (updateOrder) output.output.order(driver.read.ids());
+					revisions = Object.freeze(currentRevisions);
+				},
+				release: () => {
+					clearBindings();
+					revisions = Object.freeze([]);
+				}
+			};
+		},
+		name: "derive.keyed"
+	});
+	return projection;
+}
+const derive = Object.assign(createValueDerive, { keyed: createKeyedDerive });
+//#endregion
 //#region core/src/projection/collection/change.ts
 const commonOrderChanged = (before, after, added, removed) => {
 	const beforeCommon = before.filter((key) => !removed.has(key));
@@ -2373,7 +3135,7 @@ const createPublishedCollection = () => {
 	};
 };
 /** Owns staged keyed intent, exact transitions and published collection state. */
-const createCollectionOutput = () => {
+const createCollectionOutput = (binding) => {
 	const published = createPublishedCollection();
 	let staged = /* @__PURE__ */ new Map();
 	let nextIds = published.ids();
@@ -2384,6 +3146,7 @@ const createCollectionOutput = () => {
 	let explicitOrder;
 	let cleared = false;
 	const listeners = /* @__PURE__ */ new Set();
+	const consumers = /* @__PURE__ */ new Set();
 	const hasNext = (key) => staged.has(key) ? staged.get(key).present : !cleared && published.has(key);
 	const getNext = (key) => {
 		const entry = staged.get(key);
@@ -2461,11 +3224,10 @@ const createCollectionOutput = () => {
 			if (new Set(order).size !== order.length || order.length !== published.size() + added.size - removed.size || order.some((key) => !hasNext(key))) throw new TypeError("Projection order must contain every key exactly once.");
 			nextIds = ids.length === order.length && ids.every((key, index) => key === order[index]) ? ids : Object.freeze([...order]);
 		} else nextIds = ids;
-		const changedKeys = new Set([
-			...added,
-			...removed,
-			...updated
-		]);
+		const changedKeys = /* @__PURE__ */ new Set();
+		added.forEach((key) => changedKeys.add(key));
+		removed.forEach((key) => changedKeys.add(key));
+		updated.forEach((key) => changedKeys.add(key));
 		profile.projection("changedKeys", changedKeys.size);
 		const addedEntries = [];
 		const updatedEntries = [];
@@ -2474,7 +3236,8 @@ const createCollectionOutput = () => {
 			const beforePresent = published.has(key);
 			const afterPresent = hasNext(key);
 			if (beforePresent === afterPresent) {
-				if (!beforePresent || isEqual(published.get(key), getNext(key))) continue;
+				if (!beforePresent) continue;
+				if (isEqual !== Object.is && isEqual(published.get(key), getNext(key))) continue;
 			}
 			if (!beforePresent) addedEntries.push({
 				key,
@@ -2522,10 +3285,14 @@ const createCollectionOutput = () => {
 		cause
 	});
 	return {
+		kind: "collection",
+		get owner() {
+			return binding.owner();
+		},
 		begin,
 		seal,
-		context,
-		current: (check) => published.read(check),
+		context: (active) => context(active, binding.cause()),
+		current: () => published.read(binding.check),
 		revision: () => revision,
 		reset: () => reset,
 		publish: () => {
@@ -2534,9 +3301,12 @@ const createCollectionOutput = () => {
 			initialized = true;
 		},
 		emit: (call) => {
-			const resetEvent = Object.freeze({ kind: "reset" });
-			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
+			Array.from(listeners).forEach((listener) => call(listener));
 		},
+		hasConsumers: () => consumers.size > 0,
+		forEachConsumer: (run) => consumers.forEach(run),
+		attachConsumer: (consumer) => consumers.add(consumer),
+		detachConsumer: (consumer) => consumers.delete(consumer),
 		clear: () => {
 			staged.clear();
 			nextIds = published.ids();
@@ -2549,6 +3319,7 @@ const createCollectionOutput = () => {
 			published.release();
 			staged.clear();
 			listeners.clear();
+			consumers.clear();
 			nextIds = Object.freeze([]);
 			change = void 0;
 			initialized = false;
@@ -2557,15 +3328,18 @@ const createCollectionOutput = () => {
 			explicitOrder = void 0;
 			cleared = false;
 		},
-		subscribe: (listener) => listeners.add(listener),
-		unsubscribe: (listener) => listeners.delete(listener)
+		subscribe: (listener) => {
+			binding.check();
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
 	};
 };
 //#endregion
 //#region core/src/projection/output/value.ts
 const unset = Symbol("projection-value-unset");
 /** Owns staged and published state for one scalar Projection output. */
-const createValueOutput = () => {
+const createValueOutput = (binding) => {
 	let value;
 	let staged = unset;
 	let next;
@@ -2574,6 +3348,7 @@ const createValueOutput = () => {
 	let changed = false;
 	let reset = false;
 	const listeners = /* @__PURE__ */ new Set();
+	const consumers = /* @__PURE__ */ new Set();
 	const begin = (active, initialize) => {
 		staged = unset;
 		next = value;
@@ -2607,20 +3382,24 @@ const createValueOutput = () => {
 		return changed;
 	};
 	return {
+		kind: "value",
+		get owner() {
+			return binding.owner();
+		},
 		begin,
 		seal,
-		context: (active, cause) => {
+		context: (active) => {
 			assertScope(active);
 			return Object.freeze({
 				kind: "value",
 				value: next,
 				revision,
 				reset,
-				cause
+				cause: binding.cause()
 			});
 		},
-		current: (check) => {
-			check();
+		current: () => {
+			binding.check();
 			return value;
 		},
 		revision: () => revision,
@@ -2634,6 +3413,10 @@ const createValueOutput = () => {
 			profile.materialized.notification();
 			Array.from(listeners).forEach((listener) => call(listener));
 		},
+		hasConsumers: () => consumers.size > 0,
+		forEachConsumer: (run) => consumers.forEach(run),
+		attachConsumer: (consumer) => consumers.add(consumer),
+		detachConsumer: (consumer) => consumers.delete(consumer),
 		clear: () => {
 			staged = unset;
 			next = value;
@@ -2642,6 +3425,7 @@ const createValueOutput = () => {
 		},
 		release: () => {
 			listeners.clear();
+			consumers.clear();
 			staged = unset;
 			value = next = void 0;
 			initialized = false;
@@ -2649,8 +3433,11 @@ const createValueOutput = () => {
 			changed = false;
 			reset = false;
 		},
-		subscribe: (listener) => listeners.add(listener),
-		unsubscribe: (listener) => listeners.delete(listener)
+		subscribe: (listener) => {
+			binding.check();
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		}
 	};
 };
 //#endregion
@@ -2666,59 +3453,23 @@ const createProcessor = (scheduler, definition, dependencies) => {
 		if (processor.fault) throw processor.fault;
 	};
 	const bound = definition.outputs.map((outputDefinition) => {
-		if (outputDefinition.kind === "value") {
-			const state = createValueOutput();
-			return {
-				kind: "value",
-				definition: outputDefinition,
-				state,
-				output: {
-					kind: "value",
-					get owner() {
-						return processor;
-					},
-					consumers: /* @__PURE__ */ new Set(),
-					context: (active) => state.context(active, cause),
-					current: () => state.current(check),
-					revision: state.revision,
-					reset: state.reset,
-					subscribe: (listener) => {
-						check();
-						const wrapped = () => listener();
-						state.subscribe(wrapped);
-						return () => state.unsubscribe(wrapped);
-					},
-					emit: state.emit,
-					clear: state.clear,
-					release: state.release
-				}
-			};
-		}
-		const state = createCollectionOutput();
+		if (outputDefinition.kind === "value") return {
+			kind: "value",
+			definition: outputDefinition,
+			state: createValueOutput({
+				owner: () => processor,
+				check,
+				cause: () => cause
+			})
+		};
 		return {
 			kind: "collection",
 			definition: outputDefinition,
-			state,
-			output: {
-				kind: "collection",
-				get owner() {
-					return processor;
-				},
-				consumers: /* @__PURE__ */ new Set(),
-				context: (active) => state.context(active, cause),
-				current: () => state.current(check),
-				revision: state.revision,
-				reset: state.reset,
-				subscribe: (listener) => {
-					check();
-					const wrapped = (change) => listener(change);
-					state.subscribe(wrapped);
-					return () => state.unsubscribe(wrapped);
-				},
-				emit: state.emit,
-				clear: state.clear,
-				release: state.release
-			}
+			state: createCollectionOutput({
+				owner: () => processor,
+				check,
+				cause: () => cause
+			})
 		};
 	});
 	const begin = (active, initialize) => Object.freeze(bound.map((entry) => {
@@ -2737,40 +3488,28 @@ const createProcessor = (scheduler, definition, dependencies) => {
 	}));
 	const seal = (reset) => {
 		const changed = [];
-		for (const entry of bound) if (entry.state.seal(reset, entry.definition.equality)) changed.push(entry.output);
+		for (const entry of bound) if (entry.state.seal(reset, entry.definition.equality)) changed.push(entry.state);
 		return Object.freeze(changed);
 	};
-	const run = (reset, runCause) => {
+	const run = (reset, runCause, recreate = false) => {
 		cause = runCause;
 		let active = true;
 		try {
 			const scopeActive = () => active;
 			const sources = Object.freeze(dependencies.map((output) => output.context(scopeActive)));
-			let outputs = begin(scopeActive, reset);
+			const outputs = begin(scopeActive, reset);
+			if (recreate && instance) {
+				instance.release?.();
+				instance = void 0;
+			}
 			if (!instance) instance = definition.create();
 			profile.materialized[reset ? "rebuilt" : "updated"]();
-			let result = instance.evaluate({
+			assertSynchronous(instance.evaluate({
 				reset,
 				cause: runCause,
 				sources,
 				outputs
-			});
-			assertSynchronous(result);
-			if (result?.kind === "rebuild") {
-				if (reset) throw new TypeError("Initial or reset projection processor cannot rebuild.");
-				instance.release?.();
-				instance = definition.create();
-				outputs = begin(scopeActive, true);
-				result = instance.evaluate({
-					reset: true,
-					cause: runCause,
-					sources,
-					outputs
-				});
-				assertSynchronous(result);
-				if (result?.kind === "rebuild") throw new TypeError("Reset projection processor cannot rebuild again.");
-				return seal(true);
-			}
+			}));
 			return seal(reset);
 		} finally {
 			active = false;
@@ -2782,7 +3521,7 @@ const createProcessor = (scheduler, definition, dependencies) => {
 		order,
 		name: definition.name ? `${definition.name} (${order})` : `projection-${order}`,
 		dependencies: Object.freeze([...dependencies]),
-		outputs: Object.freeze(bound.map((entry) => entry.output)),
+		outputs: Object.freeze(bound.map((entry) => entry.state)),
 		fault: void 0,
 		disposed: false,
 		evaluate: run,
@@ -2792,13 +3531,21 @@ const createProcessor = (scheduler, definition, dependencies) => {
 			cause = void 0;
 		},
 		release: () => {
-			instance?.release?.();
+			const current = instance;
 			instance = void 0;
-			bound.forEach((entry) => {
-				entry.output.consumers.clear();
+			const failures = [];
+			try {
+				current?.release?.();
+			} catch (error) {
+				failures.push(error);
+			}
+			for (const entry of bound) try {
 				entry.state.release();
-			});
+			} catch (error) {
+				failures.push(error);
+			}
 			cause = void 0;
+			if (failures.length) throw failures[0];
 		}
 	};
 	try {
@@ -2808,11 +3555,14 @@ const createProcessor = (scheduler, definition, dependencies) => {
 			if (processor.evaluate(true, void 0).length) processor.publish();
 			processor.clear();
 		});
+		scheduler.addProcessor(processor);
 	} catch (error) {
-		processor.release();
+		processor.disposed = true;
+		try {
+			processor.release();
+		} catch {}
 		throw error;
 	}
-	scheduler.addProcessor(processor);
 	return processor;
 };
 //#endregion
@@ -2978,53 +3728,7 @@ const createSelectorReadable = (source, selector, equality = Object.is) => {
 };
 //#endregion
 //#region core/src/projection/source/materialization.ts
-const createDocumentDirty = () => ({
-	replace: false,
-	order: false,
-	treeRoot: false,
-	treeNodes: /* @__PURE__ */ new Set(),
-	children: /* @__PURE__ */ new Map()
-});
-const clearDocumentDirty = (dirty) => {
-	dirty.replace = false;
-	dirty.order = false;
-	dirty.treeRoot = false;
-	dirty.treeNodes.clear();
-	dirty.children.clear();
-};
 const hasDocumentDirty = (dirty) => dirty.replace || dirty.order || dirty.treeRoot || dirty.treeNodes.size > 0 || dirty.children.size > 0;
-const locate = (dirty, path) => {
-	let current = dirty;
-	for (const key of path) {
-		if (current.replace) return void 0;
-		let child = current.children.get(key);
-		if (!child) {
-			child = createDocumentDirty();
-			current.children.set(key, child);
-		}
-		current = child;
-	}
-	return current;
-};
-const markDocumentReplace = (dirty, path) => {
-	const current = locate(dirty, path);
-	if (!current) return;
-	current.replace = true;
-	current.order = false;
-	current.treeRoot = false;
-	current.treeNodes.clear();
-	current.children.clear();
-};
-const markDocumentOrder = (dirty, path) => {
-	const current = locate(dirty, path);
-	if (current && !current.replace) current.order = true;
-};
-const markDocumentTree = (dirty, path, root, nodes) => {
-	const current = locate(dirty, path);
-	if (!current || current.replace) return;
-	current.treeRoot ||= root;
-	for (const id of nodes) current.treeNodes.add(id);
-};
 const equivalent = (node, left, right) => node.kind === "field" ? Object.is(left, right) : equalValue(node, left, right);
 const replaceValue = (node, previous, current) => equivalent(node, previous, current) ? previous : copyValue(node, current);
 const cloneRecord = (value) => {
@@ -3187,6 +3891,52 @@ const materializeDocumentValue = (node, previous, current, dirty) => {
 };
 //#endregion
 //#region core/src/projection/source/dirty.ts
+const createDocumentDirty = () => ({
+	replace: false,
+	order: false,
+	treeRoot: false,
+	treeNodes: /* @__PURE__ */ new Set(),
+	children: /* @__PURE__ */ new Map()
+});
+const clearDocumentDirty = (dirty) => {
+	dirty.replace = false;
+	dirty.order = false;
+	dirty.treeRoot = false;
+	dirty.treeNodes.clear();
+	dirty.children.clear();
+};
+const locate = (dirty, path) => {
+	let current = dirty;
+	for (const key of path) {
+		if (current.replace) return void 0;
+		let child = current.children.get(key);
+		if (!child) {
+			child = createDocumentDirty();
+			current.children.set(key, child);
+		}
+		current = child;
+	}
+	return current;
+};
+const markDocumentReplace = (dirty, path) => {
+	const current = locate(dirty, path);
+	if (!current) return;
+	current.replace = true;
+	current.order = false;
+	current.treeRoot = false;
+	current.treeNodes.clear();
+	current.children.clear();
+};
+const markDocumentOrder = (dirty, path) => {
+	const current = locate(dirty, path);
+	if (current && !current.replace) current.order = true;
+};
+const markDocumentTree = (dirty, path, root, nodes) => {
+	const current = locate(dirty, path);
+	if (!current || current.replace) return;
+	current.treeRoot ||= root;
+	for (const id of nodes) current.treeNodes.add(id);
+};
 const createCollectionPending = () => ({
 	reset: false,
 	order: false,
@@ -3288,9 +4038,8 @@ const mergeCollectionChanges = (selector, pending, changes) => {
 };
 //#endregion
 //#region core/src/projection/source/boundary.ts
-const sourceError = (source, cause) => new ProjectionError("source", source.name, [source.outputs[0].revision()], cause);
+const sourceError = (cause) => new ProjectionError("source", cause);
 const createValueBoundary = (scheduler, name, initial, equality, prepare, clearSource) => {
-	const state = createValueOutput();
 	let boundary;
 	let pendingReset = false;
 	let pendingCause;
@@ -3301,26 +4050,12 @@ const createValueBoundary = (scheduler, name, initial, equality, prepare, clearS
 		if (!scheduler.active || boundary.disposed) throw new ProjectionDisposedError();
 		if (boundary.fault) throw boundary.fault;
 	};
-	const output = {
-		kind: "value",
-		get owner() {
-			return boundary;
-		},
-		consumers: /* @__PURE__ */ new Set(),
-		context: (active) => state.context(active, contextCause),
-		current: () => state.current(check),
-		revision: state.revision,
-		reset: state.reset,
-		subscribe: (listener) => {
-			check();
-			const wrapped = () => listener();
-			state.subscribe(wrapped);
-			return () => state.unsubscribe(wrapped);
-		},
-		emit: state.emit,
-		clear: state.clear,
-		release: state.release
-	};
+	const state = createValueOutput({
+		owner: () => boundary,
+		check,
+		cause: () => contextCause
+	});
+	const output = state;
 	boundary = {
 		kind: "source",
 		name,
@@ -3356,24 +4091,42 @@ const createValueBoundary = (scheduler, name, initial, equality, prepare, clearS
 			clearSource(failed);
 		},
 		release: () => {
-			cleanup?.();
+			const detach = cleanup;
 			cleanup = void 0;
-			state.release();
-			output.consumers.clear();
+			const failures = [];
+			try {
+				detach?.();
+			} catch (error) {
+				failures.push(error);
+			}
+			try {
+				state.release();
+			} catch (error) {
+				failures.push(error);
+			}
+			if (failures.length) throw failures[0];
 		}
 	};
-	scheduler.initialize(() => {
-		let active = true;
+	try {
+		scheduler.initialize(() => {
+			let active = true;
+			try {
+				state.begin(() => active, true).output.set(initial);
+				state.seal(true, equality);
+				state.publish();
+				state.clear();
+			} finally {
+				active = false;
+			}
+		});
+		scheduler.addSource(boundary);
+	} catch (error) {
+		boundary.disposed = true;
 		try {
-			state.begin(() => active, true).output.set(initial);
-			state.seal(true, equality);
-			state.publish();
-			state.clear();
-		} finally {
-			active = false;
-		}
-	});
-	scheduler.addSource(boundary);
+			boundary.release();
+		} catch {}
+		throw error;
+	}
 	const mark = (metadata = {}) => {
 		scheduler.assertIdle();
 		pendingReset ||= metadata.reset ?? false;
@@ -3382,7 +4135,7 @@ const createValueBoundary = (scheduler, name, initial, equality, prepare, clearS
 		scheduler.capture(boundary);
 	};
 	const fail = (cause) => {
-		boundary.fault = sourceError(boundary, cause);
+		boundary.fault = sourceError(cause);
 		recovering = false;
 		scheduler.capture(boundary);
 	};
@@ -3408,7 +4161,7 @@ const stageCollectionRead = (state, read, active, options) => {
 		}
 		evaluation.output.order(ids);
 	} else {
-		const previous = state.current(() => void 0);
+		const previous = state.current();
 		const keys = options.candidates ? [...new Set(options.candidates)] : [...new Set([...previous.ids(), ...read.ids()])];
 		if (!options.candidates) profile.collectionView.idsScanned(keys.length);
 		for (const key of keys) if (read.has(key)) {
@@ -3424,7 +4177,6 @@ const stageCollectionRead = (state, read, active, options) => {
 	return state.seal(options.reset, options.isEqual ?? Object.is);
 };
 const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSource) => {
-	const state = createCollectionOutput();
 	let boundary;
 	let pendingReset = false;
 	let pendingCause;
@@ -3438,26 +4190,12 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 		if (!scheduler.active || boundary.disposed) throw new ProjectionDisposedError();
 		if (boundary.fault) throw boundary.fault;
 	};
-	const output = {
-		kind: "collection",
-		get owner() {
-			return boundary;
-		},
-		consumers: /* @__PURE__ */ new Set(),
-		context: (active) => state.context(active, contextCause),
-		current: () => state.current(check),
-		revision: state.revision,
-		reset: state.reset,
-		subscribe: (listener) => {
-			check();
-			const wrapped = (change) => listener(change);
-			state.subscribe(wrapped);
-			return () => state.unsubscribe(wrapped);
-		},
-		emit: state.emit,
-		clear: state.clear,
-		release: state.release
-	};
+	const state = createCollectionOutput({
+		owner: () => boundary,
+		check,
+		cause: () => contextCause
+	});
+	const output = state;
 	boundary = {
 		kind: "source",
 		name,
@@ -3470,7 +4208,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 			contextCause = cause;
 			let active = true;
 			try {
-				const changed = stageCollectionRead(state, readLatest(() => active, state.current(() => void 0)), () => active, {
+				const changed = stageCollectionRead(state, readLatest(() => active, state.current()), () => active, {
 					reset: pendingReset,
 					...fullScan ? {} : { candidates },
 					orderMayChange,
@@ -3499,26 +4237,44 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 			clearSource(failed);
 		},
 		release: () => {
-			cleanup?.();
+			const detach = cleanup;
 			cleanup = void 0;
-			state.release();
-			output.consumers.clear();
+			const failures = [];
+			try {
+				detach?.();
+			} catch (error) {
+				failures.push(error);
+			}
+			try {
+				state.release();
+			} catch (error) {
+				failures.push(error);
+			}
+			if (failures.length) throw failures[0];
 		}
 	};
-	scheduler.initialize(() => {
-		let active = true;
+	try {
+		scheduler.initialize(() => {
+			let active = true;
+			try {
+				stageCollectionRead(state, readLatest(() => active, state.current()), () => active, {
+					reset: true,
+					isEqual: equality
+				});
+				state.publish();
+				state.clear();
+			} finally {
+				active = false;
+			}
+		});
+		scheduler.addSource(boundary);
+	} catch (error) {
+		boundary.disposed = true;
 		try {
-			stageCollectionRead(state, readLatest(() => active, state.current(() => void 0)), () => active, {
-				reset: true,
-				isEqual: equality
-			});
-			state.publish();
-			state.clear();
-		} finally {
-			active = false;
-		}
-	});
-	scheduler.addSource(boundary);
+			boundary.release();
+		} catch {}
+		throw error;
+	}
 	const mark = (metadata = {}) => {
 		scheduler.assertIdle();
 		pendingReset ||= metadata.reset ?? false;
@@ -3530,7 +4286,7 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 		scheduler.capture(boundary);
 	};
 	const fail = (cause) => {
-		boundary.fault = sourceError(boundary, cause);
+		boundary.fault = sourceError(cause);
 		recovering = false;
 		scheduler.capture(boundary);
 	};
@@ -3564,14 +4320,19 @@ const createDocumentSourceRegistry = (scheduler) => {
 		const guard = (locked) => {
 			state.projectionLocks += locked ? 1 : -1;
 		};
-		scheduler.guards.add(guard);
+		let unregisterGuard = scheduler.registerGuard(guard);
 		let closed = false;
-		let detach = () => void 0;
+		let detach;
 		const documentConnection = {
 			add(binding) {
 				if (closed) throw new Error("Document projection connection is closed.");
 				bindings.add(binding);
-				index.add(binding.target, binding);
+				try {
+					index.add(binding.target, binding);
+				} catch (error) {
+					bindings.delete(binding);
+					throw error;
+				}
 				let active = true;
 				return () => {
 					if (!active) return;
@@ -3584,27 +4345,58 @@ const createDocumentSourceRegistry = (scheduler) => {
 			close() {
 				if (closed) return;
 				closed = true;
-				detach();
+				const stopNotifications = detach;
+				detach = void 0;
+				const stopGuard = unregisterGuard;
+				unregisterGuard = () => void 0;
 				bindings.clear();
 				candidates.clear();
 				index.clear();
-				scheduler.guards.delete(guard);
 				documents.delete(state);
+				const failures = [];
+				try {
+					stopNotifications?.();
+				} catch (error) {
+					failures.push(error);
+				}
+				try {
+					stopGuard();
+				} catch (error) {
+					failures.push(error);
+				}
+				if (failures.length) throw failures[0];
 			}
 		};
-		detach = context.notifications.attachProjection({
-			capture: (commit) => {
-				candidates.clear();
-				index.collect(commit.changes, (binding) => candidates.add(binding));
-				candidates.forEach((binding) => binding.capture(commit));
-			},
-			settle: scheduler.settle,
-			flush: scheduler.flush,
-			dispose: () => {
-				for (const binding of bindings) binding.dispose();
-				scheduler.run();
-			}
-		});
+		try {
+			detach = context.notifications.attachProjection({
+				capture: (commit) => {
+					candidates.clear();
+					index.collect(commit.changes, (binding) => candidates.add(binding));
+					candidates.forEach((binding) => binding.capture(commit));
+				},
+				settle: scheduler.settle,
+				flush: scheduler.flush,
+				dispose: () => {
+					const failures = [];
+					for (const binding of [...bindings]) try {
+						binding.dispose();
+					} catch (error) {
+						failures.push(error);
+					}
+					try {
+						scheduler.run();
+					} catch (error) {
+						failures.push(error);
+					}
+					if (failures.length) throw failures[0];
+				}
+			});
+		} catch (error) {
+			try {
+				documentConnection.close();
+			} catch {}
+			throw error;
+		}
 		documents.set(state, documentConnection);
 		return documentConnection;
 	};
@@ -3639,18 +4431,26 @@ const createDocumentSourceRegistry = (scheduler) => {
 				if (failed) markDocumentReplace(dirty, []);
 				else clearDocumentDirty(dirty);
 			});
-			const remove = connection(document).add({
-				target: selector,
-				capture: (commit) => {
-					try {
-						mergeValueChanges(selector, dirty, commit.changes);
-						boundary.mark({ reset: commit.changes.changes.some((change) => change.kind === "reset") });
-					} catch (cause) {
-						boundary.fail(cause);
-					}
-				},
-				dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
-			});
+			let remove;
+			try {
+				remove = connection(document).add({
+					target: selector,
+					capture: (commit) => {
+						try {
+							mergeValueChanges(selector, dirty, commit.changes);
+							boundary.mark({ reset: commit.changes.changes.some((change) => change.kind === "reset") });
+						} catch (cause) {
+							boundary.fail(cause);
+						}
+					},
+					dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
+				});
+			} catch (error) {
+				try {
+					scheduler.releaseProducer(boundary.producer);
+				} catch {}
+				throw error;
+			}
 			boundary.detach(remove);
 			return boundary;
 		}
@@ -3721,22 +4521,30 @@ const createDocumentSourceRegistry = (scheduler) => {
 			if (failed) resetCollectionPending(pending);
 			else clearCollectionPending(pending);
 		});
-		const remove = connection(document).add({
-			target: selector,
-			capture: (commit) => {
-				try {
-					mergeCollectionChanges(selector, pending, commit.changes);
-					boundary.mark({
-						reset: pending.reset,
-						...pending.reset ? {} : { candidates: pending.entries.keys() },
-						orderMayChange: pending.order
-					});
-				} catch (cause) {
-					boundary.fail(cause);
-				}
-			},
-			dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
-		});
+		let remove;
+		try {
+			remove = connection(document).add({
+				target: selector,
+				capture: (commit) => {
+					try {
+						mergeCollectionChanges(selector, pending, commit.changes);
+						boundary.mark({
+							reset: pending.reset,
+							...pending.reset ? {} : { candidates: pending.entries.keys() },
+							orderMayChange: pending.order
+						});
+					} catch (cause) {
+						boundary.fail(cause);
+					}
+				},
+				dispose: () => boundary.fail(/* @__PURE__ */ new Error("Document has been disposed."))
+			});
+		} catch (error) {
+			try {
+				scheduler.releaseProducer(boundary.producer);
+			} catch {}
+			throw error;
+		}
 		boundary.detach(remove);
 		return boundary;
 	};
@@ -3750,115 +4558,23 @@ const createDocumentSourceRegistry = (scheduler) => {
 			});
 		},
 		dispose() {
-			documents.forEach((document) => document.close());
+			const failures = [];
+			for (const document of [...documents.values()]) try {
+				document.close();
+			} catch (error) {
+				failures.push(error);
+			}
 			documents.clear();
+			if (failures.length) throw failures[0];
 		}
 	};
 };
 //#endregion
-//#region core/src/projection/source/registry.ts
-const createSourceRegistry = (scheduler) => {
-	const documents = createDocumentSourceRegistry(scheduler);
+//#region core/src/projection/source/external.ts
+const createExternalSourceRegistry = (scheduler, documents) => {
 	const readables = /* @__PURE__ */ new Map();
-	const externalValues = /* @__PURE__ */ new WeakMap();
-	const externalCollections = /* @__PURE__ */ new WeakMap();
-	const valueInput = (definition) => {
-		if (definition.source.kind !== "value-input") throw new Error("Invalid value input source.");
-		const source = definition.source;
-		let latest = source.initial;
-		const boundary = createValueBoundary(scheduler, "projection input", source.initial, source.equality, () => latest, () => void 0);
-		return {
-			...boundary,
-			write: {
-				kind: "value",
-				set(value) {
-					scheduler.assertIdle();
-					latest = value;
-					boundary.mark();
-					scheduler.run();
-				}
-			}
-		};
-	};
-	const collectionInput = (definition) => {
-		if (definition.source.kind !== "collection-input") throw new Error("Invalid collection input source.");
-		const values = new Map(definition.source.initial);
-		const boundary = createCollectionBoundary(scheduler, "projection collection input", () => mapRead(values), definition.output.equality, () => void 0);
-		return {
-			...boundary,
-			write: {
-				kind: "collection",
-				update(run) {
-					scheduler.assertIdle();
-					const staged = /* @__PURE__ */ new Map();
-					const operations = [];
-					let active = true;
-					const draft = Object.freeze({
-						get: (key) => {
-							assertScope(() => active);
-							const entry = staged.get(key);
-							return entry ? entry.present ? entry.value : void 0 : values.get(key);
-						},
-						has: (key) => {
-							assertScope(() => active);
-							const entry = staged.get(key);
-							return entry ? entry.present : values.has(key);
-						},
-						set: (key, value) => {
-							assertScope(() => active);
-							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-							staged.set(key, {
-								present: true,
-								value
-							});
-							operations.push({
-								kind: "set",
-								key,
-								value
-							});
-						},
-						remove: (key) => {
-							assertScope(() => active);
-							if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-							staged.set(key, { present: false });
-							operations.push({
-								kind: "remove",
-								key
-							});
-						}
-					});
-					try {
-						assertSynchronous(run(draft));
-					} finally {
-						active = false;
-					}
-					const candidates = /* @__PURE__ */ new Set();
-					let structural = false;
-					let changed = false;
-					for (const operation of operations) {
-						const present = values.has(operation.key);
-						if (operation.kind === "set") {
-							if (present && Object.is(values.get(operation.key), operation.value)) continue;
-							structural ||= !present;
-							values.set(operation.key, operation.value);
-						} else {
-							if (!present) continue;
-							structural = true;
-							values.delete(operation.key);
-						}
-						candidates.add(operation.key);
-						changed = true;
-					}
-					if (!changed) return;
-					boundary.mark({
-						candidates,
-						orderMayChange: structural
-					});
-					scheduler.run();
-				}
-			}
-		};
-	};
+	const externalValues = /* @__PURE__ */ new Map();
+	const externalCollections = /* @__PURE__ */ new Map();
 	const readable = (definition) => {
 		if (definition.source.kind !== "readable") throw new Error("Invalid Readable source.");
 		const { readable, equality } = definition.source;
@@ -3892,19 +4608,44 @@ const createSourceRegistry = (scheduler) => {
 				close() {
 					if (closed) return;
 					closed = true;
-					unsubscribe?.();
-					detachDocument?.();
+					const stopReadable = unsubscribe;
+					unsubscribe = void 0;
+					const stopDocument = detachDocument;
+					detachDocument = void 0;
 					readables.delete(readable);
+					members.clear();
+					const failures = [];
+					try {
+						stopReadable?.();
+					} catch (error) {
+						failures.push(error);
+					}
+					try {
+						stopDocument?.();
+					} catch (error) {
+						failures.push(error);
+					}
+					if (failures.length) throw failures[0];
 				}
 			};
-			const owner = contextOf(readable, false)?.owner;
-			if (owner) detachDocument = documents.attachRoot(owner, {
-				capture: () => receive(false),
-				dispose: () => {
-					members.forEach((next) => next.boundary.fail(/* @__PURE__ */ new Error("Document has been disposed.")));
-				}
-			});
-			unsubscribe = readable.subscribe(() => receive(true));
+			try {
+				const owner = contextOf(readable, false)?.owner;
+				if (owner) detachDocument = documents.attachRoot(owner, {
+					capture: () => receive(false),
+					dispose: () => {
+						members.forEach((next) => next.boundary.fail(/* @__PURE__ */ new Error("Document has been disposed.")));
+					}
+				});
+				unsubscribe = readable.subscribe(() => receive(true));
+			} catch (error) {
+				try {
+					created.close();
+				} catch {}
+				try {
+					scheduler.releaseProducer(boundary.producer);
+				} catch {}
+				throw error;
+			}
 			connection = created;
 			readables.set(readable, connection);
 		}
@@ -3937,8 +4678,11 @@ const createSourceRegistry = (scheduler) => {
 				close() {
 					if (closed) return;
 					closed = true;
-					unsubscribe?.();
+					const stop = unsubscribe;
+					unsubscribe = void 0;
 					externalValues.delete(source);
+					members.clear();
+					stop?.();
 				}
 			};
 			try {
@@ -3953,9 +4697,14 @@ const createSourceRegistry = (scheduler) => {
 					}
 					scheduler.run();
 				});
-			} catch (cause) {
-				created.close();
-				throw cause;
+			} catch (error) {
+				try {
+					created.close();
+				} catch {}
+				try {
+					scheduler.releaseProducer(boundary.producer);
+				} catch {}
+				throw error;
 			}
 			connection = created;
 			externalValues.set(source, connection);
@@ -3988,8 +4737,11 @@ const createSourceRegistry = (scheduler) => {
 				close() {
 					if (closed) return;
 					closed = true;
-					unsubscribe?.();
+					const stop = unsubscribe;
+					unsubscribe = void 0;
 					externalCollections.delete(source);
+					members.clear();
+					stop?.();
 				}
 			};
 			try {
@@ -4021,9 +4773,14 @@ const createSourceRegistry = (scheduler) => {
 					}
 					scheduler.run();
 				});
-			} catch (cause) {
-				created.close();
-				throw cause;
+			} catch (error) {
+				try {
+					created.close();
+				} catch {}
+				try {
+					scheduler.releaseProducer(boundary.producer);
+				} catch {}
+				throw error;
 			}
 			connection = created;
 			externalCollections.set(source, connection);
@@ -4038,18 +4795,166 @@ const createSourceRegistry = (scheduler) => {
 	return {
 		materialize(definition) {
 			switch (definition.source.kind) {
-				case "value-input": return valueInput(definition);
-				case "collection-input": return collectionInput(definition);
-				case "document": return documents.materialize(definition);
 				case "readable": return readable(definition);
 				case "external-value": return externalValue(definition);
 				case "external-collection": return externalCollection(definition);
+				default: throw new Error("Invalid external projection source.");
 			}
 		},
 		dispose() {
-			documents.dispose();
-			readables.forEach((connection) => connection.close());
+			const failures = [];
+			const connections = new Set([
+				...readables.values(),
+				...externalValues.values(),
+				...externalCollections.values()
+			]);
+			for (const connection of connections) try {
+				connection.close();
+			} catch (error) {
+				failures.push(error);
+			}
 			readables.clear();
+			externalValues.clear();
+			externalCollections.clear();
+			if (failures.length) throw failures[0];
+		}
+	};
+};
+//#endregion
+//#region core/src/projection/source/input.ts
+const materializeInputSource = (scheduler, definition) => {
+	const source = definition.source;
+	if (source.kind === "value-input") {
+		let latest = source.initial;
+		const boundary = createValueBoundary(scheduler, "projection input", source.initial, source.equality, () => latest, () => void 0);
+		return {
+			...boundary,
+			write: {
+				kind: "value",
+				set(value) {
+					scheduler.assertIdle();
+					latest = value;
+					boundary.mark();
+					scheduler.run();
+				}
+			}
+		};
+	}
+	if (source.kind !== "collection-input") throw new Error("Invalid projection input source.");
+	const values = new Map(source.initial);
+	const boundary = createCollectionBoundary(scheduler, "projection collection input", () => mapRead(values), definition.output.equality, () => void 0);
+	return {
+		...boundary,
+		write: {
+			kind: "collection",
+			update(run) {
+				scheduler.assertIdle();
+				const staged = /* @__PURE__ */ new Map();
+				const operations = [];
+				let active = true;
+				const draft = Object.freeze({
+					get: (key) => {
+						assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present ? entry.value : void 0 : values.get(key);
+					},
+					has: (key) => {
+						assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present : values.has(key);
+					},
+					set: (key, value) => {
+						assertScope(() => active);
+						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						staged.set(key, {
+							present: true,
+							value
+						});
+						operations.push({
+							kind: "set",
+							key,
+							value
+						});
+					},
+					remove: (key) => {
+						assertScope(() => active);
+						if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
+						staged.set(key, { present: false });
+						operations.push({
+							kind: "remove",
+							key
+						});
+					}
+				});
+				try {
+					assertSynchronous(run(draft));
+				} finally {
+					active = false;
+				}
+				const candidates = /* @__PURE__ */ new Set();
+				let structural = false;
+				const accepted = [];
+				const overlay = /* @__PURE__ */ new Map();
+				for (const operation of operations) {
+					const overlayValue = overlay.get(operation.key);
+					const present = overlayValue ? overlayValue.present : values.has(operation.key);
+					if (operation.kind === "set") {
+						const previous = overlayValue ? overlayValue.present ? overlayValue.value : void 0 : values.get(operation.key);
+						if (present && source.equality(previous, operation.value)) continue;
+						structural ||= !present;
+						overlay.set(operation.key, {
+							present: true,
+							value: operation.value
+						});
+					} else {
+						if (!present) continue;
+						structural = true;
+						overlay.set(operation.key, { present: false });
+					}
+					accepted.push(operation);
+					candidates.add(operation.key);
+				}
+				if (!accepted.length) return;
+				for (const operation of accepted) if (operation.kind === "set") values.set(operation.key, operation.value);
+				else values.delete(operation.key);
+				boundary.mark({
+					candidates,
+					orderMayChange: structural
+				});
+				scheduler.run();
+			}
+		}
+	};
+};
+//#endregion
+//#region core/src/projection/source/registry.ts
+const createSourceRegistry = (scheduler) => {
+	const documents = createDocumentSourceRegistry(scheduler);
+	const external = createExternalSourceRegistry(scheduler, documents);
+	return {
+		materialize(definition) {
+			switch (definition.source.kind) {
+				case "value-input":
+				case "collection-input": return materializeInputSource(scheduler, definition);
+				case "document": return documents.materialize(definition);
+				case "readable":
+				case "external-value":
+				case "external-collection": return external.materialize(definition);
+			}
+		},
+		dispose() {
+			const failures = [];
+			try {
+				external.dispose();
+			} catch (error) {
+				failures.push(error);
+			}
+			try {
+				documents.dispose();
+			} catch (error) {
+				failures.push(error);
+			}
+			if (failures.length) throw failures[0];
 		}
 	};
 };
@@ -4092,6 +4997,7 @@ const createProjectionRuntime = (options) => {
 				outputs: processor.outputs
 			});
 		}
+		definition.materialized = true;
 		materialized.set(definition, result);
 		rememberScoped(definition, requester);
 		return result;
@@ -4132,12 +5038,12 @@ const createProjectionRuntime = (options) => {
 		publicViews.delete(output);
 		return current;
 	};
-	const get = (projection, requester) => publicCurrent(resolveOutput(projection, requester));
+	const readProjection = (projection, requester) => publicCurrent(resolveOutput(projection, requester));
 	const readableSource = (projection, requester) => {
 		const output = resolveOutput(projection, requester);
 		return Object.freeze({
 			kind: output.kind,
-			current: () => get(projection, requester),
+			current: () => readProjection(projection, requester),
 			revision: () => {
 				assertOutput(output);
 				return output.revision();
@@ -4149,7 +5055,7 @@ const createProjectionRuntime = (options) => {
 		const source = readableSource(projection, requester);
 		return selector ? createSelectorReadable(source, selector, equality) : createDirectReadable(source);
 	};
-	function readable(projection, selector, equality) {
+	function selectProjection(projection, selector, equality) {
 		return makeReadable(projection, selector, equality);
 	}
 	const inputWrite = (target, requester) => {
@@ -4160,34 +5066,46 @@ const createProjectionRuntime = (options) => {
 		if (!write) throw new TypeError("Projection input is not writable.");
 		return write;
 	};
-	const setInput = (target, value, requester) => {
-		const write = inputWrite(target, requester);
-		if (write.kind !== "value") throw new TypeError("Projection is not a value input.");
-		write.set(value);
-	};
-	const updateInput = (target, run, requester) => {
+	const updateInput = (target, valueOrRun, requester) => {
 		const write = inputWrite(target, requester);
-		if (write.kind !== "collection") throw new TypeError("Projection is not a collection input.");
-		write.update(run);
+		if (write.kind === "value") {
+			write.set(valueOrRun);
+			return;
+		}
+		if (typeof valueOrRun !== "function") throw new TypeError("Collection input update requires a draft callback.");
+		write.update(valueOrRun);
 	};
-	function batch(optionsOrCallback, maybeCallback) {
-		return typeof optionsOrCallback === "function" ? scheduler.batch(optionsOrCallback) : scheduler.batch(optionsOrCallback, maybeCallback);
+	function update(target, valueOrRun) {
+		updateInput(target, valueOrRun);
 	}
+	const batch = (run, options) => scheduler.batch(run, options);
 	const disposeScope = (state) => {
 		if (!state.active) return;
 		scheduler.assertIdle();
 		state.active = false;
-		state.subscriptions.forEach((unsubscribe) => unsubscribe());
+		const failures = [];
+		const subscriptions = [...state.subscriptions];
 		state.subscriptions.clear();
+		for (const unsubscribe of subscriptions) try {
+			unsubscribe();
+		} catch (error) {
+			failures.push(error);
+		}
 		for (let index = state.materialized.length - 1; index >= 0; index--) {
 			const definition = state.materialized[index];
 			const current = materialized.get(definition);
 			if (!current) continue;
-			scheduler.releaseProducer(current.record);
-			materialized.delete(definition);
+			try {
+				scheduler.releaseProducer(current.record);
+			} catch (error) {
+				failures.push(error);
+			} finally {
+				materialized.delete(definition);
+			}
 		}
 		state.materialized.length = 0;
 		scopes.delete(state);
+		if (failures.length) throw failures[0];
 	};
 	const createScope = () => {
 		scheduler.assertIdle();
@@ -4201,23 +5119,30 @@ const createProjectionRuntime = (options) => {
 			if (!state.active) throw new ProjectionDisposedError();
 			scheduler.assertActive();
 		};
-		const own = (projection) => {
+		function own(target) {
 			assertActive();
-			return ownProjection(projection, state);
-		};
-		const ownOutputTree = (tree) => {
-			if (isProjection(tree)) return own(tree);
-			if (!tree || typeof tree !== "object") throw new TypeError("Incremental group output tree must be an object.");
-			for (const value of Object.values(tree)) ownOutputTree(value);
-			return tree;
-		};
-		const scopedInput = Object.assign((initial, equality) => own(input(initial, equality)), { collection: (initial) => own(input.collection(initial)) });
-		const scopedDerive = (dependencies, compute, equality) => own(derive(dependencies, compute, equality));
-		const scopedIncremental = Object.assign((dependencies, processor) => own(incremental(dependencies, processor)), {
-			collection: (dependencies, processor) => own(incremental.collection(dependencies, processor)),
-			group: (dependencies, defineOutputs, processor) => ownOutputTree(incremental.group(dependencies, defineOutputs, processor))
-		});
-		function scopeReadable(projection, selector, equality) {
+			const projections = [];
+			const collect = (value) => {
+				if (isProjection(value)) {
+					projections.push(value);
+					return;
+				}
+				if (!isPlainObject(value)) throw new TypeError("Projection ownership tree must be a plain object.");
+				for (const key of Reflect.ownKeys(value)) {
+					if (typeof key !== "string") throw new TypeError("Projection ownership tree keys must be strings.");
+					const descriptor = Object.getOwnPropertyDescriptor(value, key);
+					if (!descriptor?.enumerable || !("value" in descriptor)) throw new TypeError("Projection ownership tree must use enumerable data properties.");
+					const child = descriptor.value;
+					if (!isProjection(child) && !isPlainObject(child)) throw new TypeError("Projection ownership tree leaves must be projections.");
+					collect(child);
+				}
+			};
+			collect(target);
+			if (!projections.length) throw new TypeError("Projection ownership tree must contain a projection.");
+			ownProjections(projections, state);
+			return target;
+		}
+		function scopeSelect(projection, selector, equality) {
 			assertActive();
 			const source = makeReadable(projection, selector, equality, state);
 			return Object.freeze({
@@ -4244,54 +5169,64 @@ const createProjectionRuntime = (options) => {
 				}
 			});
 		}
-		function scopeBatch(optionsOrCallback, maybeCallback) {
+		function scopeUpdate(target, valueOrRun) {
+			assertActive();
+			updateInput(target, valueOrRun, state);
+		}
+		function scopeBatch(run, options) {
 			assertActive();
-			return typeof optionsOrCallback === "function" ? batch(optionsOrCallback) : batch(optionsOrCallback, maybeCallback);
+			return batch(run, options);
 		}
 		return Object.freeze({
-			input: scopedInput,
-			derive: scopedDerive,
-			incremental: scopedIncremental,
-			get: (projection) => {
+			own,
+			read: (projection) => {
 				assertActive();
-				return get(projection, state);
-			},
-			readable: scopeReadable,
-			set: (target, value) => {
-				assertActive();
-				setInput(target, value, state);
-			},
-			update: (target, run) => {
-				assertActive();
-				updateInput(target, run, state);
+				return readProjection(projection, state);
 			},
+			select: scopeSelect,
+			update: scopeUpdate,
 			batch: scopeBatch,
 			dispose: () => disposeScope(state)
 		});
 	};
 	return Object.freeze({
-		get,
-		readable,
-		set: setInput,
-		update: updateInput,
+		read: readProjection,
+		select: selectProjection,
+		update,
 		batch,
 		scope: createScope,
 		dispose: () => {
 			if (!scheduler.active) return;
 			scheduler.assertIdle();
+			const failures = [];
 			for (const scope of scopes) {
 				scope.active = false;
-				scope.subscriptions.forEach((unsubscribe) => unsubscribe());
+				const subscriptions = [...scope.subscriptions];
 				scope.subscriptions.clear();
+				for (const unsubscribe of subscriptions) try {
+					unsubscribe();
+				} catch (error) {
+					failures.push(error);
+				}
 				scope.materialized.length = 0;
 			}
 			scopes.clear();
-			sources.dispose();
-			scheduler.dispose();
+			try {
+				sources.dispose();
+			} catch (error) {
+				failures.push(error);
+			}
+			try {
+				scheduler.dispose();
+			} catch (error) {
+				failures.push(error);
+			}
+			if (failures.length === 1) throw failures[0];
+			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
 		}
 	});
 };
 //#endregion
-export { DocumentDisposedError, DocumentReentrancyError, ParseError, ProjectionDisposedError, ProjectionError, TransactionRejected, asReadable, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
+export { DocumentDisposedError, DocumentReentrancyError, ParseError, ProjectionDisposedError, ProjectionError, TransactionRejected, createDocument, createProjectionRuntime, derive, field, input, list, map, object, observe, optional, parse, read, replace, select, snapshot, table, tree, variant };
 
 //# sourceMappingURL=index.js.map