doxum 0.1.23 → 0.1.26

package/dist/index.cjs

@@ -1,16 +1,432 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_advanced = require("./advanced-Cle5g3B4.cjs");
-const require_context = require("./context-BcLKGfq8.cjs");
-const require_driver = require("./driver-BD3DQOW6.cjs");
-//#region core/src/address/resolve.ts
-const variantNode = (node, value) => {
-	const tag = require_context.isRecord(value) && typeof value[node.tag] === "string" ? value[node.tag] : void 0;
-	return node.variants[String(tag ?? Object.keys(node.variants)[0] ?? "")];
+const require_scheduler = require("./scheduler-D4VthaaK.cjs");
+const require_record = require("./record-ChYUi8PP.cjs");
+const require_driver = require("./driver-BL91gn7_.cjs");
+//#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) => {
+	require_scheduler.profile.equality.call();
+	if (left === right) return true;
+	require_scheduler.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);
+				require_scheduler.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);
+				require_scheduler.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()) {
+			require_scheduler.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 (!require_record.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 (!require_record.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 (!require_record.isPlainObject(value)) return issue(address, "Expected a collection object.");
+		const entries = node.kind === "table" ? value.byId : value;
+		if (!require_record.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 (!require_driver.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 (!require_record.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) => {
+	require_scheduler.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;
+	require_scheduler.profile.copy.structure();
+	if ((node.kind === "object" || node.kind === "variant") && require_record.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") && require_record.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" && require_record.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") && require_record.isRecord(left) && require_record.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" && require_record.isRecord(left) && require_record.isRecord(right)) return equal(left.ids, right.ids) && equalValue({
+		kind: "map",
+		value: node.value
+	}, left.byId, right.byId);
+	if (node.kind === "tree" && require_record.isRecord(left) && require_record.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" && require_record.isRecord(left) && require_record.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 = require_record.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;
@@ -28,17 +444,17 @@ const nodeAt = (schema, address, document) => {
 	return node;
 };
 const readSegment = (value, segment, node) => {
-	if (!require_context.isRecord(value) && !Array.isArray(value)) return void 0;
-	if (node?.kind === "list" && Array.isArray(value)) return value[require_advanced.indexedKeys(value, node.keyOf).index(segment)];
-	if (node?.kind === "table" && require_context.isRecord(value) && require_context.isRecord(value.byId)) return Object.hasOwn(value.byId, segment) ? value.byId[segment] : void 0;
+	if (!require_record.isRecord(value) && !Array.isArray(value)) return void 0;
+	if (node?.kind === "list" && Array.isArray(value)) return value[indexedKeys(value, node.keyOf).index(segment)];
+	if (node?.kind === "table" && require_record.isRecord(value) && require_record.isRecord(value.byId)) return Object.hasOwn(value.byId, segment) ? value.byId[segment] : void 0;
 	return Object.prototype.hasOwnProperty.call(value, segment) ? value[segment] : void 0;
 };
 const resolveContainer = (owner, generation, at, node, value) => {
-	if (!node || !require_context.isRecord(value) && !Array.isArray(value)) return void 0;
-	const parent = node.kind === "table" && require_context.isRecord(value) ? value.byId : value;
-	if (!require_context.isRecord(parent) && !Array.isArray(parent)) return void 0;
+	if (!node || !require_record.isRecord(value) && !Array.isArray(value)) return void 0;
+	const parent = node.kind === "table" && require_record.isRecord(value) ? value.byId : value;
+	if (!require_record.isRecord(parent) && !Array.isArray(parent)) return void 0;
 	if (node.kind === "tree") return void 0;
-	const layout = require_advanced.compiledLayout(node, value);
+	const layout = compiledLayout(node, value);
 	if (!layout) return void 0;
 	return {
 		owner,
@@ -50,14 +466,14 @@ const resolveContainer = (owner, generation, at, node, value) => {
 		layout
 	};
 };
-const resolveTreeContainer = (owner, generation, at, node, value) => node?.kind === "tree" && require_context.is(value) ? {
+const resolveTreeContainer = (owner, generation, at, node, value) => node?.kind === "tree" && require_driver.is(value) ? {
 	owner,
 	generation,
 	at,
 	node,
 	value
 } : void 0;
-const memberKey = (container, key) => container.node.kind === "list" ? require_advanced.indexedKeys(container.parent, container.node.keyOf).index(key) : key;
+const memberKey = (container, key) => container.node.kind === "list" ? indexedKeys(container.parent, container.node.keyOf).index(key) : key;
 /** One recent path per transaction; structural writes invalidate all retained locations. */
 const createAddressResolver = (schema, root) => {
 	const prefix = [];
@@ -103,8 +519,8 @@ const resolveWithPrefix = (schema, root, address, prefix) => {
 	}
 	let cacheable = true;
 	for (let index = start; index < address.length - 1; index += 1) {
-		require_advanced.profile.address.schemaStep();
-		require_advanced.profile.address.documentStep();
+		require_scheduler.profile.address.schemaStep();
+		require_scheduler.profile.address.documentStep();
 		const resolved = step(node, current, address[index]);
 		if (!resolved) return void 0;
 		if (node?.kind !== "object" && node?.kind !== "table" && node?.kind !== "map") cacheable = false;
@@ -122,11 +538,11 @@ const resolveWithPrefix = (schema, root, address, prefix) => {
 };
 /** Resolves one member from an already current schema/container pair. */
 const resolveChild = (node, current, last) => {
-	require_advanced.profile.address.schemaStep();
-	require_advanced.profile.address.documentStep();
+	require_scheduler.profile.address.schemaStep();
+	require_scheduler.profile.address.documentStep();
 	const resolved = step(node, current, last);
-	if (!resolved || !require_context.isRecord(current) && !Array.isArray(current)) return void 0;
-	if (node?.kind === "table" && require_context.isRecord(current) && require_context.isRecord(current.byId)) return {
+	if (!resolved || !require_record.isRecord(current) && !Array.isArray(current)) return void 0;
+	if (node?.kind === "table" && require_record.isRecord(current) && require_record.isRecord(current.byId)) return {
 		node: resolved,
 		parent: current.byId,
 		key: last
@@ -134,20 +550,10 @@ const resolveChild = (node, current, last) => {
 	return {
 		node: resolved,
 		parent: current,
-		key: node?.kind === "list" && Array.isArray(current) ? require_advanced.indexedKeys(current, node.keyOf).index(last) : last
+		key: node?.kind === "list" && Array.isArray(current) ? indexedKeys(current, node.keyOf).index(last) : last
 	};
 };
 //#endregion
-//#region core/src/mutation/operations/map.ts
-function put(session, container, id, value) {
-	if (container.node.kind !== "map") return require_driver.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 require_driver.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);
@@ -235,25 +641,25 @@ function insert$1(session, container, value, position) {
 	session.validate(node.value, value, at);
 	const id = node.keyOf(value);
 	if (typeof id !== "string") return require_driver.fail(at, "invalid-list-key", "List key must be a string.");
-	const items = current, keys$1 = require_advanced.keys(items, node.keyOf);
+	const items = current, keys$1 = keys(items, node.keyOf);
 	if (keys$1.index(id) >= 0) return require_driver.fail(at, "duplicate-list-item", "List key already exists.");
 	if (!valid(keys$1, position)) return require_driver.fail(at, "invalid-anchor", "Unknown list anchor.");
 	session.recorder.order(container);
 	session.recorder.member(container, id, session.definition(container, id), -1);
-	require_advanced.insert(items, index(keys$1, position), value);
+	insert$2(items, index(keys$1, position), value);
 	session.invalidate();
 }
 function replace$2(session, container, id, value) {
 	const { at, node, value: items } = container;
 	if (node.kind !== "list") return require_driver.fail(at, "invalid-list-key", "Expected a list.");
-	const index = require_advanced.indexedKeys(items, node.keyOf).index(id);
+	const index = indexedKeys(items, node.keyOf).index(id);
 	if (index < 0) return require_driver.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 require_driver.fail(at, "missing-list-item", "List key does not exist.");
-	const index = require_advanced.keys(value, node.keyOf).index(id);
+	const index = keys(value, node.keyOf).index(id);
 	if (index < 0) return require_driver.fail(at, "missing-list-item", "List key does not exist.");
 	session.writeMember(container, id, void 0, "remove", index);
 }
@@ -267,7 +673,7 @@ const positionIndex = (index, length, at) => {
 const insert = (session, container, id, value, position) => {
 	const { at, node: schema, value: tree } = container;
 	if (typeof id !== "string") return require_driver.fail(at, "invalid-key", "Tree keys must be strings.");
-	if (require_context.contains(tree, id)) return require_driver.fail(at, "duplicate-tree-node", "Tree node already exists.");
+	if (require_driver.contains(tree, id)) return require_driver.fail(at, "duplicate-tree-node", "Tree node already exists.");
 	const parentId = position?.parentId;
 	const parent = parentId === void 0 ? void 0 : node$1(tree, parentId);
 	if (tree.rootId !== void 0 && !parent || tree.rootId === void 0 && parentId !== void 0) return require_driver.fail(at, "missing-tree-parent", "A nonempty tree requires an existing parent.");
@@ -322,7 +728,7 @@ const move$1 = (session, container, id, position) => {
 	const { at, value: tree } = container;
 	const entry = node$1(tree, id), parentId = position?.parentId;
 	if (!entry) return require_driver.fail(at, "missing-tree-node", "Tree node does not exist.");
-	if (entry.parentId === void 0 || parentId === void 0 || !require_context.contains(tree, parentId)) return require_driver.fail(at, "missing-tree-parent", "Moving requires a non-root node and an existing parent.");
+	if (entry.parentId === void 0 || parentId === void 0 || !require_driver.contains(tree, parentId)) return require_driver.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 require_driver.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);
@@ -359,16 +765,16 @@ function move(session, container, ids, position) {
 	if (node.kind === "table") {
 		const order = container.value.ids;
 		const next = plannedOrder(container.at, order, selection, position);
-		if (require_advanced.equal(order, next)) return;
+		if (equal(order, next)) return;
 		session.recorder.order(container);
-		require_advanced.installKeys(order, next);
+		installKeys(order, next);
 	} else {
 		const items = container.value;
-		const current = require_advanced.listSequence(items, node.keyOf);
+		const current = listSequence(items, node.keyOf);
 		const next = plannedOrder(container.at, current.order, selection, position);
-		if (require_advanced.equal(current.order, next)) return;
+		if (equal(current.order, next)) return;
 		session.recorder.order(container);
-		require_advanced.installList(items, node.keyOf, current, next);
+		installList(items, node.keyOf, current, next);
 	}
 	session.invalidate();
 }
@@ -376,17 +782,17 @@ function reorder(session, container, next) {
 	const node = assertOrdered(container);
 	if (node.kind === "table") {
 		const current = container.value.ids;
-		if (!require_advanced.matches(next, current)) return require_driver.fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
-		if (require_advanced.equal(current, next)) return;
+		if (!matches(next, current)) return require_driver.fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
+		if (equal(current, next)) return;
 		session.recorder.order(container);
-		require_advanced.installKeys(current, next);
+		installKeys(current, next);
 	} else {
 		const items = container.value;
-		const current = require_advanced.listSequence(items, node.keyOf);
-		if (!require_advanced.matches(next, current.order)) return require_driver.fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
-		if (require_advanced.equal(current.order, next)) return;
+		const current = listSequence(items, node.keyOf);
+		if (!matches(next, current.order)) return require_driver.fail(container.at, "invalid-collection", "Order must contain every key exactly once.");
+		if (equal(current.order, next)) return;
 		session.recorder.order(container);
-		require_advanced.installList(items, node.keyOf, current, next);
+		installList(items, node.keyOf, current, next);
 	}
 	session.invalidate();
 }
@@ -411,13 +817,17 @@ const sameTreeTarget = (left, right) => {
 	return left.kind !== "node" || right.kind === "node" && left.id === right.id;
 };
 const same = (left, right) => {
+	require_scheduler.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) {
+		require_scheduler.profile.dependency.segmentCompared();
+		if (leftAddress[index] !== rightAddress[index]) return false;
+	}
 	return left.kind !== "collection" || id(left) === id(right);
 };
 const indexedAddress = (target) => {
@@ -445,6 +855,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;
@@ -522,7 +938,7 @@ const locations = /* @__PURE__ */ new WeakMap();
 const locationOf = (value) => locations.get(value);
 const addressOf = (target) => {
 	if (target.at) return target.at;
-	require_advanced.profile.access("addresses");
+	require_scheduler.profile.access("addresses");
 	return target.at = addressOf(target.parent).concat(target.key);
 };
 const assertActive = (context) => {
@@ -544,11 +960,11 @@ const snapshot = (value) => {
 	if (!location) return value;
 	const { context } = location;
 	const at = addressOf(location.target);
-	require_advanced.profile.access("snapshots");
+	require_scheduler.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 require_advanced.copyValue(resolved.node, resolved.value);
+	return copyValue(resolved.node, resolved.value);
 };
 const replace = (container, key, value) => {
 	if (!locationOf(container)) throw new TypeError("replace requires scoped document access.");
@@ -559,7 +975,7 @@ const resolve = (context, target) => {
 	assertActive(context);
 	const generation = context.session?.generation ?? 0;
 	if (target.generation !== generation) {
-		require_advanced.profile.access("resolutions");
+		require_scheduler.profile.access("resolutions");
 		if (!target.parent && !target.at.length) {
 			target.node = context.state.schema;
 			target.value = context.state.document;
@@ -574,7 +990,7 @@ const resolve = (context, target) => {
 	return target;
 };
 const createAccess = (context, initial = []) => {
-	require_advanced.profile.access("scopes");
+	require_scheduler.profile.access("scopes");
 	const mutable = () => {
 		assertActive(context);
 		if (!context.session) throw new TypeError("Cannot modify read-only document access.");
@@ -585,13 +1001,13 @@ const createAccess = (context, initial = []) => {
 		return target.container = session.bind(addressOf(target), target.node, target.value);
 	};
 	const childAt = (target, key) => {
-		require_advanced.profile.access("addresses");
+		require_scheduler.profile.access("addresses");
 		return addressOf(target).concat(key);
 	};
 	const access = (target) => {
 		if (target.proxy) return target.proxy;
 		const proxy = new Proxy(target, handler);
-		require_advanced.profile.access("proxies");
+		require_scheduler.profile.access("proxies");
 		locations.set(proxy, {
 			context,
 			target
@@ -621,7 +1037,7 @@ const createAccess = (context, initial = []) => {
 			if (children?.kind !== "fixed" || children.schema !== target.node) children = {
 				kind: "fixed",
 				schema: target.node,
-				slots: new Array(require_advanced.compiledShape(target.node, target.value).members.size)
+				slots: new Array(compiledShape(target.node, target.value).members.size)
 			};
 			child = children.slots[member.slot] ??= createTarget(void 0, target, key);
 		} else {
@@ -683,12 +1099,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);
 	};
@@ -702,7 +1120,7 @@ const createAccess = (context, initial = []) => {
 		if (property === "has") return (id) => {
 			const current = collectionValue(target, node);
 			collect(context, at, "collection", id);
-			return node.kind === "table" ? Object.hasOwn(current.byId, id) : require_advanced.indexedKeys(current, node.keyOf).index(id) >= 0;
+			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);
@@ -788,28 +1206,28 @@ const createAccess = (context, initial = []) => {
 				id
 			});
 			const value = current();
-			return require_context.contains(value, id) ? value.nodes[id].value : void 0;
+			return require_driver.contains(value, id) ? value.nodes[id].value : void 0;
 		};
 		if (property === "has") return (id) => {
 			collectTree(context, at, {
 				kind: "node",
 				id
 			});
-			return require_context.contains(current(), id);
+			return require_driver.contains(current(), id);
 		};
 		if (property === "parent") return (id) => {
 			collectTree(context, at, {
 				kind: "node",
 				id
 			});
-			return require_context.parent(current(), id);
+			return require_driver.parent(current(), id);
 		};
 		if (property === "children") return (id) => {
 			collectTree(context, at, {
 				kind: "node",
 				id
 			});
-			const children$1 = require_context.children(current(), id);
+			const children$1 = require_driver.children(current(), id);
 			return children$1 ? [...children$1] : void 0;
 		};
 	};
@@ -826,7 +1244,7 @@ const createAccess = (context, initial = []) => {
 				collect(context, childAt(target, property));
 				return value[property];
 			}
-			const member = require_advanced.compiledShape(node, value)?.members.get(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));
@@ -889,12 +1307,68 @@ 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) => {
-	require_advanced.profile.address.prefixComparison();
+	require_scheduler.profile.address.prefixComparison();
 	if (parent.length > child.length) return false;
 	for (let index = 0; index < parent.length; index += 1) {
-		require_advanced.profile.address.segmentCompared();
+		require_scheduler.profile.address.segmentCompared();
 		if (parent[index] !== child[index]) return false;
 	}
 	return true;
@@ -907,7 +1381,7 @@ const createImpact = (schema, changes) => {
 	let orders;
 	const index = () => {
 		if (!values) {
-			require_advanced.profile.impact.index();
+			require_scheduler.profile.impact.index();
 			values = new require_driver.AddressIndex();
 			orders = new require_driver.AddressIndex();
 			visitChangedLocations(changes, (at) => values.add(at, true), (at) => orders.add(at, true));
@@ -916,7 +1390,7 @@ const createImpact = (schema, changes) => {
 	};
 	const cache = /* @__PURE__ */ new Map();
 	const affects = (value) => {
-		require_advanced.profile.impact.affects();
+		require_scheduler.profile.impact.affects();
 		if (!belongs(value, schema)) return false;
 		if (reset) return true;
 		return affected(value, index(), orders);
@@ -990,8 +1464,8 @@ const createImpact = (schema, changes) => {
 	};
 	return Object.freeze({
 		kind: reset ? "reset" : "incremental",
-		affects: (pick) => affects(require_advanced.compilePath(schema, "value", pick)),
-		collection: (pick) => collection(require_advanced.compilePath(schema, "collection", pick))
+		affects: (pick) => affects(compilePath(schema, "value", pick)),
+		collection: (pick) => collection(compilePath(schema, "collection", pick))
 	});
 };
 //#endregion
@@ -1193,18 +1667,18 @@ const createHistory = (input) => {
 const installMember = (parent, key, present, value) => {
 	if (Array.isArray(parent)) {
 		const index = Number(key);
-		if (present) if (index < 0) require_advanced.insert(parent, parent.length, value);
+		if (present) if (index < 0) insert$2(parent, parent.length, value);
 		else parent[index] = value;
-		else if (index >= 0) require_advanced.remove(parent, index);
-	} else require_context.installOwn(parent, key, present, value);
+		else if (index >= 0) remove$3(parent, index);
+	} else require_record.installOwn(parent, key, present, value);
 };
 const orderOf = (node, value) => {
-	if (node.kind === "list") return require_advanced.toArray(require_advanced.indexedKeys(value, node.keyOf));
+	if (node.kind === "list") return toArray(indexedKeys(value, node.keyOf));
 	if (node.kind === "table") return [...value.ids];
 	throw new Error("Order requires a table or list.");
 };
 const installOrder = (node, value, order) => {
-	if (node.kind === "list") require_advanced.install(value, node.keyOf, order);
+	if (node.kind === "list") install(value, node.keyOf, order);
 	else if (node.kind === "table") value.ids = [...order];
 	else throw new Error("Order requires a table or list.");
 };
@@ -1225,9 +1699,9 @@ const forgetMember = (group, key) => {
 const emptyGroup = (group) => !group.order && (group.layout === "fixed" ? !group.members.some(Boolean) : !group.members?.size);
 const transition = (node, key, beforePresent, before, afterPresent, after) => {
 	if (beforePresent === afterPresent && (!beforePresent || Object.is(before, after))) return;
-	if (node.kind !== "field" && beforePresent === afterPresent && require_advanced.equalValue(node, before, after)) return;
-	const value = afterPresent ? node.kind === "field" ? after : require_advanced.copyValue(node, after) : void 0;
-	require_advanced.profile.recorder("transitions");
+	if (node.kind !== "field" && beforePresent === afterPresent && equalValue(node, before, after)) return;
+	const value = afterPresent ? node.kind === "field" ? after : copyValue(node, after) : void 0;
+	require_scheduler.profile.recorder("transitions");
 	return !beforePresent ? {
 		key,
 		kind: "added",
@@ -1268,7 +1742,7 @@ const diffMember = (changes, members, node, at, key, beforePresent, before, afte
 			const left = before, right = after;
 			const childAt = at.concat(key);
 			const children = [];
-			for (const [child, definition] of require_advanced.compiledShape(node, before).members) diffMember(changes, children, definition.node, childAt, child, Object.hasOwn(left, child), left[child], Object.hasOwn(right, child), right[child]);
+			for (const [child, definition] of compiledShape(node, before).members) diffMember(changes, children, definition.node, childAt, child, Object.hasOwn(left, child), left[child], Object.hasOwn(right, child), right[child]);
 			publishMembers(changes, childAt, children);
 			return;
 		}
@@ -1281,8 +1755,8 @@ const diffMember = (changes, members, node, at, key, beforePresent, before, afte
 			for (const id of Object.keys(left)) diffMember(changes, children, node.value, childAt, id, true, left[id], Object.hasOwn(right, id), right[id]);
 			for (const id of Object.keys(right)) if (!Object.hasOwn(left, id)) diffMember(changes, children, node.value, childAt, id, false, void 0, true, right[id]);
 			let order;
-			if (node.kind === "table" && !require_advanced.equal(a.ids, b.ids)) {
-				require_advanced.profile.recorder("publishedOrderItems", b.ids.length);
+			if (node.kind === "table" && !equal(a.ids, b.ids)) {
+				require_scheduler.profile.recorder("publishedOrderItems", b.ids.length);
 				order = {
 					before: a.ids,
 					after: [...b.ids]
@@ -1299,7 +1773,7 @@ const restore = (fact, schema, root, skip = 0) => {
 	const at = skip ? fact.at.slice(skip) : fact.at;
 	if (fact.kind === "member") {
 		const member = fact.member;
-		const value = member.present ? require_advanced.copyValue(member.node, member.value) : void 0;
+		const value = member.present ? copyValue(member.node, member.value) : void 0;
 		if (!at.length) return value;
 		const location = resolveLocated(schema, root, at);
 		if (!location) throw new Error("Cannot restore an unresolved member.");
@@ -1313,12 +1787,12 @@ const restore = (fact, schema, root, skip = 0) => {
 		const tree = location.value;
 		if (fact.before === null) delete tree.rootId;
 		else tree.rootId = fact.before;
-		for (const [id, node] of fact.nodes) installMember(tree.nodes, id, node !== void 0, node && require_advanced.copyTreeNode(node));
+		for (const [id, node] of fact.nodes) installMember(tree.nodes, id, node !== void 0, node && copyTreeNode(node));
 	}
 	return root;
 };
 const reconstructBefore = (node, current, records, offset) => {
-	let before = require_advanced.copyValue(node, current);
+	let before = copyValue(node, current);
 	for (let i = records.length - 1; i >= 0; i--) if (records[i].kind !== "order") before = restore(records[i], node, before, offset);
 	for (const record of records) if (record.kind === "order") before = restore(record, node, before, offset);
 	return before;
@@ -1337,10 +1811,10 @@ const sealMembers = (fact, changes) => {
 	}
 	let order;
 	if (fact.order) {
-		const current = fact.node.kind === "list" ? require_advanced.indexedKeys(fact.value, fact.node.keyOf) : fact.value.ids;
-		if (!require_advanced.equal(fact.order, current)) {
+		const current = fact.node.kind === "list" ? indexedKeys(fact.value, fact.node.keyOf) : fact.value.ids;
+		if (!equal(fact.order, current)) {
 			const after = orderOf(fact.node, fact.value);
-			require_advanced.profile.recorder("publishedOrderItems", after.length);
+			require_scheduler.profile.recorder("publishedOrderItems", after.length);
 			order = {
 				before: fact.order,
 				after
@@ -1357,11 +1831,11 @@ const sealTree = (fact, canonical, changes) => {
 	for (const [id, before] of fact.nodes) {
 		const after = Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
 		if (!before && !after) continue;
-		if (before && after && require_advanced.equalTreeNode(before, after)) continue;
+		if (before && after && equalTreeNode(before, after)) continue;
 		nodes.push(!before ? {
 			id,
 			kind: "added",
-			after: require_advanced.copyTreeNode(after)
+			after: copyTreeNode(after)
 		} : !after ? {
 			id,
 			kind: "removed",
@@ -1370,7 +1844,7 @@ const sealTree = (fact, canonical, changes) => {
 			id,
 			kind: "updated",
 			before,
-			after: require_advanced.copyTreeNode(after)
+			after: copyTreeNode(after)
 		});
 	}
 	const after = tree.rootId ?? null;
@@ -1398,7 +1872,7 @@ var ChangeRecorder = class {
 			this.indexedGroups = true;
 			for (const fact of this.facts) if (fact.kind === "members") {
 				index.add(fact.at, fact);
-				require_advanced.profile.recorder("indexedGroups");
+				require_scheduler.profile.recorder("indexedGroups");
 			}
 		}
 		return index;
@@ -1447,7 +1921,7 @@ var ChangeRecorder = class {
 	releaseCovered(children) {
 		let changedGroups;
 		for (const child of children) {
-			require_advanced.profile.recorder("absorbed");
+			require_scheduler.profile.recorder("absorbed");
 			if (child.kind === "member") {
 				const { group, member } = child;
 				forgetMember(group, member.key);
@@ -1463,9 +1937,9 @@ var ChangeRecorder = class {
 		this.facts.add(fact);
 		if (fact.kind === "members") {
 			this.groups.set(fact.parent, fact);
-			require_advanced.profile.recorder("groups");
+			require_scheduler.profile.recorder("groups");
 			if (!this.indexedGroups) return;
-			require_advanced.profile.recorder("indexedGroups");
+			require_scheduler.profile.recorder("indexedGroups");
 		}
 		(this.index ??= new require_driver.AddressIndex()).add(fact.at, fact);
 	}
@@ -1495,14 +1969,14 @@ var ChangeRecorder = class {
 		if (group.layout === "dynamic") (group.members ??= /* @__PURE__ */ new Map()).set(key, member);
 		else if (definition.kind === "fixed") group.members[definition.slot] = member;
 		else throw new Error("A fixed member group requires a fixed schema member.");
-		require_advanced.profile.recorder("facts");
+		require_scheduler.profile.recorder("facts");
 	}
 	reset() {
 		if (this.resetBefore) return;
 		const value = this.absorb([], this.state.schema, this.state.document, true);
 		this.resetBefore = { value };
 		this.groups = /* @__PURE__ */ new WeakMap();
-		require_advanced.profile.recorder("facts");
+		require_scheduler.profile.recorder("facts");
 	}
 	createGroup(container) {
 		const group = container.layout.kind === "fixed" ? {
@@ -1527,13 +2001,13 @@ var ChangeRecorder = class {
 		return group;
 	}
 	order(container) {
-		require_advanced.profile.recorder("orderCaptures");
+		require_scheduler.profile.recorder("orderCaptures");
 		let group = this.groups.get(container.parent);
 		if (group?.order || this.covered(container.at)) return;
 		group ??= this.createGroup(container);
 		group.order = orderOf(container.node, container.value);
-		require_advanced.profile.recorder("orderSnapshots");
-		require_advanced.profile.recorder("orderItems", group.order.length);
+		require_scheduler.profile.recorder("orderSnapshots");
+		require_scheduler.profile.recorder("orderItems", group.order.length);
 	}
 	tree(container, id) {
 		const { at, value: tree } = container;
@@ -1551,8 +2025,8 @@ var ChangeRecorder = class {
 			this.register(fact);
 		}
 		if (id !== void 0 && !fact.nodes.has(id)) {
-			require_advanced.profile.recorder("treeNodes");
-			fact.nodes.set(id, Object.hasOwn(tree.nodes, id) ? require_advanced.copyTreeNode(tree.nodes[id]) : void 0);
+			require_scheduler.profile.recorder("treeNodes");
+			fact.nodes.set(id, Object.hasOwn(tree.nodes, id) ? copyTreeNode(tree.nodes[id]) : void 0);
 		}
 	}
 	rollback() {
@@ -1565,7 +2039,7 @@ var ChangeRecorder = class {
 			const fact = facts[i];
 			if (fact.kind === "members") for (const member of fact.members?.values() ?? []) {
 				if (!member) continue;
-				installMember(fact.parent, memberKey(fact, member.key), member.present, member.present ? require_advanced.copyValue(member.node, member.value) : void 0);
+				installMember(fact.parent, memberKey(fact, member.key), member.present, member.present ? copyValue(member.node, member.value) : void 0);
 			}
 			else if (fact.kind === "tree") restore(fact, this.state.schema, this.state.document);
 		}
@@ -1573,19 +2047,19 @@ var ChangeRecorder = class {
 	}
 	seal() {
 		if (this.resetBefore) {
-			if (require_advanced.equalValue(this.state.schema, this.resetBefore.value, this.state.document)) return require_driver.sealChanges([]);
-			require_advanced.profile.recorder("sealed");
+			if (equalValue(this.state.schema, this.resetBefore.value, this.state.document)) return require_driver.sealChanges([]);
+			require_scheduler.profile.recorder("sealed");
 			return require_driver.sealChanges([{
 				kind: "reset",
 				before: this.resetBefore.value,
-				after: require_advanced.copyValue(this.state.schema, this.state.document)
+				after: copyValue(this.state.schema, this.state.document)
 			}]);
 		}
 		const changes = [];
 		for (const fact of this.facts) if (fact.kind === "members") sealMembers(fact, changes);
 		else sealTree(fact, this.state, changes);
 		const result = require_driver.sealChanges(changes);
-		require_advanced.profile.recorder("sealed", result.changes.length);
+		require_scheduler.profile.recorder("sealed", result.changes.length);
 		return result;
 	}
 };
@@ -1605,7 +2079,7 @@ var MutationSession = class {
 		this.resolvedRoot = state.document;
 	}
 	validate(node, value, at) {
-		const failure = require_advanced.checkValue(node, value, at);
+		const failure = checkValue(node, value, at);
 		if (failure) require_driver.invalidValue(failure);
 	}
 	resolveContainer(at) {
@@ -1627,7 +2101,7 @@ var MutationSession = class {
 			this.validate(this.state.schema, value, at);
 			if (Object.is(this.state.document, value)) return;
 			this.recorder.reset();
-			this.state.document = require_advanced.copyValue(this.state.schema, value);
+			this.state.document = copyValue(this.state.schema, value);
 			this.invalidate();
 			return;
 		}
@@ -1669,12 +2143,12 @@ var MutationSession = class {
 		const previous = container.parent[physicalKey];
 		if (existed === present && (!present || Object.is(previous, value))) return false;
 		if (parentNode.kind === "map" || parentNode.kind === "table") {
-			const failure = require_advanced.checkKey(parentNode.key, key, []);
+			const failure = checkKey(parentNode.key, key, []);
 			if (failure) return require_driver.fail(container.at.concat(key, ...failure.address), "invalid-key", failure.message);
 		}
 		if (present) {
 			if (node.kind === "field") {
-				const failure = require_advanced.checkValue(node, value, []);
+				const failure = checkValue(node, value, []);
 				if (failure) return require_driver.invalidValue(failure, container.at.concat(key, ...failure.address));
 			} else this.validate(node, value, container.at.concat(key));
 			if (parentNode.kind === "list" && parentNode.keyOf(value) !== key) return require_driver.fail(container.at.concat(key), "invalid-list-key", "Replacing an item must retain its addressed key.");
@@ -1682,7 +2156,7 @@ var MutationSession = class {
 		const membershipChanged = entry && existed !== present;
 		if (membershipChanged && (parentNode.kind === "list" || parentNode.kind === "table")) this.recorder.order(container);
 		this.recorder.member(container, key, member, physicalKey);
-		const next = present ? node.kind === "field" ? value : require_advanced.copyValue(node, value) : void 0;
+		const next = present ? node.kind === "field" ? value : copyValue(node, value) : void 0;
 		installMember(container.parent, physicalKey, present, next);
 		if (node.kind !== "field" || membershipChanged) this.invalidate();
 		return membershipChanged;
@@ -1722,12 +2196,12 @@ function apply(session, changes, direction) {
 		}
 		if (change.order) {
 			const keys = node.kind === "table" ? Object.keys(container.parent) : orderOf(node, current);
-			if (!require_advanced.matches(change.order[side], keys)) return require_driver.fail(change.at, "invalid-changes", "Order must contain exactly the resulting keys.");
+			if (!matches(change.order[side], keys)) return require_driver.fail(change.at, "invalid-changes", "Order must contain exactly the resulting keys.");
 			installOrder(node, current, change.order[side]);
 			session.invalidate();
 		} else if (membershipChanged && node.kind === "table") {
 			const ids = current.ids;
-			if (!require_advanced.matches(ids, Object.keys(container.parent))) return require_driver.fail(change.at, "invalid-changes", "Table membership changes require a matching order.");
+			if (!matches(ids, Object.keys(container.parent))) return require_driver.fail(change.at, "invalid-changes", "Table membership changes require a matching order.");
 		}
 	} else {
 		const container = session.resolveTree(change.at);
@@ -1740,16 +2214,26 @@ function apply(session, changes, direction) {
 		for (const item of change.nodes) {
 			const next = side === "after" ? item.kind !== "removed" ? item.after : void 0 : item.kind !== "added" ? item.before : void 0;
 			if (next !== void 0) {
-				const diagnostic = require_advanced.checkTreePayload(node.value, next, change.at.concat(item.id));
+				const diagnostic = checkTreePayload(node.value, next, change.at.concat(item.id));
 				if (diagnostic) require_driver.invalidValue(diagnostic);
 			}
-			installMember(current.nodes, item.id, next !== void 0, next && require_advanced.copyTreeNode(next));
+			installMember(current.nodes, item.id, next !== void 0, next && copyTreeNode(next));
 		}
-		if (!require_context.validate(current)) return require_driver.fail(change.at, "invalid-tree", "Invalid tree structure.");
+		if (!require_driver.validate(current)) return require_driver.fail(change.at, "invalid-tree", "Invalid tree structure.");
 		session.invalidate();
 	}
 }
 //#endregion
+//#region core/src/runtime/readable.ts
+const readonlyDocument = (runtime) => {
+	const readable = {
+		revision: runtime.revision,
+		subscribe: runtime.subscribe
+	};
+	require_driver.bindContext(readable, require_driver.contextOf(runtime));
+	return Object.freeze(readable);
+};
+//#endregion
 //#region core/src/runtime/notification.ts
 const attachProjection = (notification, processor) => {
 	const entry = {
@@ -1913,18 +2397,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 = require_advanced.checkValue(input.schema, input.initial);
-	if (invalid) throw new require_advanced.ParseError(invalid);
+	const schema = schemaNodeOf(input.schema);
+	const invalid = checkValue(schema, input.initial);
+	if (invalid) throw new ParseError(invalid);
 	const state = {
-		schema: input.schema,
-		document: require_advanced.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();
@@ -1957,7 +2442,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);
@@ -2004,6 +2489,7 @@ const createDocument = (input) => {
 	runtime = {
 		schema: input.schema,
 		revision: () => revision,
+		readonly: () => readonlyAlias ??= readonlyDocument(runtime),
 		update: (run, options) => {
 			const source = options?.source ?? "local";
 			let value;
@@ -2022,13 +2508,16 @@ const createDocument = (input) => {
 				value
 			};
 		},
-		apply: (inputChanges, options) => mutate({
-			kind: "apply",
-			source: options?.source ?? "local"
-		}, options?.history ?? true, (session) => {
-			if (!options || options.expectedRevision !== revision) require_driver.fail([], "baseline-mismatch", "apply requires the current expectedRevision.");
-			apply(session, require_driver.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) require_driver.fail([], "baseline-mismatch", "apply requires the current expectedRevision.");
+				apply(session, require_driver.decodeChanges(inputChanges), "forward");
+			});
+		},
 		replace: (value, options) => {
 			const source = options?.source ?? "system";
 			return mutate({
@@ -2038,14 +2527,14 @@ const createDocument = (input) => {
 		},
 		snapshot: () => {
 			if (state.disposed) throw new DocumentDisposedError();
-			return require_advanced.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) => require_advanced.compilePath(input.schema, "value", p)), listener);
+			return notifications.subscribeTargets(picks.map((p) => compilePath(schema, "value", p)), listener);
 		}),
 		history: history.api,
 		dispose: () => {
@@ -2067,27 +2556,25 @@ const createDocument = (input) => {
 		driver: void 0,
 		bypassDepth: 0
 	};
-	require_context.bindContext(runtime, context);
-	require_context.bindContext(history.api, context);
+	require_driver.bindContext(runtime, context);
+	require_driver.bindContext(history.api, context);
 	return runtime;
 };
 //#endregion
-//#region core/src/runtime/readable.ts
-const asReadable = (runtime) => {
-	const readable = {
-		revision: runtime.revision,
-		subscribe: runtime.subscribe
-	};
-	require_context.bindContext(readable, require_context.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())
 	};
@@ -2095,7 +2582,7 @@ const createDependencyTracker = () => {
 //#endregion
 //#region core/src/runtime/access.ts
 const readWith = (runtime, run, dependencies) => {
-	const state = require_context.contextOf(runtime).state;
+	const state = require_driver.contextOf(runtime).state;
 	if (state.disposed) throw new DocumentDisposedError();
 	state.projectionLocks += 1;
 	try {
@@ -2116,7 +2603,7 @@ const sameDependencySet = (left, right) => {
 	return true;
 };
 const select = (document, selector, equality = Object.is) => {
-	const context = require_context.contextOf(document);
+	const context = require_driver.contextOf(document);
 	let initialized = false;
 	let value;
 	let selectedRevision = 0;
@@ -2176,6 +2663,281 @@ const select = (document, selector, equality = Object.is) => {
 	});
 };
 //#endregion
+//#region core/src/projection/input.ts
+const valueInput = (initial, equality = Object.is) => require_scheduler.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 require_scheduler.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" ? require_scheduler.defineSource({
+		kind: "external-collection",
+		source
+	}, {
+		kind: "collection",
+		equality: Object.is
+	}) : require_scheduler.defineSource({
+		kind: "external-value",
+		source,
+		equality: Object.is
+	}, {
+		kind: "value",
+		equality: Object.is
+	});
+	if ("current" in source && typeof source.current === "function") return require_scheduler.defineSource({
+		kind: "readable",
+		readable: source,
+		equality: Object.is
+	}, {
+		kind: "value",
+		equality: Object.is
+	});
+	const document = source;
+	const state = require_driver.contextOf(document).state;
+	const selected = selector ? compilePath(state.schema, "auto", selector) : Object.freeze({
+		kind: "value",
+		schema: state.schema,
+		address: Object.freeze([])
+	});
+	return require_scheduler.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 : require_scheduler.snapshotCollectionView(source.read);
+const outputKind = (projection) => {
+	const ref = require_scheduler.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" || require_scheduler.isProjection(value)) return false;
+	const candidate = value;
+	return require_scheduler.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 (!require_record.isPlainObject(dependencies) || require_scheduler.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(require_scheduler.projectionRef);
+	const [projection] = require_scheduler.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));
+			require_scheduler.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 (!require_record.isPlainObject(dependencySpecs) || require_scheduler.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 (require_scheduler.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] = require_scheduler.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);
+							require_scheduler.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));
+						require_scheduler.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));
@@ -2239,7 +3001,7 @@ const collectionHasAnyChange = (change) => change.kind === "reset" || Boolean(ch
 //#region core/src/projection/collection/index.ts
 const height = (node) => node?.height ?? 0;
 const node = (key, value, left, right) => {
-	require_advanced.profile.collectionIndex.node();
+	require_scheduler.profile.collectionIndex.node();
 	return Object.freeze({
 		key,
 		value,
@@ -2300,7 +3062,7 @@ var PersistentKeyedIndex = class PersistentKeyedIndex {
 	}
 	static from(entries) {
 		const sorted = [...entries].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
-		require_advanced.profile.collectionIndex.build(sorted.length);
+		require_scheduler.profile.collectionIndex.build(sorted.length);
 		return new PersistentKeyedIndex(fromSorted(sorted));
 	}
 	get(key) {
@@ -2374,7 +3136,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();
@@ -2385,6 +3147,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);
@@ -2404,15 +3167,15 @@ const createCollectionOutput = () => {
 		reset = initialize;
 		const read = (next) => ({
 			get: (key) => {
-				require_advanced.assertScope(active);
+				require_scheduler.assertScope(active);
 				return next ? getNext(key) : published.get(key);
 			},
 			has: (key) => {
-				require_advanced.assertScope(active);
+				require_scheduler.assertScope(active);
 				return next ? hasNext(key) : published.has(key);
 			},
 			ids: () => {
-				require_advanced.assertScope(active);
+				require_scheduler.assertScope(active);
 				return next ? Object.freeze(explicitOrder ? [...explicitOrder] : [...deriveIds()]) : published.ids();
 			}
 		});
@@ -2421,7 +3184,7 @@ const createCollectionOutput = () => {
 			next: read(true),
 			output: {
 				set: (key, value) => {
-					require_advanced.assertScope(active);
+					require_scheduler.assertScope(active);
 					if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
 					staged.set(key, {
 						present: true,
@@ -2429,11 +3192,11 @@ const createCollectionOutput = () => {
 					});
 				},
 				remove: (key) => {
-					require_advanced.assertScope(active);
+					require_scheduler.assertScope(active);
 					staged.set(key, { present: false });
 				},
 				order: (order) => {
-					require_advanced.assertScope(active);
+					require_scheduler.assertScope(active);
 					explicitOrder = Object.freeze([...order]);
 				}
 			}
@@ -2443,7 +3206,7 @@ const createCollectionOutput = () => {
 		if (cleared) {
 			for (const key of published.keys()) if (!staged.has(key)) staged.set(key, { present: false });
 		}
-		require_advanced.profile.projection("touchedKeys", staged.size);
+		require_scheduler.profile.projection("touchedKeys", staged.size);
 		const added = /* @__PURE__ */ new Set();
 		const removed = /* @__PURE__ */ new Set();
 		const updated = /* @__PURE__ */ new Set();
@@ -2462,12 +3225,11 @@ 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
-		]);
-		require_advanced.profile.projection("changedKeys", changedKeys.size);
+		const changedKeys = /* @__PURE__ */ new Set();
+		added.forEach((key) => changedKeys.add(key));
+		removed.forEach((key) => changedKeys.add(key));
+		updated.forEach((key) => changedKeys.add(key));
+		require_scheduler.profile.projection("changedKeys", changedKeys.size);
 		const addedEntries = [];
 		const updatedEntries = [];
 		const removedEntries = [];
@@ -2475,7 +3237,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,
@@ -2505,15 +3268,15 @@ const createCollectionOutput = () => {
 		kind: "collection",
 		read: {
 			get: (key) => {
-				require_advanced.assertScope(active);
+				require_scheduler.assertScope(active);
 				return getNext(key);
 			},
 			has: (key) => {
-				require_advanced.assertScope(active);
+				require_scheduler.assertScope(active);
 				return hasNext(key);
 			},
 			ids: () => {
-				require_advanced.assertScope(active);
+				require_scheduler.assertScope(active);
 				return nextIds;
 			}
 		},
@@ -2523,10 +3286,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: () => {
@@ -2535,9 +3302,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();
@@ -2550,6 +3320,7 @@ const createCollectionOutput = () => {
 			published.release();
 			staged.clear();
 			listeners.clear();
+			consumers.clear();
 			nextIds = Object.freeze([]);
 			change = void 0;
 			initialized = false;
@@ -2558,15 +3329,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;
@@ -2575,6 +3349,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;
@@ -2583,12 +3358,12 @@ const createValueOutput = () => {
 		return {
 			previous: initialized ? value : void 0,
 			next: () => {
-				require_advanced.assertScope(active);
+				require_scheduler.assertScope(active);
 				if (staged !== unset) return staged;
 				return initialize ? void 0 : initialized ? value : void 0;
 			},
 			output: Object.freeze({ set: (candidate) => {
-				require_advanced.assertScope(active);
+				require_scheduler.assertScope(active);
 				staged = candidate;
 			} })
 		};
@@ -2608,20 +3383,24 @@ const createValueOutput = () => {
 		return changed;
 	};
 	return {
+		kind: "value",
+		get owner() {
+			return binding.owner();
+		},
 		begin,
 		seal,
-		context: (active, cause) => {
-			require_advanced.assertScope(active);
+		context: (active) => {
+			require_scheduler.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,
@@ -2632,9 +3411,13 @@ const createValueOutput = () => {
 			initialized = true;
 		},
 		emit: (call) => {
-			require_advanced.profile.materialized.notification();
+			require_scheduler.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;
@@ -2643,6 +3426,7 @@ const createValueOutput = () => {
 		},
 		release: () => {
 			listeners.clear();
+			consumers.clear();
 			staged = unset;
 			value = next = void 0;
 			initialized = false;
@@ -2650,8 +3434,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
@@ -2663,63 +3450,27 @@ const createProcessor = (scheduler, definition, dependencies) => {
 	let instance;
 	let cause;
 	const check = () => {
-		if (!scheduler.active || processor.disposed) throw new require_advanced.ProjectionDisposedError();
+		if (!scheduler.active || processor.disposed) throw new require_scheduler.ProjectionDisposedError();
 		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) => {
@@ -2738,40 +3489,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();
-			require_advanced.profile.materialized[reset ? "rebuilt" : "updated"]();
-			let result = instance.evaluate({
+			require_scheduler.profile.materialized[reset ? "rebuilt" : "updated"]();
+			require_scheduler.assertSynchronous(instance.evaluate({
 				reset,
 				cause: runCause,
 				sources,
 				outputs
-			});
-			require_advanced.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
-				});
-				require_advanced.assertSynchronous(result);
-				if (result?.kind === "rebuild") throw new TypeError("Reset projection processor cannot rebuild again.");
-				return seal(true);
-			}
+			}));
 			return seal(reset);
 		} finally {
 			active = false;
@@ -2783,7 +3522,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,
@@ -2793,27 +3532,38 @@ 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 {
 		scheduler.initialize(() => {
 			const invalid = dependencies.find((output) => output.owner.fault || output.owner.disposed);
-			if (invalid) throw invalid.owner.fault ?? new require_advanced.ProjectionDisposedError();
+			if (invalid) throw invalid.owner.fault ?? new require_scheduler.ProjectionDisposedError();
 			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
@@ -2979,57 +3729,11 @@ 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) : require_advanced.equalValue(node, left, right);
-const replaceValue = (node, previous, current) => equivalent(node, previous, current) ? previous : require_advanced.copyValue(node, current);
+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) => {
-	require_advanced.profile.copy.shallowRecord(Object.getOwnPropertyNames(value).length);
+	require_scheduler.profile.copy.shallowRecord(Object.getOwnPropertyNames(value).length);
 	return Object.create(Object.getPrototypeOf(value), Object.getOwnPropertyDescriptors(value));
 };
 const materializeRecordChild = (node, previous, current, key, dirty) => {
@@ -3041,7 +3745,7 @@ const materializeRecordChild = (node, previous, current, key, dirty) => {
 		present: false,
 		value: void 0
 	};
-	const next = before ? materializeDocumentValue(node, previous[key], current[key], dirty) : require_advanced.copyValue(node, current[key]);
+	const next = before ? materializeDocumentValue(node, previous[key], current[key], dirty) : copyValue(node, current[key]);
 	if (before && next === previous[key]) return { changed: false };
 	return {
 		changed: true,
@@ -3051,7 +3755,7 @@ const materializeRecordChild = (node, previous, current, key, dirty) => {
 };
 const materializeObject = (node, previous, current, dirty) => {
 	if (node.kind === "variant" && previous[node.tag] !== current[node.tag]) return replaceValue(node, previous, current);
-	const layout = require_advanced.compiledShape(node, current);
+	const layout = compiledShape(node, current);
 	if (!layout) return replaceValue(node, previous, current);
 	let result;
 	for (const [key, childDirty] of dirty.children) {
@@ -3060,7 +3764,7 @@ const materializeObject = (node, previous, current, dirty) => {
 		const child = materializeRecordChild(member.node, previous, current, key, childDirty);
 		if (!child.changed) continue;
 		result ??= cloneRecord(previous);
-		require_context.installOwn(result, key, child.present, child.value);
+		require_record.installOwn(result, key, child.present, child.value);
 	}
 	return result ?? previous;
 };
@@ -3070,12 +3774,12 @@ const materializeMap = (node, previous, current, dirty) => {
 		const child = materializeRecordChild(node.value, previous, current, key, childDirty);
 		if (!child.changed) continue;
 		result ??= cloneRecord(previous);
-		require_context.installOwn(result, key, child.present, child.value);
+		require_record.installOwn(result, key, child.present, child.value);
 	}
 	return result ?? previous;
 };
 const materializeTable = (node, previous, current, dirty) => {
-	if (!require_context.isRecord(previous.byId) || !require_context.isRecord(current.byId)) return replaceValue(node, previous, current);
+	if (!require_record.isRecord(previous.byId) || !require_record.isRecord(current.byId)) return replaceValue(node, previous, current);
 	const beforeById = previous.byId;
 	const afterById = current.byId;
 	let result;
@@ -3084,28 +3788,28 @@ const materializeTable = (node, previous, current, dirty) => {
 		const child = materializeRecordChild(node.value, beforeById, afterById, key, childDirty);
 		if (!child.changed) continue;
 		nextById ??= cloneRecord(beforeById);
-		require_context.installOwn(nextById, key, child.present, child.value);
+		require_record.installOwn(nextById, key, child.present, child.value);
 	}
 	if (nextById) {
 		result = cloneRecord(previous);
-		require_context.installOwn(result, "byId", true, nextById);
+		require_record.installOwn(result, "byId", true, nextById);
 	}
 	if (dirty.order) {
 		const beforeIds = previous.ids;
 		const afterIds = current.ids;
 		if (!Array.isArray(beforeIds) || !Array.isArray(afterIds)) return replaceValue(node, previous, current);
-		if (!require_advanced.equal(beforeIds, afterIds)) {
+		if (!equal(beforeIds, afterIds)) {
 			result ??= cloneRecord(previous);
-			require_context.installOwn(result, "ids", true, [...afterIds]);
+			require_record.installOwn(result, "ids", true, [...afterIds]);
 		}
 	}
 	return result ?? previous;
 };
 const materializeList = (node, previous, current, dirty) => {
 	if (dirty.order) {
-		const before = require_advanced.listSequence(previous, node.keyOf);
-		const after = require_advanced.listSequence(current, node.keyOf);
-		let changed = !require_advanced.equal(before.order, after.order);
+		const before = listSequence(previous, node.keyOf);
+		const after = listSequence(current, node.keyOf);
+		let changed = !equal(before.order, after.order);
 		const result = new Array(after.order.length);
 		for (let index = 0; index < after.order.length; index++) {
 			const key = after.order[index];
@@ -3124,8 +3828,8 @@ const materializeList = (node, previous, current, dirty) => {
 		return changed ? result : previous;
 	}
 	let result;
-	const before = require_advanced.indexedKeys(previous, node.keyOf);
-	const after = require_advanced.indexedKeys(current, node.keyOf);
+	const before = indexedKeys(previous, node.keyOf);
+	const after = indexedKeys(current, node.keyOf);
 	for (const [key, childDirty] of dirty.children) {
 		const previousIndex = before.index(key);
 		const currentIndex = after.index(key);
@@ -3138,14 +3842,14 @@ const materializeList = (node, previous, current, dirty) => {
 	return result ?? previous;
 };
 const materializeTree = (node, previous, current, dirty) => {
-	if (!require_context.isRecord(previous.nodes) || !require_context.isRecord(current.nodes)) return replaceValue(node, previous, current);
+	if (!require_record.isRecord(previous.nodes) || !require_record.isRecord(current.nodes)) return replaceValue(node, previous, current);
 	let result;
 	if (dirty.treeRoot) {
 		const beforePresent = Object.hasOwn(previous, "rootId");
 		const afterPresent = Object.hasOwn(current, "rootId");
 		if (beforePresent !== afterPresent || !Object.is(previous.rootId, current.rootId)) {
 			result = cloneRecord(previous);
-			require_context.installOwn(result, "rootId", afterPresent, current.rootId);
+			require_record.installOwn(result, "rootId", afterPresent, current.rootId);
 		}
 	}
 	let nodes;
@@ -3154,13 +3858,13 @@ const materializeTree = (node, previous, current, dirty) => {
 		const afterPresent = Object.hasOwn(current.nodes, id);
 		const before = beforePresent ? previous.nodes[id] : void 0;
 		const after = afterPresent ? current.nodes[id] : void 0;
-		if (beforePresent === afterPresent && require_advanced.equalTreeNode(before, after)) continue;
+		if (beforePresent === afterPresent && equalTreeNode(before, after)) continue;
 		nodes ??= cloneRecord(previous.nodes);
-		require_context.installOwn(nodes, id, afterPresent, after && require_advanced.copyTreeNode(after));
+		require_record.installOwn(nodes, id, afterPresent, after && copyTreeNode(after));
 	}
 	if (nodes) {
 		result ??= cloneRecord(previous);
-		require_context.installOwn(result, "nodes", true, nodes);
+		require_record.installOwn(result, "nodes", true, nodes);
 	}
 	return result ?? previous;
 };
@@ -3168,26 +3872,72 @@ const materializeDocumentValue = (node, previous, current, dirty) => {
 	if (!hasDocumentDirty(dirty)) return previous;
 	if (dirty.replace || previous === void 0 || current === void 0 || node.kind === "field") return replaceValue(node, previous, current);
 	if (node.kind === "object" || node.kind === "variant") {
-		if (!require_context.isRecord(previous) || !require_context.isRecord(current)) return replaceValue(node, previous, current);
+		if (!require_record.isRecord(previous) || !require_record.isRecord(current)) return replaceValue(node, previous, current);
 		return materializeObject(node, previous, current, dirty);
 	}
 	if (node.kind === "map") {
-		if (!require_context.isRecord(previous) || !require_context.isRecord(current)) return replaceValue(node, previous, current);
+		if (!require_record.isRecord(previous) || !require_record.isRecord(current)) return replaceValue(node, previous, current);
 		return materializeMap(node, previous, current, dirty);
 	}
 	if (node.kind === "table") {
-		if (!require_context.isRecord(previous) || !require_context.isRecord(current)) return replaceValue(node, previous, current);
+		if (!require_record.isRecord(previous) || !require_record.isRecord(current)) return replaceValue(node, previous, current);
 		return materializeTable(node, previous, current, dirty);
 	}
 	if (node.kind === "list") {
 		if (!Array.isArray(previous) || !Array.isArray(current)) return replaceValue(node, previous, current);
 		return materializeList(node, previous, current, dirty);
 	}
-	if (!require_context.isRecord(previous) || !require_context.isRecord(current)) return replaceValue(node, previous, current);
+	if (!require_record.isRecord(previous) || !require_record.isRecord(current)) return replaceValue(node, previous, current);
 	return materializeTree(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,
@@ -3289,9 +4039,8 @@ const mergeCollectionChanges = (selector, pending, changes) => {
 };
 //#endregion
 //#region core/src/projection/source/boundary.ts
-const sourceError = (source, cause) => new require_advanced.ProjectionError("source", source.name, [source.outputs[0].revision()], cause);
+const sourceError = (cause) => new require_scheduler.ProjectionError("source", cause);
 const createValueBoundary = (scheduler, name, initial, equality, prepare, clearSource) => {
-	const state = createValueOutput();
 	let boundary;
 	let pendingReset = false;
 	let pendingCause;
@@ -3299,29 +4048,15 @@ const createValueBoundary = (scheduler, name, initial, equality, prepare, clearS
 	let recovering = false;
 	let cleanup;
 	const check = () => {
-		if (!scheduler.active || boundary.disposed) throw new require_advanced.ProjectionDisposedError();
+		if (!scheduler.active || boundary.disposed) throw new require_scheduler.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,
@@ -3357,24 +4092,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;
@@ -3383,7 +4136,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);
 	};
@@ -3402,30 +4155,29 @@ const stageCollectionRead = (state, read, active, options) => {
 	const evaluation = state.begin(active, options.reset);
 	if (options.reset) {
 		const ids = read.ids();
-		require_advanced.profile.collectionView.idsScanned(ids.length);
+		require_scheduler.profile.collectionView.idsScanned(ids.length);
 		for (const key of ids) {
-			require_advanced.profile.collectionView.mapped();
+			require_scheduler.profile.collectionView.mapped();
 			evaluation.output.set(key, read.get(key));
 		}
 		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) require_advanced.profile.collectionView.idsScanned(keys.length);
+		if (!options.candidates) require_scheduler.profile.collectionView.idsScanned(keys.length);
 		for (const key of keys) if (read.has(key)) {
-			require_advanced.profile.collectionView.mapped();
+			require_scheduler.profile.collectionView.mapped();
 			evaluation.output.set(key, read.get(key));
 		} else evaluation.output.remove(key);
 		if (options.orderMayChange || !options.candidates) {
 			const ids = read.ids();
-			if (options.candidates) require_advanced.profile.collectionView.idsScanned(ids.length);
+			if (options.candidates) require_scheduler.profile.collectionView.idsScanned(ids.length);
 			evaluation.output.order(ids);
 		}
 	}
 	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;
@@ -3436,29 +4188,15 @@ const createCollectionBoundary = (scheduler, name, readLatest, equality, clearSo
 	const candidates = /* @__PURE__ */ new Set();
 	let cleanup;
 	const check = () => {
-		if (!scheduler.active || boundary.disposed) throw new require_advanced.ProjectionDisposedError();
+		if (!scheduler.active || boundary.disposed) throw new require_scheduler.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,
@@ -3471,7 +4209,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,
@@ -3500,26 +4238,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;
@@ -3531,7 +4287,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);
 	};
@@ -3554,7 +4310,7 @@ const documentRootTarget = Object.freeze({
 const createDocumentSourceRegistry = (scheduler) => {
 	const documents = /* @__PURE__ */ new Map();
 	const connection = (runtime) => {
-		const context = require_context.contextOf(runtime);
+		const context = require_driver.contextOf(runtime);
 		const state = context.state;
 		const cached = documents.get(state);
 		if (cached) return cached;
@@ -3565,14 +4321,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;
@@ -3585,34 +4346,65 @@ 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;
 	};
 	const materialize = (definition) => {
 		if (definition.source.kind !== "document") throw new Error("Invalid document source.");
 		const { document, selector } = definition.source;
-		const state = require_context.contextOf(document).state;
+		const state = require_driver.contextOf(document).state;
 		const current = () => resolveValue(state.schema, state.document, selector.address);
 		const disposed = () => {
 			if (state.disposed) throw new Error("Document has been disposed.");
@@ -3624,15 +4416,15 @@ const createDocumentSourceRegistry = (scheduler) => {
 				const resolved = current();
 				const node = resolved?.node;
 				const value = resolved?.value;
-				if (selector.tree?.kind === "root") return node?.kind === "tree" && require_context.isRecord(value) && typeof value.rootId === "string" ? value.rootId : void 0;
+				if (selector.tree?.kind === "root") return node?.kind === "tree" && require_record.isRecord(value) && typeof value.rootId === "string" ? value.rootId : void 0;
 				if (selector.tree?.kind === "node") {
-					if (node?.kind !== "tree" || !require_context.isRecord(value) || !require_context.isRecord(value.nodes)) return void 0;
+					if (node?.kind !== "tree" || !require_record.isRecord(value) || !require_record.isRecord(value.nodes)) return void 0;
 					const entry = Object.hasOwn(value.nodes, selector.tree.id) ? value.nodes[selector.tree.id] : void 0;
-					if (require_advanced.equalTreeNode(previous, entry)) return previous;
-					return entry ? require_advanced.copyTreeNode(entry) : void 0;
+					if (equalTreeNode(previous, entry)) return previous;
+					return entry ? copyTreeNode(entry) : void 0;
 				}
 				if (!node) return void 0;
-				return previous === void 0 ? require_advanced.copyValue(node, value) : materializeDocumentValue(node, previous, value, dirty);
+				return previous === void 0 ? copyValue(node, value) : materializeDocumentValue(node, previous, value, dirty);
 			};
 			const initial = read();
 			let boundary;
@@ -3640,18 +4432,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;
 		}
@@ -3662,50 +4462,50 @@ const createDocumentSourceRegistry = (scheduler) => {
 			const node = resolved?.node;
 			const value = resolved?.value;
 			const treeNodes = selector.tree?.kind === "nodes";
-			const entryNode = !treeNodes && node ? require_advanced.collectionEntryNode(node) : void 0;
+			const entryNode = !treeNodes && node ? collectionEntryNode(node) : void 0;
 			const snapshots = /* @__PURE__ */ new Map();
 			const replacement = createDocumentDirty();
 			if (pending.reset) markDocumentReplace(replacement, []);
 			const ids = () => {
-				require_advanced.assertScope(active);
-				if (treeNodes) return node?.kind === "tree" && require_context.isRecord(value) && require_context.isRecord(value.nodes) ? Object.freeze(Object.keys(value.nodes)) : Object.freeze([]);
-				if (node?.kind === "map" && require_context.isRecord(value)) return Object.freeze(Object.keys(value));
-				if (node?.kind === "table" && require_context.isRecord(value) && Array.isArray(value.ids)) return Object.freeze([...value.ids]);
-				if (node?.kind === "list" && Array.isArray(value)) return Object.freeze(require_advanced.toArray(require_advanced.indexedKeys(value, node.keyOf)));
+				require_scheduler.assertScope(active);
+				if (treeNodes) return node?.kind === "tree" && require_record.isRecord(value) && require_record.isRecord(value.nodes) ? Object.freeze(Object.keys(value.nodes)) : Object.freeze([]);
+				if (node?.kind === "map" && require_record.isRecord(value)) return Object.freeze(Object.keys(value));
+				if (node?.kind === "table" && require_record.isRecord(value) && Array.isArray(value.ids)) return Object.freeze([...value.ids]);
+				if (node?.kind === "list" && Array.isArray(value)) return Object.freeze(toArray(indexedKeys(value, node.keyOf)));
 				return Object.freeze([]);
 			};
 			const has = (key) => {
-				require_advanced.assertScope(active);
-				if (treeNodes) return Boolean(node?.kind === "tree" && require_context.isRecord(value) && require_context.isRecord(value.nodes) && Object.hasOwn(value.nodes, key));
-				if (node?.kind === "map" && require_context.isRecord(value)) return Object.hasOwn(value, key);
-				if (node?.kind === "table" && require_context.isRecord(value) && require_context.isRecord(value.byId)) return Object.hasOwn(value.byId, key);
-				if (node?.kind === "list" && Array.isArray(value)) return require_advanced.indexedKeys(value, node.keyOf).index(key) >= 0;
+				require_scheduler.assertScope(active);
+				if (treeNodes) return Boolean(node?.kind === "tree" && require_record.isRecord(value) && require_record.isRecord(value.nodes) && Object.hasOwn(value.nodes, key));
+				if (node?.kind === "map" && require_record.isRecord(value)) return Object.hasOwn(value, key);
+				if (node?.kind === "table" && require_record.isRecord(value) && require_record.isRecord(value.byId)) return Object.hasOwn(value.byId, key);
+				if (node?.kind === "list" && Array.isArray(value)) return indexedKeys(value, node.keyOf).index(key) >= 0;
 				return false;
 			};
 			const raw = (key) => {
 				if (treeNodes) {
-					if (node?.kind !== "tree" || !require_context.isRecord(value) || !require_context.isRecord(value.nodes)) return void 0;
+					if (node?.kind !== "tree" || !require_record.isRecord(value) || !require_record.isRecord(value.nodes)) return void 0;
 					return Object.hasOwn(value.nodes, key) ? value.nodes[key] : void 0;
 				}
-				if (node?.kind === "map" && require_context.isRecord(value)) return Object.hasOwn(value, key) ? value[key] : void 0;
-				if (node?.kind === "table" && require_context.isRecord(value) && require_context.isRecord(value.byId)) return Object.hasOwn(value.byId, key) ? value.byId[key] : void 0;
+				if (node?.kind === "map" && require_record.isRecord(value)) return Object.hasOwn(value, key) ? value[key] : void 0;
+				if (node?.kind === "table" && require_record.isRecord(value) && require_record.isRecord(value.byId)) return Object.hasOwn(value.byId, key) ? value.byId[key] : void 0;
 				if (node?.kind === "list" && Array.isArray(value)) {
-					const index = require_advanced.indexedKeys(value, node.keyOf).index(key);
+					const index = indexedKeys(value, node.keyOf).index(key);
 					return index < 0 ? void 0 : value[index];
 				}
 			};
 			return Object.freeze({
 				get: (key) => {
-					require_advanced.assertScope(active);
+					require_scheduler.assertScope(active);
 					if (!snapshots.has(key)) if (!has(key)) snapshots.set(key, void 0);
 					else {
 						const current = raw(key);
 						if (treeNodes) {
 							const entry = current;
 							const before = previous.has(key) ? previous.get(key) : void 0;
-							snapshots.set(key, require_advanced.equalTreeNode(before, entry) ? before : require_advanced.copyTreeNode(entry));
+							snapshots.set(key, equalTreeNode(before, entry) ? before : copyTreeNode(entry));
 						} else if (!entryNode) snapshots.set(key, current);
-						else if (!previous.has(key)) snapshots.set(key, require_advanced.copyValue(entryNode, current));
+						else if (!previous.has(key)) snapshots.set(key, copyValue(entryNode, current));
 						else {
 							const dirty = pending.entries.get(key) ?? (pending.reset ? replacement : void 0);
 							snapshots.set(key, dirty ? materializeDocumentValue(entryNode, previous.get(key), current, dirty) : previous.get(key));
@@ -3722,22 +4522,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;
 	};
@@ -3751,115 +4559,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", () => require_advanced.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) => {
-							require_advanced.assertScope(() => active);
-							const entry = staged.get(key);
-							return entry ? entry.present ? entry.value : void 0 : values.get(key);
-						},
-						has: (key) => {
-							require_advanced.assertScope(() => active);
-							const entry = staged.get(key);
-							return entry ? entry.present : values.has(key);
-						},
-						set: (key, value) => {
-							require_advanced.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) => {
-							require_advanced.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 {
-						require_advanced.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;
@@ -3893,19 +4609,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 = require_context.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 = require_driver.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);
 		}
@@ -3938,8 +4679,11 @@ const createSourceRegistry = (scheduler) => {
 				close() {
 					if (closed) return;
 					closed = true;
-					unsubscribe?.();
+					const stop = unsubscribe;
+					unsubscribe = void 0;
 					externalValues.delete(source);
+					members.clear();
+					stop?.();
 				}
 			};
 			try {
@@ -3954,9 +4698,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);
@@ -3989,8 +4738,11 @@ const createSourceRegistry = (scheduler) => {
 				close() {
 					if (closed) return;
 					closed = true;
-					unsubscribe?.();
+					const stop = unsubscribe;
+					unsubscribe = void 0;
 					externalCollections.delete(source);
+					members.clear();
+					stop?.();
 				}
 			};
 			try {
@@ -4022,9 +4774,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);
@@ -4039,25 +4796,173 @@ 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", () => require_scheduler.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) => {
+						require_scheduler.assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present ? entry.value : void 0 : values.get(key);
+					},
+					has: (key) => {
+						require_scheduler.assertScope(() => active);
+						const entry = staged.get(key);
+						return entry ? entry.present : values.has(key);
+					},
+					set: (key, value) => {
+						require_scheduler.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) => {
+						require_scheduler.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 {
+					require_scheduler.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];
 		}
 	};
 };
 //#endregion
 //#region core/src/projection/runtime.ts
 const createProjectionRuntime = (options) => {
-	const scheduler = require_advanced.createScheduler(options?.onError ?? (() => void 0));
+	const scheduler = require_scheduler.createScheduler(options?.onError ?? (() => void 0));
 	const sources = createSourceRegistry(scheduler);
 	const materialized = /* @__PURE__ */ new WeakMap();
 	const publicViews = /* @__PURE__ */ new WeakMap();
@@ -4067,7 +4972,7 @@ const createProjectionRuntime = (options) => {
 		const owner = definition.owner;
 		if (owner === void 0) return;
 		if (owner !== requester) throw new TypeError("Projection belongs to another scope.");
-		if (!requester?.active) throw new require_advanced.ProjectionDisposedError();
+		if (!requester?.active) throw new require_scheduler.ProjectionDisposedError();
 	};
 	const rememberScoped = (definition, requester) => {
 		if (requester && definition.owner === requester) requester.materialized.push(definition);
@@ -4085,7 +4990,7 @@ const createProjectionRuntime = (options) => {
 				...source.write ? { write: source.write } : {}
 			});
 		} else {
-			if (definition.owner === void 0 && definition.dependencies.some((dependency) => require_advanced.producerOf(dependency).owner !== void 0)) throw new TypeError("A root projection cannot depend on a scoped projection.");
+			if (definition.owner === void 0 && definition.dependencies.some((dependency) => require_scheduler.producerOf(dependency).owner !== void 0)) throw new TypeError("A root projection cannot depend on a scoped projection.");
 			const dependencies = definition.dependencies.map((dependency) => resolveOutput(dependency, requester));
 			const processor = createProcessor(scheduler, definition, Object.freeze(dependencies));
 			result = Object.freeze({
@@ -4093,19 +4998,20 @@ const createProjectionRuntime = (options) => {
 				outputs: processor.outputs
 			});
 		}
+		definition.materialized = true;
 		materialized.set(definition, result);
 		rememberScoped(definition, requester);
 		return result;
 	};
 	const resolveOutput = (projection, requester) => {
-		const ref = require_advanced.projectionRef(projection);
+		const ref = require_scheduler.projectionRef(projection);
 		const output = materializeProducer(ref.producer, requester).outputs[ref.output];
 		if (!output) throw new TypeError("Projection output does not exist.");
 		return output;
 	};
 	const assertOutput = (output) => {
 		scheduler.assertActive();
-		if (output.owner.disposed) throw new require_advanced.ProjectionDisposedError();
+		if (output.owner.disposed) throw new require_scheduler.ProjectionDisposedError();
 		if (output.owner.fault) throw output.owner.fault;
 	};
 	const publicCurrent = (output) => {
@@ -4115,7 +5021,7 @@ const createProjectionRuntime = (options) => {
 		const cached = publicViews.get(output);
 		if (cached?.revision === revision) return cached.value;
 		if (output.kind === "collection") {
-			const value = require_advanced.collectionView(current);
+			const value = require_scheduler.collectionView(current);
 			publicViews.set(output, {
 				revision,
 				value
@@ -4123,7 +5029,7 @@ const createProjectionRuntime = (options) => {
 			return value;
 		}
 		if (isMapLike(current)) {
-			const value = require_advanced.snapshotCollectionView(require_advanced.mapRead(current));
+			const value = require_scheduler.snapshotCollectionView(require_scheduler.mapRead(current));
 			publicViews.set(output, {
 				revision,
 				value
@@ -4133,12 +5039,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();
@@ -4150,45 +5056,57 @@ 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) => {
-		const ref = require_advanced.projectionRef(target);
+		const ref = require_scheduler.projectionRef(target);
 		if (ref.output !== 0 || ref.producer.kind !== "source") throw new TypeError("Projection is not an input.");
 		if (ref.producer.source.kind !== "value-input" && ref.producer.source.kind !== "collection-input") throw new TypeError("Projection is not an input.");
 		const write = materializeProducer(ref.producer, requester).write;
 		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();
@@ -4199,26 +5117,33 @@ const createProjectionRuntime = (options) => {
 		};
 		scopes.add(state);
 		const assertActive = () => {
-			if (!state.active) throw new require_advanced.ProjectionDisposedError();
+			if (!state.active) throw new require_scheduler.ProjectionDisposedError();
 			scheduler.assertActive();
 		};
-		const own = (projection) => {
+		function own(target) {
 			assertActive();
-			return require_advanced.ownProjection(projection, state);
-		};
-		const ownOutputTree = (tree) => {
-			if (require_advanced.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(require_advanced.input(initial, equality)), { collection: (initial) => own(require_advanced.input.collection(initial)) });
-		const scopedDerive = (dependencies, compute, equality) => own(require_advanced.derive(dependencies, compute, equality));
-		const scopedIncremental = Object.assign((dependencies, processor) => own(require_advanced.incremental(dependencies, processor)), {
-			collection: (dependencies, processor) => own(require_advanced.incremental.collection(dependencies, processor)),
-			group: (dependencies, defineOutputs, processor) => ownOutputTree(require_advanced.incremental.group(dependencies, defineOutputs, processor))
-		});
-		function scopeReadable(projection, selector, equality) {
+			const projections = [];
+			const collect = (value) => {
+				if (require_scheduler.isProjection(value)) {
+					projections.push(value);
+					return;
+				}
+				if (!require_record.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 (!require_scheduler.isProjection(child) && !require_record.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.");
+			require_scheduler.ownProjections(projections, state);
+			return target;
+		}
+		function scopeSelect(projection, selector, equality) {
 			assertActive();
 			const source = makeReadable(projection, selector, equality, state);
 			return Object.freeze({
@@ -4245,78 +5170,87 @@ 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
 exports.DocumentDisposedError = DocumentDisposedError;
 exports.DocumentReentrancyError = DocumentReentrancyError;
-exports.ParseError = require_advanced.ParseError;
-exports.ProjectionDisposedError = require_advanced.ProjectionDisposedError;
-exports.ProjectionError = require_advanced.ProjectionError;
+exports.ParseError = ParseError;
+exports.ProjectionDisposedError = require_scheduler.ProjectionDisposedError;
+exports.ProjectionError = require_scheduler.ProjectionError;
 exports.TransactionRejected = TransactionRejected;
-exports.asReadable = asReadable;
 exports.createDocument = createDocument;
 exports.createProjectionRuntime = createProjectionRuntime;
-exports.derive = require_advanced.derive;
-exports.field = require_advanced.field;
-exports.input = require_advanced.input;
-exports.list = require_advanced.list;
-exports.map = require_advanced.map;
-exports.object = require_advanced.object;
-exports.observe = require_advanced.observe;
-exports.optional = require_advanced.optional;
-exports.parse = require_advanced.parse;
+exports.derive = derive;
+exports.field = field;
+exports.input = input;
+exports.list = list;
+exports.map = map;
+exports.object = object;
+exports.observe = observe;
+exports.optional = optional;
+exports.parse = parse;
 exports.read = read;
 exports.replace = replace;
 exports.select = select;
 exports.snapshot = snapshot;
-exports.table = require_advanced.table;
-exports.tree = require_advanced.tree;
-exports.variant = require_advanced.variant;
+exports.table = table;
+exports.tree = tree;
+exports.variant = variant;
 
 //# sourceMappingURL=index.cjs.map