doxum 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_dependency = require("./dependency-Dfzs3khk.cjs");
-const require_ownership = require("./ownership-CU-9DKJQ.cjs");
+const require_runtime = require("./runtime-CRijXjYp.cjs");
+const require_ownership = require("./ownership-CY0nPXGF.cjs");
 const require_driver = require("./driver-CNxqMVFH.cjs");
 //#region core/src/impact.ts
 const emptyCollectionImpact = Object.freeze({
@@ -29,7 +29,7 @@ const createImpact = (input) => {
 		if (pathBuckets.get(void 0)?.some(test)) return true;
 		return pathBuckets.get(address[0])?.some(test) ?? false;
 	};
-	const pathsAffect = (address) => address.length === 0 ? paths.length > 0 : somePath(address, (changed) => require_dependency.overlaps(changed, address));
+	const pathsAffect = (address) => address.length === 0 ? paths.length > 0 : somePath(address, (changed) => require_runtime.overlaps(changed, address));
 	let collectionCache;
 	const findCollection = (address) => input.collections?.find((entry) => entry.address.length === address.length && entry.address.every((segment, index) => segment === address[index]));
 	return {
@@ -38,12 +38,12 @@ const createImpact = (input) => {
 		affects: (value) => {
 			require_ownership.profile.impact.affects();
 			if (kind === "reset") return true;
-			if (!require_dependency.belongs(value, input.schema)) return false;
-			if (pathsAffect(require_dependency.address(value))) return true;
+			if (!require_runtime.belongs(value, input.schema)) return false;
+			if (pathsAffect(require_runtime.address(value))) return true;
 			if (value.kind === "collection") {
-				const collection = findCollection(require_dependency.address(value));
+				const collection = findCollection(require_runtime.address(value));
 				if (!collection) return false;
-				const id$1 = require_dependency.id(value);
+				const id$1 = require_runtime.id(value);
 				if (id$1 !== void 0) return collection.added.has(id$1) || collection.removed.has(id$1) || collection.updated.has(id$1);
 				return collection.added.size > 0 || collection.removed.size > 0 || collection.updated.size > 0 || collection.orderChanged;
 			}
@@ -55,7 +55,7 @@ const createImpact = (input) => {
 			const cached = collectionCache?.find((entry) => entry.address.length === selector.address.length && entry.address.every((segment, index) => segment === selector.address[index]))?.value;
 			if (cached) return cached;
 			const exact = findCollection(selector.address);
-			if (somePath(selector.address, (changed) => require_dependency.contains(changed, selector.address) && changed.length < selector.address.length)) {
+			if (somePath(selector.address, (changed) => require_runtime.contains(changed, selector.address) && changed.length < selector.address.length)) {
 				const reset = { kind: "reset" };
 				(collectionCache ??= []).push({
 					address: selector.address,
@@ -165,7 +165,7 @@ const createHistory = (input) => {
 };
 //#endregion
 //#region core/src/access/writer.ts
-const schemaRoot = (schema) => require_dependency.object(schema.shape);
+const schemaRoot = (schema) => require_runtime.object(schema.shape);
 const emit = (sink, operation) => sink(operation);
 const writerFor = (node, inputAddress, sink) => {
 	const address = Object.freeze(inputAddress);
@@ -196,7 +196,11 @@ const writerFor = (node, inputAddress, sink) => {
 			type: "dict.replace",
 			at: address,
 			value
-		})
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
 	};
 	if (node.kind === "list") return {
 		insert: (value, anchor) => emit(sink, {
@@ -222,7 +226,11 @@ const writerFor = (node, inputAddress, sink) => {
 			at: address,
 			value,
 			keys: value.map(node.keyOf)
-		})
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
 	};
 	if (node.kind === "tree") return {
 		insert: (treeNodeId, value, parentId, index) => emit(sink, {
@@ -255,7 +263,11 @@ const writerFor = (node, inputAddress, sink) => {
 			type: "tree.replace",
 			at: address,
 			value
-		})
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
 	};
 	if (node.kind === "table") {
 		let items;
@@ -319,11 +331,17 @@ const writerFor = (node, inputAddress, sink) => {
 		};
 	}
 	if (node.kind === "single") return writerFor(node.value, address, sink);
-	if (node.kind === "variant") return { replace: (value) => emit(sink, {
-		type: "variant.replace",
-		at: address,
-		value
-	}) };
+	if (node.kind === "variant") return {
+		replace: (value) => emit(sink, {
+			type: "variant.replace",
+			at: address,
+			value
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
+	};
 	let children;
 	return new Proxy({}, { get: (_target, property) => {
 		if (typeof property !== "string" || !node.shape[property]) return void 0;
@@ -541,8 +559,11 @@ const rejected$3 = (operation, code, message) => ({
 	issue: from(operation, code, message)
 });
 const executeList = (target, operation, copyPayload) => {
-	if (!Array.isArray(target.value) || target.node.kind !== "list") return rejected$3(operation, "invalid-address", "List target is invalid.");
-	const list = target.value;
+	if (target.node.kind !== "list") return rejected$3(operation, "invalid-address", "List target is invalid.");
+	const absent = target.value === void 0 && "optional" in target.node && target.node.optional === true;
+	if (!Array.isArray(target.value) && !absent) return rejected$3(operation, "invalid-address", "List target is invalid.");
+	if (absent && operation.type !== "list.replace") return rejected$3(operation, "invalid-address", "Only list replacement can initialize an optional list.");
+	const list = Array.isArray(target.value) ? target.value : [];
 	const orderedKeys = keys(list, target.node.keyOf);
 	const own = (value) => copyPayload ? require_ownership.ownPayload(value) : value;
 	if (operation.type === "list.replace") {
@@ -553,18 +574,23 @@ const executeList = (target, operation, copyPayload) => {
 			if (seen.has(key) || target.node.keyOf(operation.value[index]) !== key) return rejected$3(operation, "invalid-list-keys", "List replacement keys are invalid.");
 			seen.add(key);
 		}
-		if (require_ownership.sameStructuralValue(list, operation.value)) return { status: "unchanged" };
-		const keys = new Array(list.length);
-		for (let index = 0; index < list.length; index += 1) keys[index] = target.node.keyOf(list[index]);
-		const inverse = {
+		if (!absent && require_ownership.sameStructuralValue(list, operation.value)) return { status: "unchanged" };
+		const keys = list.map(target.node.keyOf);
+		const inverse = absent ? {
+			type: "value.clear",
+			at: operation.at
+		} : {
 			type: "list.replace",
 			at: operation.at,
 			value: require_ownership.cloneValue(list, "inverse"),
 			keys
 		};
 		const owned = own(operation.value);
-		list.length = owned.length;
-		for (let index = 0; index < owned.length; index += 1) list[index] = owned[index];
+		if (absent) target.parent[target.key] = owned;
+		else {
+			list.length = owned.length;
+			for (let index = 0; index < owned.length; index += 1) list[index] = owned[index];
+		}
 		return {
 			status: "changed",
 			inverse: [inverse]
@@ -1024,16 +1050,39 @@ const outcome = (operation, value) => value.status === "rejected" ? {
 	issue: from(operation, value.code, value.message)
 } : value;
 const executeTree = (root, target, operation, copyPayload) => {
-	if (!is(target.value)) return {
+	if (target.node.kind !== "tree") return {
 		status: "rejected",
 		issue: from(operation, "invalid-address", "Tree target is invalid.")
 	};
 	const own = (value) => copyPayload ? require_ownership.ownPayload(value) : value;
+	const absent = target.value === void 0 && "optional" in target.node && target.node.optional === true;
 	if (operation.type === "tree.replace") {
+		if (absent) {
+			if (!validate(operation.value)) return {
+				status: "rejected",
+				issue: from(operation, "invalid-tree", "Tree replacement is malformed.")
+			};
+			target.parent[target.key] = own(operation.value);
+			return {
+				status: "changed",
+				inverse: [{
+					type: "value.clear",
+					at: operation.at
+				}]
+			};
+		}
+		if (!is(target.value)) return {
+			status: "rejected",
+			issue: from(operation, "invalid-address", "Tree target is invalid.")
+		};
 		const result = replace(target.value, operation);
-		if (result.status === "changed") require_dependency.set(root, operation.at, require_ownership.ownPayload(operation.value));
+		if (result.status === "changed") require_runtime.set(root, operation.at, require_ownership.ownPayload(operation.value));
 		return outcome(operation, result);
 	}
+	if (!is(target.value)) return {
+		status: "rejected",
+		issue: from(operation, "invalid-address", "Tree target is invalid.")
+	};
 	if (operation.type === "tree.insert") return outcome(operation, insert(target.value, operation, own(operation.value)));
 	if (operation.type === "tree.set") return outcome(operation, set(target.value, operation, own(operation.value)));
 	if (operation.type === "tree.remove") return outcome(operation, remove(target.value, operation));
@@ -1091,6 +1140,18 @@ const executeValue = (target, operation, copyPayload) => {
 			inverse: [inverse]
 		};
 	}
+	if (operation.type === "dict.replace" && target.value === void 0) {
+		if (!("optional" in target.node) || !target.node.optional) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
+		const inverse = {
+			type: "value.clear",
+			at: operation.at
+		};
+		target.parent[target.key] = own(operation.value);
+		return {
+			status: "changed",
+			inverse: [inverse]
+		};
+	}
 	if (!require_ownership.isRecord(target.value)) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
 	if (operation.type === "dict.replace") {
 		if (require_ownership.sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
@@ -1139,11 +1200,67 @@ const executeValue = (target, operation, copyPayload) => {
 };
 //#endregion
 //#region core/src/mutation/execute.ts
+const hasOwn$1 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const executeClear = (target, operation) => {
+	if (!("optional" in target.node) || !target.node.optional) return {
+		status: "rejected",
+		issue: from(operation, "required-field", "Only optional values can be cleared.")
+	};
+	if (!hasOwn$1(target.parent, target.key)) return { status: "unchanged" };
+	if (target.node.kind !== "field" && target.node.kind !== "variant" && target.node.kind !== "dict" && target.node.kind !== "record" && target.node.kind !== "list" && target.node.kind !== "tree") return {
+		status: "rejected",
+		issue: from(operation, "invalid-operation", "This optional value has no clear operation.")
+	};
+	const inverse = (() => {
+		switch (target.node.kind) {
+			case "field": return {
+				type: "field.set",
+				at: operation.at,
+				value: target.value
+			};
+			case "variant": return {
+				type: "variant.replace",
+				at: operation.at,
+				value: require_ownership.cloneValue(target.value, "inverse")
+			};
+			case "dict":
+			case "record": return {
+				type: "dict.replace",
+				at: operation.at,
+				value: require_ownership.cloneValue(target.value, "inverse")
+			};
+			case "list":
+				if (!Array.isArray(target.value)) return {
+					type: "list.replace",
+					at: operation.at,
+					value: [],
+					keys: []
+				};
+				return {
+					type: "list.replace",
+					at: operation.at,
+					value: require_ownership.cloneValue(target.value, "inverse"),
+					keys: target.value.map(target.node.keyOf)
+				};
+			case "tree": return {
+				type: "tree.replace",
+				at: operation.at,
+				value: require_ownership.cloneValue(target.value, "inverse")
+			};
+		}
+	})();
+	delete target.parent[target.key];
+	return {
+		status: "changed",
+		inverse: [inverse]
+	};
+};
 const invalidTarget = (operation) => ({
 	status: "rejected",
 	issue: from(operation, "invalid-address", `Operation '${operation.type}' does not match the schema address.`)
 });
 const execute = (root, operation, target, copyPayload) => {
+	if (operation.type === "value.clear") return !target ? invalidTarget(operation) : executeClear(target, operation);
 	if (operation.type === "field.set" || operation.type === "field.clear") return !target || target.node.kind !== "field" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
 	if (operation.type === "variant.replace") return !target || target.node.kind !== "variant" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
 	if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") return !target || target.node.kind !== "dict" && target.node.kind !== "record" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
@@ -1209,14 +1326,14 @@ const indexedSubjects = (root, address) => {
 	return subjects;
 };
 const writePresence = (root, address, before) => {
-	const target = require_dependency.locate(root, address);
+	const target = require_runtime.locate(root, address);
 	if (!target) return;
 	if (before.status === "present") target.parent[target.key] = before.value;
 	else if (Array.isArray(target.parent)) target.parent.splice(Number(target.key), 1);
 	else delete target.parent[String(target.key)];
 };
 const writeContainer = (root, address, value) => {
-	const target = require_dependency.locate(root, address);
+	const target = require_runtime.locate(root, address);
 	if (!target) return;
 	target.parent[target.key] = value;
 };
@@ -1284,7 +1401,7 @@ const restoreSubject = (value, prefix, subject) => {
 		writeContainer(value, address, subject.before);
 		return value;
 	}
-	const current = require_dependency.read(value, address);
+	const current = require_runtime.read(value, address);
 	if (subject.kind === "dict") {
 		if (require_ownership.isRecord(current)) restoreDict(current, subject.state);
 		return value;
@@ -1302,13 +1419,13 @@ const restoreSubject = (value, prefix, subject) => {
 	return value;
 };
 const valueChanged = (root, subject) => {
-	const target = require_dependency.locate(root, subject.address);
+	const target = require_runtime.locate(root, subject.address);
 	const exists = !!target && hasOwn(target.parent, target.key);
 	if (subject.before.status === "absent") return exists;
 	return !exists || !Object.is(subject.before.value, target?.value);
 };
 const dictChanged = (root, subject) => {
-	const value = require_dependency.read(root, subject.address);
+	const value = require_runtime.read(root, subject.address);
 	if (!require_ownership.isRecord(value)) return true;
 	if (subject.state.mode === "whole") return !require_ownership.sameStructuralValue(subject.state.value, value);
 	for (const [key, before] of subject.state.entries) {
@@ -1318,7 +1435,7 @@ const dictChanged = (root, subject) => {
 	return false;
 };
 const listChanged = (root, subject) => {
-	const value = require_dependency.read(root, subject.address);
+	const value = require_runtime.read(root, subject.address);
 	if (!Array.isArray(value)) return true;
 	if (subject.state.mode === "whole") return !require_ownership.sameStructuralValue(subject.state.value, value);
 	const positions = /* @__PURE__ */ new Map();
@@ -1350,7 +1467,7 @@ const commonOrderChanged = (before, after) => {
 	return false;
 };
 const analyzeEntity = (root, subject) => {
-	const resolution = entityCollection(subject, require_dependency.read(root, subject.address));
+	const resolution = entityCollection(subject, require_runtime.read(root, subject.address));
 	const added = /* @__PURE__ */ new Set();
 	const removed = /* @__PURE__ */ new Set();
 	const updated = /* @__PURE__ */ new Set();
@@ -1382,10 +1499,10 @@ const analyzeEntity = (root, subject) => {
 };
 const subjectChanged = (root, subject) => {
 	if (subject.kind === "value") return valueChanged(root, subject);
-	if (subject.kind === "variant") return !require_ownership.sameStructuralValue(subject.before, require_dependency.read(root, subject.address));
+	if (subject.kind === "variant") return !require_ownership.sameStructuralValue(subject.before, require_runtime.read(root, subject.address));
 	if (subject.kind === "dict") return dictChanged(root, subject);
 	if (subject.kind === "list") return listChanged(root, subject);
-	return changeChanged(subject.state, require_dependency.read(root, subject.address));
+	return changeChanged(subject.state, require_runtime.read(root, subject.address));
 };
 const listOrderBefore = (value, node, inverse) => {
 	const order = value.map(node.keyOf);
@@ -1533,11 +1650,12 @@ const createChangeJournal = (root) => {
 	const recordValue = (resolved, operation, inverse) => {
 		if (find("value", operation.at, resolved.addressHash)) return;
 		const first = inverse[0];
-		if (first?.type !== "field.set" && first?.type !== "field.clear") return inverseMismatch(operation);
+		if (first?.type !== "field.set" && first?.type !== "field.clear" && first?.type !== "value.clear" && !("value" in (first ?? {}))) return inverseMismatch(operation);
+		const before = first.type === "field.clear" || first.type === "value.clear" ? absent : "value" in first ? present(first.value) : inverseMismatch(operation);
 		add({
 			...base(resolved, operation),
 			kind: "value",
-			before: first.type === "field.set" ? present(first.value) : absent
+			before
 		});
 	};
 	const recordVariant = (resolved, operation, inverse) => {
@@ -1580,6 +1698,18 @@ const createChangeJournal = (root) => {
 		if (!first) return inverseMismatch(operation);
 		let subject = find("list", operation.at, resolved.addressHash);
 		if (!subject) {
+			if (first.type === "value.clear") {
+				add({
+					...base(resolved, operation),
+					kind: "list",
+					node: resolved.node,
+					state: {
+						mode: "whole",
+						value: void 0
+					}
+				});
+				return;
+			}
 			if (first.type === "list.replace") {
 				add({
 					...base(resolved, operation),
@@ -1592,7 +1722,7 @@ const createChangeJournal = (root) => {
 				});
 				return;
 			}
-			const value = require_dependency.read(root, operation.at);
+			const value = require_runtime.read(root, operation.at);
 			if (!Array.isArray(value)) return inverseMismatch(operation);
 			subject = add({
 				...base(resolved, operation),
@@ -1630,7 +1760,7 @@ const createChangeJournal = (root) => {
 	};
 	const recordEntity = (resolved, operation, inverse) => {
 		if (resolved.node.kind !== "table" && resolved.node.kind !== "map") return inverseMismatch(operation);
-		const resolution = resolveEntityCollection(resolved.node, require_dependency.read(root, operation.at));
+		const resolution = resolveEntityCollection(resolved.node, require_runtime.read(root, operation.at));
 		if (resolution.status === "invalid") return inverseMismatch(operation);
 		const collection = resolution.collection;
 		const subject = find("entity", operation.at, resolved.addressHash) ?? add({
@@ -1666,7 +1796,23 @@ const createChangeJournal = (root) => {
 		return inverseMismatch(operation);
 	};
 	const recordTree = (resolved, operation, inverse) => {
-		const current = require_dependency.read(root, operation.at);
+		const current = require_runtime.read(root, operation.at);
+		if (inverse.length === 1 && inverse[0].type === "value.clear" && operation.type === "tree.replace") {
+			const subject = find("tree", operation.at, resolved.addressHash);
+			if (subject) subject.state = {
+				mode: "whole",
+				value: void 0
+			};
+			else add({
+				...base(resolved, operation),
+				kind: "tree",
+				state: {
+					mode: "whole",
+					value: void 0
+				}
+			});
+			return;
+		}
 		if (!is(current)) return inverseMismatch(operation);
 		const inverses = inverse.filter(treeOperation);
 		if (inverses.length === 0 || inverses.length !== inverse.length) return inverseMismatch(operation);
@@ -1683,7 +1829,7 @@ const createChangeJournal = (root) => {
 		record: (resolved, operation, inverse) => {
 			require_ownership.profile.batch.journalRecord();
 			if (ownerOf(operation.at)) return;
-			if (operation.type === "field.set" || operation.type === "field.clear") {
+			if (operation.type === "field.set" || operation.type === "field.clear" || operation.type === "value.clear") {
 				recordValue(resolved, operation, inverse);
 				return;
 			}
@@ -1692,7 +1838,8 @@ const createChangeJournal = (root) => {
 				return;
 			}
 			if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") {
-				recordDict(resolved, operation, inverse);
+				if (operation.type === "dict.replace" && inverse[0]?.type === "value.clear") recordValue(resolved, operation, inverse);
+				else recordDict(resolved, operation, inverse);
 				return;
 			}
 			if (operation.type === "entity.create" || operation.type === "entity.remove" || operation.type === "entity.move") {
@@ -1793,7 +1940,8 @@ const decode = (input) => {
 	switch (input.type) {
 		case "field.set":
 		case "variant.replace": return has(input, "value") ? decoded(input) : rejected("invalid-operation", "Operation value is required.");
-		case "field.clear": return decoded(input);
+		case "field.clear":
+		case "value.clear": return decoded(input);
 		case "dict.set": return typeof input.key === "string" && has(input, "value") ? decoded(input) : rejected("invalid-operation", "Dictionary set requires a string key and value.");
 		case "dict.delete": return typeof input.key === "string" ? decoded(input) : rejected("invalid-operation", "Dictionary delete requires a string key.");
 		case "dict.replace": return require_ownership.isRecord(input.value) ? decoded(input) : rejected("invalid-operation", "Dictionary replacement must be an object.");
@@ -1878,7 +2026,7 @@ const createMutationSession = (root, schema, options = {}) => {
 	const rollback = () => {
 		if (state === "rolled-back") return;
 		for (let stepIndex = steps.length - 1; stepIndex >= 0; stepIndex -= 1) for (const inverse of steps[stepIndex].inverse) {
-			const result = execute(root, inverse, require_dependency.resolveLocated(schema, root, inverse.at), true);
+			const result = execute(root, inverse, require_runtime.resolveLocated(schema, root, inverse.at), true);
 			if (result.status === "rejected") throw new Error(`Document rollback failed: ${result.issue.message}`);
 		}
 		state = "rolled-back";
@@ -1894,7 +2042,7 @@ const createMutationSession = (root, schema, options = {}) => {
 			}
 			const normalized = normalize(decoded.operation);
 			require_ownership.profile.batch.entry(normalized.type === "entity.create" ? normalized.entries.length : normalized.type === "entity.remove" ? normalized.ids.length : 1);
-			const resolved = require_dependency.resolveLocated(schema, root, normalized.at);
+			const resolved = require_runtime.resolveLocated(schema, root, normalized.at);
 			if (resolved?.collection) require_ownership.profile.batch.collectionResolved();
 			require_ownership.profile.mutation.executed();
 			const result = execute(root, normalized, resolved, options.copyPayload === true || requiresPayloadCopy(normalized));
@@ -1986,6 +2134,7 @@ const commandFootprint = (operations) => {
 	for (const operation of operations) switch (operation.type) {
 		case "field.set":
 		case "field.clear":
+		case "value.clear":
 		case "variant.replace":
 			add(targets, {
 				kind: "value",
@@ -2148,166 +2297,6 @@ const decodeCommandFootprint = (value) => {
 	return Object.freeze(Array.from(targets.values()));
 };
 //#endregion
-//#region core/src/runtime/notification.ts
-const ROOT_BUCKET = Symbol("document-root");
-const notifications = /* @__PURE__ */ new WeakMap();
-const key = (value) => require_dependency.bucket(value) ?? ROOT_BUCKET;
-const createNotification = (runtime) => {
-	const notification = {
-		root: /* @__PURE__ */ new Set(),
-		filtered: /* @__PURE__ */ new Set(),
-		buckets: /* @__PURE__ */ new Map(),
-		processors: [],
-		candidates: /* @__PURE__ */ new Set(),
-		rootSnapshot: [],
-		notifying: false
-	};
-	notifications.set(runtime, notification);
-	return notification;
-};
-const notificationOf = (runtime) => {
-	const value = notifications.get(runtime);
-	if (!value) throw new Error("Unknown Doxum runtime.");
-	return value;
-};
-const shareNotification = (source, target) => {
-	notifications.set(target, notificationOf(source));
-};
-const registerProcessor = (runtime, processor) => {
-	const notification = notificationOf(runtime);
-	const entry = {
-		processor,
-		active: true
-	};
-	notification.processors.push(entry);
-	return () => {
-		if (!entry.active) return;
-		entry.active = false;
-		if (!notification.notifying) {
-			const index = notification.processors.indexOf(entry);
-			if (index >= 0) notification.processors.splice(index, 1);
-		}
-	};
-};
-const subscribeRoot = (notification, listener) => {
-	const entry = {
-		listener,
-		active: true
-	};
-	notification.root.add(entry);
-	return () => {
-		entry.active = false;
-		if (!notification.notifying) notification.root.delete(entry);
-	};
-};
-const subscribeTargets = (notification, targets, listener) => {
-	const entry = {
-		targets: Object.freeze(targets.slice()),
-		listener,
-		active: true
-	};
-	notification.filtered.add(entry);
-	const keys = new Set(targets.map(key));
-	keys.forEach((key) => {
-		const bucket = notification.buckets.get(key) ?? /* @__PURE__ */ new Set();
-		bucket.add(entry);
-		notification.buckets.set(key, bucket);
-	});
-	return () => {
-		if (!entry.active) return;
-		entry.active = false;
-		if (notification.notifying) return;
-		notification.filtered.delete(entry);
-		keys.forEach((key) => {
-			const bucket = notification.buckets.get(key);
-			bucket?.delete(entry);
-			if (bucket?.size === 0) notification.buckets.delete(key);
-		});
-	};
-};
-const notify = (notification, commit) => {
-	notification.notifying = true;
-	const errors = [];
-	const call = (listener) => {
-		try {
-			listener(commit);
-		} catch (error) {
-			errors.push(Object.freeze({
-				phase: "listener",
-				error
-			}));
-		}
-	};
-	try {
-		const processorCount = notification.processors.length;
-		for (let index = 0; index < processorCount; index += 1) {
-			const entry = notification.processors[index];
-			if (!entry?.active) continue;
-			try {
-				entry.processor.process(commit);
-			} catch (error) {
-				errors.push(Object.freeze({
-					phase: "processor",
-					error
-				}));
-			}
-		}
-		for (let index = 0; index < processorCount; index += 1) {
-			const entry = notification.processors[index];
-			if (!entry?.active) continue;
-			try {
-				entry.processor.flush();
-			} catch (error) {
-				errors.push(Object.freeze({
-					phase: "flush",
-					error
-				}));
-			}
-		}
-		const candidates = notification.candidates;
-		candidates.clear();
-		if (commit.impact.kind === "reset") notification.filtered.forEach((entry) => candidates.add(entry));
-		else for (const operation of commit.operations) {
-			const key = operation.at[0] ?? ROOT_BUCKET;
-			notification.buckets.get(key)?.forEach((entry) => candidates.add(entry));
-			notification.buckets.get(ROOT_BUCKET)?.forEach((entry) => candidates.add(entry));
-		}
-		candidates.forEach((entry) => {
-			if (entry.active && entry.targets.some(commit.impact.affects)) call(entry.listener);
-		});
-		const rootSnapshot = notification.rootSnapshot;
-		rootSnapshot.length = 0;
-		notification.root.forEach((entry) => rootSnapshot.push(entry));
-		for (const entry of rootSnapshot) if (entry.active) call(entry.listener);
-	} finally {
-		notification.notifying = false;
-		let writeIndex = 0;
-		for (const entry of notification.processors) if (entry.active) notification.processors[writeIndex++] = entry;
-		notification.processors.length = writeIndex;
-		notification.root.forEach((entry) => {
-			if (!entry.active) notification.root.delete(entry);
-		});
-		notification.filtered.forEach((entry) => {
-			if (!entry.active) notification.filtered.delete(entry);
-		});
-		notification.buckets.forEach((bucket, key) => {
-			bucket.forEach((entry) => {
-				if (!entry.active) bucket.delete(entry);
-			});
-			if (bucket.size === 0) notification.buckets.delete(key);
-		});
-	}
-	return Object.freeze(errors);
-};
-const disposeNotification = (notification) => {
-	notification.root.clear();
-	notification.filtered.clear();
-	notification.buckets.clear();
-	notification.processors.length = 0;
-	notification.candidates.clear();
-	notification.rootSnapshot.length = 0;
-};
-//#endregion
 //#region core/src/runtime.ts
 var RejectedUpdate = class extends Error {
 	issues;
@@ -2335,15 +2324,16 @@ const createDocument = (input) => {
 	let runtime;
 	let notification;
 	const assertWritable = (intent) => {
-		if (state.disposed) throw new require_dependency.DocumentDisposedError();
-		if (busy) throw new require_dependency.DocumentReentrancyError();
+		if (state.disposed) throw new require_runtime.DocumentDisposedError();
+		if (busy) throw new require_runtime.DocumentReentrancyError();
+		if (require_runtime.accessOf(runtime).projectionLocks) throw new require_runtime.DocumentReentrancyError();
 		require_driver.assertRuntimeWritable(runtime, intent);
 	};
 	const runTransaction = (session, run) => {
 		let reports;
 		let active = true;
 		const transaction = {
-			read: require_dependency.documentReader(input.schema, () => state.document, () => active),
+			read: require_runtime.documentReader(input.schema, () => state.document, () => active),
 			write: documentWriter(input.schema, (operation) => {
 				if (!active) throw new Error("Document writer is no longer active.");
 				const rejected = session.apply(operation);
@@ -2395,7 +2385,7 @@ const createDocument = (input) => {
 		busy = true;
 		let observerErrors;
 		try {
-			observerErrors = notify(notification, commit);
+			observerErrors = require_runtime.notify(notification, commit);
 		} finally {
 			busy = false;
 		}
@@ -2425,11 +2415,11 @@ const createDocument = (input) => {
 	runtime = {
 		schema: input.schema,
 		address: {
-			resolve: (address) => require_dependency.resolveAddress(input.schema, address, state.document),
-			read: (address) => require_dependency.read(state.document, address),
-			contains: require_dependency.contains,
-			overlaps: require_dependency.overlaps,
-			debugKey: require_dependency.debugKey
+			resolve: (address) => require_runtime.resolveAddress(input.schema, address, state.document),
+			read: (address) => require_runtime.read(state.document, address),
+			contains: require_runtime.contains,
+			overlaps: require_runtime.overlaps,
+			debugKey: require_runtime.debugKey
 		},
 		revision: () => revision,
 		update: (run, options) => {
@@ -2555,28 +2545,32 @@ const createDocument = (input) => {
 			}, source, "replace", false);
 		},
 		snapshot: () => {
-			if (state.disposed) throw new require_dependency.DocumentDisposedError();
+			if (state.disposed) throw new require_runtime.DocumentDisposedError();
 			return require_ownership.cloneValue(state.document, "snapshot");
 		},
 		subscribe: ((targetOrListener, listener) => {
-			if (state.disposed) throw new require_dependency.DocumentDisposedError();
-			if (typeof targetOrListener === "function") return subscribeRoot(notification, targetOrListener);
+			if (state.disposed) throw new require_runtime.DocumentDisposedError();
+			if (typeof targetOrListener === "function") return require_runtime.subscribeRoot(notification, targetOrListener);
 			const targets = Array.isArray(targetOrListener) ? targetOrListener : [targetOrListener];
 			if (targets.length === 0 || !listener) throw new TypeError("Filtered subscribe requires at least one target and a listener.");
-			return subscribeTargets(notification, targets, listener);
+			return require_runtime.subscribeTargets(notification, targets, listener);
 		}),
 		history: history.api,
 		dispose: () => {
 			if (state.disposed) return;
+			if (busy || require_runtime.accessOf(runtime).projectionLocks) throw new require_runtime.DocumentReentrancyError();
 			state.disposed = true;
-			disposeNotification(notification);
-			history.api.clear();
-			require_driver.disposeRuntimeDriver(runtime);
+			try {
+				require_runtime.disposeNotification(notification);
+			} finally {
+				history.api.clear();
+				require_driver.disposeRuntimeDriver(runtime);
+			}
 		}
 	};
-	require_dependency.bindRuntimeAccess(runtime, state);
+	require_runtime.bindRuntimeAccess(runtime, state);
 	require_driver.bindRuntimeDriver(runtime);
-	notification = createNotification(runtime);
+	notification = require_runtime.createNotification(runtime);
 	return runtime;
 };
 //#endregion
@@ -2587,427 +2581,47 @@ const asReadable = (runtime) => {
 		revision: runtime.revision,
 		subscribe: runtime.subscribe
 	};
-	require_dependency.bindRuntimeAccess(readable, require_dependency.accessOf(runtime));
-	shareNotification(runtime, readable);
+	require_runtime.bindRuntimeAccess(readable, require_runtime.accessOf(runtime));
+	require_runtime.shareNotification(runtime, readable);
 	return Object.freeze(readable);
 };
 //#endregion
 //#region core/src/projection/select.ts
-const select = (runtime, selector) => require_dependency.readWith(runtime, selector);
-//#endregion
-//#region core/src/projection/collection-view.ts
-const createCollectionView = (input) => {
-	if (require_dependency.schemaOf(input.runtime) !== input.source.schema) throw new Error("Collection selector belongs to another schema.");
-	const idsListeners = /* @__PURE__ */ new Set();
-	const allListeners = /* @__PURE__ */ new Set();
-	const itemListeners = /* @__PURE__ */ new Map();
-	const itemReadables = /* @__PURE__ */ new Map();
-	let disposed = false;
-	const sourceNode = require_dependency.nodeAt(input.source.schema, input.source.address);
-	const entryNode = sourceNode?.kind === "table" || sourceNode?.kind === "map" ? sourceNode.value : {
-		kind: "object",
-		shape: {}
-	};
-	const mapEntry = (document, id) => {
-		require_ownership.profile.collectionView.mapped();
-		const address = [...input.source.address, String(id)];
-		let active = true;
-		try {
-			return input.map(id, require_dependency.readerFor(entryNode, {
-				root: () => document,
-				active: () => active
-			}, address));
-		} finally {
-			active = false;
-		}
-	};
-	const build = (previous, changed) => {
-		const document = require_dependency.documentOf(input.runtime);
-		const collection = require_dependency.read(document, input.source.address);
-		const ids = collection && typeof collection === "object" && "ids" in collection && Array.isArray(collection.ids) ? [...collection.ids] : Object.keys(collection ?? {});
-		require_ownership.profile.collectionView.idsScanned(ids.length);
-		const values = previous && changed ? previous.values : /* @__PURE__ */ new Map();
-		if (previous && changed) {
-			const nextIds = new Set(ids);
-			for (const id of previous.ids) if (!nextIds.has(id)) values.delete(id);
-		}
-		for (const id of ids) {
-			if (previous && changed && previous.values.has(id) && !changed.has(id)) continue;
-			const next = mapEntry(document, id);
-			if (previous && changed && previous.values.has(id)) {
-				const before = previous.values.get(id);
-				if (input.isEqual ? input.isEqual(before, next) : Object.is(before, next)) {
-					changed.delete(id);
-					continue;
-				}
-			}
-			values.set(id, next);
-		}
-		return {
-			ids: Object.freeze(ids),
-			values,
-			all: void 0,
-			allDirty: true
-		};
-	};
-	let state = build();
-	const ensureAll = () => {
-		if (!state.allDirty && state.all) return state.all;
-		require_ownership.profile.collectionView.arrayCopied();
-		const all = new Array(state.ids.length);
-		for (let index = 0; index < state.ids.length; index += 1) all[index] = state.values.get(state.ids[index]);
-		const stable = Object.freeze(all);
-		state.all = stable;
-		state.allDirty = false;
-		return stable;
-	};
-	const emit = (listeners) => {
-		Array.from(listeners).forEach((listener) => listener());
-	};
-	const unsubscribe = input.runtime.subscribe(input.source, (commit) => {
-		if (disposed) return;
-		const impact = commit.impact.collection(input.source);
-		if (impact.kind === "incremental" && impact.added.size === 0 && impact.removed.size === 0 && !impact.orderChanged) {
-			const previous = state;
-			const changes = [];
-			const document = require_dependency.documentOf(input.runtime);
-			impact.updated.forEach((id) => {
-				if (!previous.values.has(id)) return;
-				const before = previous.values.get(id);
-				const after = mapEntry(document, id);
-				if (input.isEqual ? input.isEqual(before, after) : Object.is(before, after)) return;
-				changes.push([id, after]);
-			});
-			if (changes.length === 0) return;
-			for (const [id, value] of changes) previous.values.set(id, value);
-			previous.all = void 0;
-			previous.allDirty = true;
-			emit(allListeners);
-			for (const [id] of changes) {
-				const listeners = itemListeners.get(id);
-				if (listeners) emit(listeners);
-			}
-			return;
-		}
-		const changed = impact.kind === "reset" ? void 0 : new Set([...impact.added, ...impact.updated]);
-		const previous = state;
-		const next = build(previous, changed);
-		const changedIds = /* @__PURE__ */ new Set();
-		if (changed) {
-			changed.forEach((id) => changedIds.add(id));
-			previous.ids.forEach((id) => {
-				if (!next.values.has(id)) changedIds.add(id);
-			});
-			next.ids.forEach((id) => {
-				if (!previous.values.has(id)) changedIds.add(id);
-			});
-		} else {
-			previous.ids.forEach((id) => {
-				if (!next.values.has(id)) changedIds.add(id);
-				else if (!(input.isEqual ? input.isEqual(previous.values.get(id), next.values.get(id)) : Object.is(previous.values.get(id), next.values.get(id)))) changedIds.add(id);
-			});
-			next.ids.forEach((id) => {
-				if (!previous.values.has(id)) changedIds.add(id);
-			});
-		}
-		const idsChanged = impact.kind === "incremental" ? impact.added.size > 0 || impact.removed.size > 0 || impact.orderChanged : previous.ids.length !== next.ids.length || previous.ids.some((id, index) => next.ids[index] !== id);
-		state = idsChanged || changedIds.size ? next : previous;
-		if (idsChanged) emit(idsListeners);
-		if (idsChanged || changedIds.size) emit(allListeners);
-		changedIds.forEach((id) => {
-			const listeners = itemListeners.get(id);
-			if (listeners) emit(listeners);
-		});
-	});
-	return {
-		ids: {
-			current: () => state.ids,
-			revision: () => input.runtime.revision(),
-			subscribe: (listener) => {
-				if (disposed) return () => void 0;
-				idsListeners.add(listener);
-				return () => idsListeners.delete(listener);
-			}
-		},
-		all: {
-			current: ensureAll,
-			revision: () => input.runtime.revision(),
-			subscribe: (listener) => {
-				if (disposed) return () => void 0;
-				allListeners.add(listener);
-				return () => allListeners.delete(listener);
-			}
-		},
-		item: (id) => {
-			const cached = itemReadables.get(id);
-			if (cached) return cached;
-			const readable = {
-				current: () => state.values.get(id),
-				revision: () => input.runtime.revision(),
-				subscribe: (listener) => {
-					if (disposed) return () => void 0;
-					const listeners = itemListeners.get(id) ?? /* @__PURE__ */ new Set();
-					itemListeners.set(id, listeners);
-					listeners.add(listener);
-					return () => {
-						listeners.delete(listener);
-						if (listeners.size === 0) itemListeners.delete(id);
-					};
-				}
-			};
-			itemReadables.set(id, readable);
-			return readable;
-		},
-		revision: () => input.runtime.revision(),
-		dispose: () => {
-			if (disposed) return;
-			disposed = true;
-			unsubscribe();
-			idsListeners.clear();
-			allListeners.clear();
-			itemListeners.clear();
-			itemReadables.clear();
-			state.values.clear();
-			state = {
-				ids: Object.freeze([]),
-				values: /* @__PURE__ */ new Map(),
-				all: Object.freeze([]),
-				allDirty: false
-			};
-		}
-	};
-};
-//#endregion
-//#region core/src/projection/materialized-view.ts
-const materializedMeta = /* @__PURE__ */ new WeakMap();
-const createMaterializedView = (runtime, spec) => {
-	const listeners = /* @__PURE__ */ new Set();
-	let disposed = false;
-	let fault;
-	let revision = runtime.revision();
-	let instance;
-	let currentValue;
-	let pendingEmit = false;
-	const dependencies = require_dependency.createDependencyTracker();
-	const sources = spec.sources ?? {};
-	const sourceEntries = Object.keys(sources).map((key) => [key, sources[key]]);
-	sourceEntries.forEach(([, source]) => {
-		const meta = materializedMeta.get(source);
-		if (!meta || meta.runtime !== runtime) throw new Error("Materialized sources must belong to the same runtime and be created first.");
-	});
-	const sourceValuesRecord = {};
-	let sourceChanged = false;
-	for (const [key] of sourceEntries) sourceValuesRecord[key] = {
-		value: void 0,
-		change: void 0
-	};
-	const sourceValues = (commitRevision) => {
-		sourceChanged = false;
-		for (const [key, source] of sourceEntries) {
-			const meta = materializedMeta.get(source);
-			const entry = sourceValuesRecord[key];
-			entry.value = meta?.value ?? source.current();
-			entry.change = meta?.change;
-			if (commitRevision !== void 0 && meta?.changedRevision === commitRevision) {
-				sourceChanged = true;
-				require_ownership.profile.materialized.sourceChanged();
-			}
-		}
-		return sourceValuesRecord;
-	};
-	let activeImpact;
-	const assertImpact = () => {
-		if (!activeImpact) throw new Error("Materialized impact is no longer active.");
-		return activeImpact;
-	};
-	const trackedImpact = {
-		get kind() {
-			return assertImpact().kind;
-		},
-		affects: (target) => {
-			dependencies.record(target);
-			return assertImpact().affects(target);
-		},
-		collection: (selector) => {
-			dependencies.record(selector);
-			return assertImpact().collection(selector);
-		},
-		get operations() {
-			dependencies.record({
-				kind: "value",
-				at: []
-			});
-			return assertImpact().operations;
-		}
-	};
-	let view;
-	const writeMeta = (change, value, nextRevision, changed) => {
-		const meta = materializedMeta.get(view);
-		if (meta) {
-			meta.value = value;
-			meta.change = change;
-			meta.revision = nextRevision;
-			if (changed) meta.changedRevision = nextRevision;
-		} else materializedMeta.set(view, {
-			runtime,
-			value,
-			change,
-			revision: nextRevision,
-			changedRevision: changed ? nextRevision : -1
-		});
-	};
-	const build = () => {
-		require_ownership.profile.materialized.rebuilt();
-		dependencies.clear();
-		let active = true;
-		try {
-			instance = spec.build({
-				read: require_dependency.documentReader(require_dependency.schemaOf(runtime), () => require_dependency.documentOf(runtime), () => active),
-				sources: sourceValues()
-			});
-			currentValue = instance.value;
-			fault = void 0;
-			revision = runtime.revision();
-		} finally {
-			active = false;
-		}
-	};
-	build();
-	const emit = () => {
-		require_ownership.profile.materialized.notification();
-		Array.from(listeners).forEach((listener) => listener());
-	};
-	const process = (commit) => {
-		if (disposed) return;
-		try {
-			if (commit.kind === "replace" || fault) {
-				build();
-				writeMeta(void 0, currentValue, commit.revision, true);
-				pendingEmit = true;
-				return;
-			}
-			const sourceSnapshot = sourceValues(commit.revision);
-			if (!sourceChanged && dependencies.size() > 0 && !dependencies.some(commit.impact.affects)) {
-				require_ownership.profile.materialized.skipped();
-				revision = commit.revision;
-				writeMeta(void 0, currentValue, commit.revision, false);
-				return;
-			}
-			dependencies.clear();
-			require_ownership.profile.materialized.updated();
-			let active = true;
-			let result;
-			try {
-				activeImpact = commit.impact;
-				result = instance.update({
-					read: require_dependency.documentReader(require_dependency.schemaOf(runtime), () => require_dependency.documentOf(runtime), () => active),
-					revision: commit.revision,
-					source: commit.source,
-					impact: trackedImpact,
-					sources: sourceSnapshot
-				});
-			} finally {
-				activeImpact = void 0;
-				active = false;
-			}
-			if (result.kind === "rebuild") {
-				build();
-				writeMeta(void 0, currentValue, commit.revision, true);
-				pendingEmit = true;
-			} else if (result.kind === "changed") {
-				currentValue = result.value;
-				revision = commit.revision;
-				writeMeta(result.change, currentValue, commit.revision, true);
-				pendingEmit = true;
-			} else {
-				revision = commit.revision;
-				writeMeta(void 0, currentValue, commit.revision, false);
-			}
-		} catch (error) {
-			try {
-				build();
-				writeMeta(void 0, currentValue, commit.revision, true);
-				pendingEmit = true;
-			} catch (rebuildError) {
-				fault = rebuildError;
-				throw rebuildError;
-			}
-			throw error;
-		}
-	};
-	view = {
-		current: () => {
-			if (fault) throw fault;
-			return currentValue;
-		},
-		revision: () => revision,
-		subscribe: (listener) => {
-			listeners.add(listener);
-			return () => listeners.delete(listener);
-		},
-		rebuild: () => {
-			build();
-			writeMeta(void 0, currentValue, runtime.revision(), true);
-			emit();
-		},
-		dispose: () => {
-			if (disposed) return;
-			disposed = true;
-			unregister();
-			listeners.clear();
-			materializedMeta.delete(view);
-		}
-	};
-	materializedMeta.set(view, {
-		runtime,
-		value: currentValue,
-		change: void 0,
-		revision,
-		changedRevision: -1
-	});
-	const unregister = registerProcessor(runtime, {
-		process,
-		flush: () => {
-			if (!pendingEmit) return;
-			pendingEmit = false;
-			emit();
-		}
-	});
-	return view;
-};
+const select = (runtime, selector) => require_runtime.readWith(runtime, selector);
 //#endregion
-exports.DocumentDisposedError = require_dependency.DocumentDisposedError;
-exports.DocumentReentrancyError = require_dependency.DocumentReentrancyError;
+exports.DocumentDisposedError = require_runtime.DocumentDisposedError;
+exports.DocumentReentrancyError = require_runtime.DocumentReentrancyError;
+exports.ProjectionDisposedError = require_runtime.ProjectionDisposedError;
+exports.ProjectionError = require_runtime.ProjectionError;
 exports.asReadable = asReadable;
 exports.commandFootprint = commandFootprint;
-exports.contains = require_dependency.contains;
-exports.createCollectionView = createCollectionView;
+exports.contains = require_runtime.contains;
 exports.createDocument = createDocument;
-exports.createMaterializedView = createMaterializedView;
-exports.debugKey = require_dependency.debugKey;
+exports.createProjectionRuntime = require_runtime.createProjectionRuntime;
+exports.debugKey = require_runtime.debugKey;
 exports.decodeCommandFootprint = decodeCommandFootprint;
-exports.dict = require_dependency.dict;
-exports.field = require_dependency.field;
+exports.dict = require_runtime.dict;
+exports.field = require_runtime.field;
 exports.footprintsOverlap = footprintsOverlap;
-exports.list = require_dependency.list;
-exports.map = require_dependency.map;
-exports.object = require_dependency.object;
-exports.optional = require_dependency.optional;
-exports.overlaps = require_dependency.overlaps;
-exports.readAddress = require_dependency.read;
-exports.record = require_dependency.record;
-exports.resolveAddress = require_dependency.resolveAddress;
-exports.schema = require_dependency.schema;
+exports.list = require_runtime.list;
+exports.map = require_runtime.map;
+exports.object = require_runtime.object;
+exports.optional = require_runtime.optional;
+exports.overlaps = require_runtime.overlaps;
+exports.readAddress = require_runtime.read;
+exports.record = require_runtime.record;
+exports.resolveAddress = require_runtime.resolveAddress;
+exports.schema = require_runtime.schema;
 exports.select = select;
-exports.single = require_dependency.single;
-exports.table = require_dependency.table;
+exports.single = require_runtime.single;
+exports.table = require_runtime.table;
 Object.defineProperty(exports, "target", {
 	enumerable: true,
 	get: function() {
-		return require_dependency.impact_target_exports;
+		return require_runtime.impact_target_exports;
 	}
 });
-exports.tree = require_dependency.tree;
-exports.variant = require_dependency.variant;
+exports.tree = require_runtime.tree;
+exports.variant = require_runtime.variant;
 
 //# sourceMappingURL=index.cjs.map