doxum 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -1,5 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_dependency = require("./dependency-DLcCvNKq.cjs");
+const require_dependency = require("./dependency-Dfzs3khk.cjs");
+const require_ownership = require("./ownership-CU-9DKJQ.cjs");
+const require_driver = require("./driver-CNxqMVFH.cjs");
 //#region core/src/impact.ts
 const emptyCollectionImpact = Object.freeze({
 	kind: "incremental",
@@ -34,7 +36,7 @@ const createImpact = (input) => {
 		kind,
 		operations: input.operations,
 		affects: (value) => {
-			require_dependency.profile.impact.affects();
+			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;
@@ -403,7 +405,7 @@ const restore = (keys, inserted, positions) => {
 //#region core/src/mutation/execute-entity.ts
 const resolveEntityCollection = (node, value) => {
 	if (node.kind === "table") {
-		if (!require_dependency.isRecord(value) || !Array.isArray(value.ids) || !require_dependency.isRecord(value.byId)) return { status: "invalid" };
+		if (!require_ownership.isRecord(value) || !Array.isArray(value.ids) || !require_ownership.isRecord(value.byId)) return { status: "invalid" };
 		return {
 			status: "resolved",
 			collection: {
@@ -413,7 +415,7 @@ const resolveEntityCollection = (node, value) => {
 			}
 		};
 	}
-	return require_dependency.isRecord(value) ? {
+	return require_ownership.isRecord(value) ? {
 		status: "resolved",
 		collection: {
 			kind: "map",
@@ -445,7 +447,7 @@ const executeEntity = (target, operation, copyPayload) => {
 		if (ids && operation.positions) {
 			if (operation.positions.length !== operation.entries.length || !validPositions(ids.length, operation.positions)) return rejected$4(operation, "invalid-operation", "Entity restore positions are invalid.");
 		} else if (ids && !valid(ids, operation.anchor)) return rejected$4(operation, "invalid-anchor", "Collection anchor is invalid.");
-		for (const entry of operation.entries) byId[entry.id] = copyPayload ? require_dependency.cloneValue(entry.value, "canonical") : require_dependency.transferPayload(entry.value);
+		for (const entry of operation.entries) byId[entry.id] = copyPayload ? require_ownership.cloneValue(entry.value, "canonical") : require_ownership.transferPayload(entry.value);
 		if (ids) if (operation.positions) restore(ids, operation.entries.map((entry) => entry.id), operation.positions);
 		else if (!operation.anchor || "at" in operation.anchor && operation.anchor.at === "end") for (const entry of operation.entries) ids.push(entry.id);
 		else {
@@ -487,7 +489,7 @@ const executeEntity = (target, operation, copyPayload) => {
 				if (seen.has(id)) {
 					entries.push({
 						id,
-						value: require_dependency.cloneValue(byId[id], "inverse")
+						value: require_ownership.cloneValue(byId[id], "inverse")
 					});
 					positions.push(index);
 					delete byId[id];
@@ -497,7 +499,7 @@ const executeEntity = (target, operation, copyPayload) => {
 		} else for (const id of operation.ids) {
 			entries.push({
 				id,
-				value: require_dependency.cloneValue(byId[id], "inverse")
+				value: require_ownership.cloneValue(byId[id], "inverse")
 			});
 			delete byId[id];
 		}
@@ -542,7 +544,7 @@ 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;
 	const orderedKeys = keys(list, target.node.keyOf);
-	const own = (value) => copyPayload ? require_dependency.ownPayload(value) : value;
+	const own = (value) => copyPayload ? require_ownership.ownPayload(value) : value;
 	if (operation.type === "list.replace") {
 		if (operation.keys.length !== operation.value.length) return rejected$3(operation, "invalid-list-keys", "List replacement keys are invalid.");
 		const seen = /* @__PURE__ */ new Set();
@@ -551,13 +553,13 @@ 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_dependency.sameStructuralValue(list, operation.value)) return { status: "unchanged" };
+		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 = {
 			type: "list.replace",
 			at: operation.at,
-			value: require_dependency.cloneValue(list, "inverse"),
+			value: require_ownership.cloneValue(list, "inverse"),
 			keys
 		};
 		const owned = own(operation.value);
@@ -589,7 +591,7 @@ const executeList = (target, operation, copyPayload) => {
 			type: "list.insert",
 			at: operation.at,
 			key: operation.key,
-			value: require_dependency.cloneValue(list[position], "inverse"),
+			value: require_ownership.cloneValue(list[position], "inverse"),
 			anchor: at(orderedKeys, position)
 		};
 		list.splice(position, 1);
@@ -679,7 +681,7 @@ const restoreIncremental = (value, change) => {
 	}
 	return value;
 };
-const restoreChange = (value, change) => change.mode === "whole" ? require_dependency.ownPayload(change.value, "journal") : restoreIncremental(value, change);
+const restoreChange = (value, change) => change.mode === "whole" ? require_ownership.ownPayload(change.value, "journal") : restoreIncremental(value, change);
 const wholeChange = (inverse, previous) => {
 	if (!previous) return {
 		mode: "whole",
@@ -688,7 +690,7 @@ const wholeChange = (inverse, previous) => {
 	if (previous.mode === "whole") return previous;
 	return {
 		mode: "whole",
-		value: restoreIncremental(require_dependency.ownPayload(inverse.value, "journal"), previous)
+		value: restoreIncremental(require_ownership.ownPayload(inverse.value, "journal"), previous)
 	};
 };
 const removedNodePresences = (inverses) => {
@@ -779,16 +781,16 @@ const recordChange = (previous, current, forward, inverses) => {
 };
 const sameNodePresence = (before, value) => {
 	if (before.status === "absent") return value === void 0;
-	return value !== void 0 && before.parentId === value.parentId && sameOrder$1(before.children, value.children) && require_dependency.sameStructuralValue(before.value, value.value);
+	return value !== void 0 && before.parentId === value.parentId && sameOrder$1(before.children, value.children) && require_ownership.sameStructuralValue(before.value, value.value);
 };
 const changeChanged = (change, value) => {
-	if (change.mode === "whole") return !require_dependency.sameStructuralValue(change.value, value);
+	if (change.mode === "whole") return !require_ownership.sameStructuralValue(change.value, value);
 	if (!is(value)) return true;
 	if ((change.root.status === "present" ? change.root.id : void 0) !== value.rootId) return true;
 	for (const [id, before] of change.nodes) if (!sameNodePresence(before, node(value, id))) return true;
 	return false;
 };
-const is = (value) => require_dependency.isRecord(value) && require_dependency.isRecord(value.nodes);
+const is = (value) => require_ownership.isRecord(value) && require_ownership.isRecord(value.nodes);
 const contains$1 = (tree, id) => has$1(tree.nodes, id);
 const validate = (value) => {
 	if (!is(value)) return false;
@@ -797,7 +799,7 @@ const validate = (value) => {
 	if (typeof value.rootId !== "string" || !has$1(value.nodes, value.rootId)) return false;
 	for (const id of ids) {
 		const entry = value.nodes[id];
-		if (!require_dependency.isRecord(entry) || !Array.isArray(entry.children)) return false;
+		if (!require_ownership.isRecord(entry) || !Array.isArray(entry.children)) return false;
 		if (entry.children.some((child) => typeof child !== "string") || new Set(entry.children).size !== entry.children.length) return false;
 		if (entry.parentId !== void 0 && typeof entry.parentId !== "string") return false;
 		if (id === value.rootId) {
@@ -824,7 +826,7 @@ const documentTreeError = (node, value, address) => {
 	if ("optional" in node && node.optional && value === void 0) return void 0;
 	if (node.kind === "tree") return validate(value) ? void 0 : address;
 	if (node.kind === "object") {
-		if (!require_dependency.isRecord(value)) return void 0;
+		if (!require_ownership.isRecord(value)) return void 0;
 		for (const [key, child] of Object.entries(node.shape)) {
 			const error = documentTreeError(child, value[key], [...address, key]);
 			if (error) return error;
@@ -833,12 +835,12 @@ const documentTreeError = (node, value, address) => {
 	}
 	if (node.kind === "single") return documentTreeError(node.value, value, address);
 	if (node.kind === "variant") {
-		if (!require_dependency.isRecord(value) || typeof value[node.tag] !== "string") return void 0;
+		if (!require_ownership.isRecord(value) || typeof value[node.tag] !== "string") return void 0;
 		const variant = node.variants[value[node.tag]];
 		return variant ? documentTreeError(variant, value, address) : void 0;
 	}
 	if (node.kind === "table") {
-		if (!require_dependency.isRecord(value) || !require_dependency.isRecord(value.byId)) return void 0;
+		if (!require_ownership.isRecord(value) || !require_ownership.isRecord(value.byId)) return void 0;
 		for (const [id, entry] of Object.entries(value.byId)) {
 			const error = documentTreeError(node.value, entry, [...address, id]);
 			if (error) return error;
@@ -846,7 +848,7 @@ const documentTreeError = (node, value, address) => {
 		return;
 	}
 	if (node.kind === "map") {
-		if (!require_dependency.isRecord(value)) return void 0;
+		if (!require_ownership.isRecord(value)) return void 0;
 		for (const [id, entry] of Object.entries(value)) {
 			const error = documentTreeError(node.value, entry, [...address, id]);
 			if (error) return error;
@@ -859,13 +861,13 @@ const invalidDocument = (schema, value) => documentTreeError({
 }, value, []);
 const replace = (current, operation) => {
 	if (!validate(operation.value)) return rejected$2("invalid-tree", "Tree replacement is malformed.");
-	if (require_dependency.sameStructuralValue(current, operation.value)) return { status: "unchanged" };
+	if (require_ownership.sameStructuralValue(current, operation.value)) return { status: "unchanged" };
 	return {
 		status: "changed",
 		inverse: [{
 			type: "tree.replace",
 			at: operation.at,
-			value: require_dependency.cloneValue(current, "inverse")
+			value: require_ownership.cloneValue(current, "inverse")
 		}]
 	};
 };
@@ -907,7 +909,7 @@ const set = (tree, operation, value) => {
 		type: "tree.set",
 		at: operation.at,
 		treeNodeId: operation.treeNodeId,
-		value: require_dependency.cloneValue(entry.value, "inverse")
+		value: require_ownership.cloneValue(entry.value, "inverse")
 	};
 	entry.value = value;
 	return {
@@ -938,7 +940,7 @@ const remove = (tree, operation) => {
 			id: frame.id,
 			parentId: frame.parentId,
 			index: frame.index,
-			value: require_dependency.cloneValue(entry.value, "inverse")
+			value: require_ownership.cloneValue(entry.value, "inverse")
 		});
 		for (let index = entry.children.length - 1; index >= 0; index -= 1) {
 			const childId = entry.children[index];
@@ -1026,10 +1028,10 @@ const executeTree = (root, target, operation, copyPayload) => {
 		status: "rejected",
 		issue: from(operation, "invalid-address", "Tree target is invalid.")
 	};
-	const own = (value) => copyPayload ? require_dependency.ownPayload(value) : value;
+	const own = (value) => copyPayload ? require_ownership.ownPayload(value) : value;
 	if (operation.type === "tree.replace") {
 		const result = replace(target.value, operation);
-		if (result.status === "changed") require_dependency.set(root, operation.at, require_dependency.ownPayload(operation.value));
+		if (result.status === "changed") require_dependency.set(root, operation.at, require_ownership.ownPayload(operation.value));
 		return outcome(operation, result);
 	}
 	if (operation.type === "tree.insert") return outcome(operation, insert(target.value, operation, own(operation.value)));
@@ -1044,7 +1046,7 @@ const rejected$1 = (operation, code, message) => ({
 	issue: from(operation, code, message)
 });
 const executeValue = (target, operation, copyPayload) => {
-	const own = (value) => copyPayload ? require_dependency.ownPayload(value) : value;
+	const own = (value) => copyPayload ? require_ownership.ownPayload(value) : value;
 	if (operation.type === "field.set" || operation.type === "field.clear") {
 		const existed = Object.prototype.hasOwnProperty.call(target.parent, target.key);
 		if (operation.type === "field.clear") {
@@ -1077,11 +1079,11 @@ const executeValue = (target, operation, copyPayload) => {
 		};
 	}
 	if (operation.type === "variant.replace") {
-		if (require_dependency.sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
+		if (require_ownership.sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
 		const inverse = {
 			type: "variant.replace",
 			at: operation.at,
-			value: require_dependency.ownPayload(target.value, "inverse")
+			value: require_ownership.ownPayload(target.value, "inverse")
 		};
 		target.parent[target.key] = own(operation.value);
 		return {
@@ -1089,13 +1091,13 @@ const executeValue = (target, operation, copyPayload) => {
 			inverse: [inverse]
 		};
 	}
-	if (!require_dependency.isRecord(target.value)) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
+	if (!require_ownership.isRecord(target.value)) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
 	if (operation.type === "dict.replace") {
-		if (require_dependency.sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
+		if (require_ownership.sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
 		const inverse = {
 			type: "dict.replace",
 			at: operation.at,
-			value: require_dependency.cloneValue(target.value, "inverse")
+			value: require_ownership.cloneValue(target.value, "inverse")
 		};
 		target.parent[target.key] = own(operation.value);
 		return {
@@ -1157,7 +1159,7 @@ const execute = (root, operation, target, copyPayload) => {
 //#region core/src/mutation/journal.ts
 const indexNode = () => ({ children: /* @__PURE__ */ new Map() });
 const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-const sameAddress = (left, right) => {
+const sameAddress$1 = (left, right) => {
 	if (left.length !== right.length) return false;
 	for (let index = 0; index < left.length; index += 1) if (left[index] !== right[index]) return false;
 	return true;
@@ -1258,7 +1260,7 @@ const restoreRootSubject = (value, subject) => {
 	if (subject.kind === "value") return subject.before.status === "present" ? subject.before.value : void 0;
 	if (subject.kind === "variant") return subject.before;
 	if (subject.kind === "dict") {
-		if (require_dependency.isRecord(value)) restoreDict(value, subject.state);
+		if (require_ownership.isRecord(value)) restoreDict(value, subject.state);
 		return value;
 	}
 	if (subject.kind === "entity") {
@@ -1272,7 +1274,7 @@ const restoreRootSubject = (value, subject) => {
 	return restoreChange(value, subject.state);
 };
 const restoreSubject = (value, prefix, subject) => {
-	if (sameAddress(prefix, subject.address)) return restoreRootSubject(value, subject);
+	if (sameAddress$1(prefix, subject.address)) return restoreRootSubject(value, subject);
 	const address = subject.address.slice(prefix.length);
 	if (subject.kind === "value") {
 		writePresence(value, address, subject.before);
@@ -1284,7 +1286,7 @@ const restoreSubject = (value, prefix, subject) => {
 	}
 	const current = require_dependency.read(value, address);
 	if (subject.kind === "dict") {
-		if (require_dependency.isRecord(current)) restoreDict(current, subject.state);
+		if (require_ownership.isRecord(current)) restoreDict(current, subject.state);
 		return value;
 	}
 	if (subject.kind === "entity") {
@@ -1307,8 +1309,8 @@ const valueChanged = (root, subject) => {
 };
 const dictChanged = (root, subject) => {
 	const value = require_dependency.read(root, subject.address);
-	if (!require_dependency.isRecord(value)) return true;
-	if (subject.state.mode === "whole") return !require_dependency.sameStructuralValue(subject.state.value, value);
+	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) {
 		const exists = hasOwn(value, key);
 		if (before.status === "absent" ? exists : !exists || !Object.is(before.value, value[key])) return true;
@@ -1318,7 +1320,7 @@ const dictChanged = (root, subject) => {
 const listChanged = (root, subject) => {
 	const value = require_dependency.read(root, subject.address);
 	if (!Array.isArray(value)) return true;
-	if (subject.state.mode === "whole") return !require_dependency.sameStructuralValue(subject.state.value, value);
+	if (subject.state.mode === "whole") return !require_ownership.sameStructuralValue(subject.state.value, value);
 	const positions = /* @__PURE__ */ new Map();
 	const order = new Array(value.length);
 	for (let index = 0; index < value.length; index += 1) {
@@ -1331,7 +1333,7 @@ const listChanged = (root, subject) => {
 		const position = positions.get(key);
 		if (before.status === "absent") {
 			if (position !== void 0) return true;
-		} else if (position === void 0 || !require_dependency.sameStructuralValue(before.value, value[position])) return true;
+		} else if (position === void 0 || !require_ownership.sameStructuralValue(before.value, value[position])) return true;
 	}
 	return false;
 };
@@ -1365,7 +1367,7 @@ const analyzeEntity = (root, subject) => {
 		if (before.status === "absent") {
 			if (exists) added.add(id);
 		} else if (!exists) removed.add(id);
-		else if (!require_dependency.sameStructuralValue(before.value, collection.byId[id])) updated.add(id);
+		else if (!require_ownership.sameStructuralValue(before.value, collection.byId[id])) updated.add(id);
 	}
 	const beforeOrder = subject.order.kind === "tracked" ? subject.order.before : void 0;
 	const finalOrder = collection.kind === "table" ? collection.ids : [];
@@ -1380,7 +1382,7 @@ const analyzeEntity = (root, subject) => {
 };
 const subjectChanged = (root, subject) => {
 	if (subject.kind === "value") return valueChanged(root, subject);
-	if (subject.kind === "variant") return !require_dependency.sameStructuralValue(subject.before, require_dependency.read(root, subject.address));
+	if (subject.kind === "variant") return !require_ownership.sameStructuralValue(subject.before, require_dependency.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));
@@ -1469,7 +1471,7 @@ const createChangeJournal = (root) => {
 		}
 		if (node.subject) throw new Error(`Change journal already owns '${subject.address.join(".")}'.`);
 		node.subject = subject;
-		require_dependency.profile.journal.subject();
+		require_ownership.profile.journal.subject();
 		return subject;
 	};
 	const remove = (subject) => {
@@ -1498,8 +1500,8 @@ const createChangeJournal = (root) => {
 	function find(kind, address, addressHash) {
 		const candidates = buckets.get(addressHash) ?? [];
 		for (const subject of candidates) {
-			require_dependency.profile.journal.comparison();
-			if (subject.kind === kind && sameAddress(subject.address, address)) return subject;
+			require_ownership.profile.journal.comparison();
+			if (subject.kind === kind && sameAddress$1(subject.address, address)) return subject;
 		}
 	}
 	const ownerOf = (address) => {
@@ -1515,11 +1517,11 @@ const createChangeJournal = (root) => {
 		const subjects = indexedSubjects(index, address);
 		if (subjects.length === 0) return value;
 		subjects.sort((left, right) => left.address.length - right.address.length);
-		let before = require_dependency.ownPayload(value, "journal");
+		let before = require_ownership.ownPayload(value, "journal");
 		for (const subject of subjects) before = restoreSubject(before, address, subject);
 		for (const subject of subjects) {
 			remove(subject);
-			require_dependency.profile.journal.absorbed();
+			require_ownership.profile.journal.absorbed();
 		}
 		return before;
 	};
@@ -1561,7 +1563,7 @@ const createChangeJournal = (root) => {
 		});
 		if (subject.state.mode === "whole") return;
 		if (first.type === "dict.replace") {
-			const value = require_dependency.ownPayload(first.value, "journal");
+			const value = require_ownership.ownPayload(first.value, "journal");
 			restoreDict(value, subject.state);
 			subject.state = {
 				mode: "whole",
@@ -1605,7 +1607,7 @@ const createChangeJournal = (root) => {
 		}
 		if (subject.state.mode === "whole") return;
 		if (first.type === "list.replace") {
-			const value = Array.from(require_dependency.ownPayload(first.value, "journal"));
+			const value = Array.from(require_ownership.ownPayload(first.value, "journal"));
 			restoreList(value, subject);
 			subject.state = {
 				mode: "whole",
@@ -1618,7 +1620,7 @@ const createChangeJournal = (root) => {
 	};
 	const trackEntityOrder = (subject, collection) => {
 		if (subject.order.kind !== "stable") return;
-		require_dependency.profile.journal.orderSnapshot(collection.ids.length);
+		require_ownership.profile.journal.orderSnapshot(collection.ids.length);
 		const before = [...collection.ids];
 		restoreEntityOrder(before, subject.order.inverses);
 		subject.order = {
@@ -1679,7 +1681,7 @@ const createChangeJournal = (root) => {
 	};
 	return {
 		record: (resolved, operation, inverse) => {
-			require_dependency.profile.batch.journalRecord();
+			require_ownership.profile.batch.journalRecord();
 			if (ownerOf(operation.at)) return;
 			if (operation.type === "field.set" || operation.type === "field.clear") {
 				recordValue(resolved, operation, inverse);
@@ -1707,7 +1709,7 @@ const createChangeJournal = (root) => {
 			const changed = [];
 			const entityChanges = /* @__PURE__ */ new Map();
 			for (const subject of active) {
-				require_dependency.profile.journal.comparison();
+				require_ownership.profile.journal.comparison();
 				if (subject.kind === "entity") {
 					const analysis = analyzeEntity(root, subject);
 					if (!analysis.changed) continue;
@@ -1721,7 +1723,7 @@ const createChangeJournal = (root) => {
 			const changeAt = (address, addressHash) => {
 				const candidates = collectionBuckets.get(addressHash) ?? [];
 				collectionBuckets.set(addressHash, candidates);
-				let change = candidates.find((entry) => sameAddress(entry.address, address));
+				let change = candidates.find((entry) => sameAddress$1(entry.address, address));
 				if (!change) {
 					change = {
 						address,
@@ -1765,9 +1767,9 @@ const createChangeJournal = (root) => {
 const has = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
 const stringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
 const positions = (value) => Array.isArray(value) && value.every((entry) => Number.isInteger(entry) && entry >= 0);
-const address = (value) => stringArray(value);
+const address$1 = (value) => stringArray(value);
 const anchor = (value) => {
-	if (!require_dependency.isRecord(value)) return false;
+	if (!require_ownership.isRecord(value)) return false;
 	if (Number(has(value, "at")) + Number(has(value, "before")) + Number(has(value, "after")) !== 1) return false;
 	if (has(value, "at")) return value.at === "start" || value.at === "end";
 	return typeof (has(value, "before") ? value.before : value.after) === "string";
@@ -1775,7 +1777,7 @@ const anchor = (value) => {
 const optionalAnchor = (value) => !has(value, "anchor") || value.anchor === void 0 || anchor(value.anchor);
 const optionalParent = (value) => !has(value, "parentId") || value.parentId === void 0 || typeof value.parentId === "string";
 const optionalIndex = (value) => !has(value, "index") || value.index === void 0 || Number.isInteger(value.index) && value.index >= 0;
-const entries = (value) => Array.isArray(value) && value.every((entry) => require_dependency.isRecord(entry) && typeof entry.id === "string" && has(entry, "value"));
+const entries = (value) => Array.isArray(value) && value.every((entry) => require_ownership.isRecord(entry) && typeof entry.id === "string" && has(entry, "value"));
 const decoded = (operation) => ({
 	status: "decoded",
 	operation
@@ -1785,8 +1787,8 @@ const rejected = (code, message) => ({
 	issue: input(code, message)
 });
 const decode = (input) => {
-	if (!require_dependency.isRecord(input)) return rejected("invalid-operation", "Operation must be an object.");
-	if (!address(input.at)) return rejected("invalid-address", "Operation address is malformed.");
+	if (!require_ownership.isRecord(input)) return rejected("invalid-operation", "Operation must be an object.");
+	if (!address$1(input.at)) return rejected("invalid-address", "Operation address is malformed.");
 	if (typeof input.type !== "string") return rejected("invalid-operation", "Operation type must be a string.");
 	switch (input.type) {
 		case "field.set":
@@ -1794,7 +1796,7 @@ const decode = (input) => {
 		case "field.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_dependency.isRecord(input.value) ? decoded(input) : rejected("invalid-operation", "Dictionary replacement must be an object.");
+		case "dict.replace": return require_ownership.isRecord(input.value) ? decoded(input) : rejected("invalid-operation", "Dictionary replacement must be an object.");
 		case "entity.create": return entries(input.entries) && optionalAnchor(input) && (!has(input, "positions") || input.positions === void 0 || positions(input.positions)) ? decoded(input) : rejected("invalid-operation", "Entity create payload is malformed.");
 		case "entity.remove": return stringArray(input.ids) ? decoded(input) : rejected("invalid-operation", "Entity remove requires string ids.");
 		case "entity.move": return typeof input.id === "string" && optionalAnchor(input) ? decoded(input) : rejected("invalid-operation", "Entity move payload is malformed.");
@@ -1819,11 +1821,12 @@ const decodeBatch = (input$1) => Array.isArray(input$1) ? {
 };
 const ownAddress = (value) => {
 	if (Object.isFrozen(value)) return value;
-	require_dependency.profile.address.arrayCopied();
+	require_ownership.profile.address.arrayCopied();
 	return Object.freeze(value.slice());
 };
+const structuralPayload = (value) => Array.isArray(value) || require_ownership.isPlainObject(value);
 const normalize = (operation) => {
-	require_dependency.profile.mutation.normalized();
+	require_ownership.profile.mutation.normalized();
 	const copy = {
 		...operation,
 		at: ownAddress(operation.at)
@@ -1836,23 +1839,34 @@ const normalize = (operation) => {
 	return Object.freeze(copy);
 };
 const publish = (operation) => {
-	if (!require_dependency.operationOwnsStructuralPayload(operation)) return operation;
-	if (operation.type === "entity.create" && operation.entries.every((entry) => require_dependency.isStablePayload(entry.value))) return operation;
+	if (operation.type === "entity.create" && operation.entries.every((entry) => !structuralPayload(entry.value) || require_ownership.isStablePayload(entry.value))) return operation;
+	if ("value" in operation && (!structuralPayload(operation.value) || require_ownership.isStablePayload(operation.value))) return operation;
 	const copy = { ...operation };
 	if (copy.entries) copy.entries = Object.freeze(copy.entries.map((entry) => Object.freeze({
 		id: entry.id,
-		value: require_dependency.isStablePayload(entry.value) ? entry.value : require_dependency.snapshotPayload(entry.value, "commit")
+		value: structuralPayload(entry.value) ? require_ownership.isStablePayload(entry.value) ? entry.value : require_ownership.snapshotPayload(entry.value, "commit") : entry.value
 	})));
-	else if ("value" in copy) copy.value = require_dependency.isStablePayload(copy.value) ? copy.value : require_dependency.snapshotPayload(copy.value, "commit");
+	else if ("value" in copy && structuralPayload(copy.value)) copy.value = require_ownership.isStablePayload(copy.value) ? copy.value : require_ownership.snapshotPayload(copy.value, "commit");
 	return Object.freeze(copy);
 };
+const requiresPayloadCopy = (operation) => {
+	if (operation.type === "entity.create") return operation.entries.some((entry) => require_ownership.isStablePayload(entry.value));
+	return "value" in operation && require_ownership.isStablePayload(operation.value);
+};
 const inverse = (operation) => {
 	const copy = { ...operation };
 	if (copy.anchor) copy.anchor = Object.freeze({ ...copy.anchor });
 	if (copy.keys) copy.keys = Object.freeze([...copy.keys]);
-	if (copy.entries) copy.entries = Object.freeze(copy.entries.map((entry) => Object.freeze({ ...entry })));
+	if (copy.entries) copy.entries = Object.freeze(copy.entries.map((entry) => Object.freeze({
+		id: entry.id,
+		value: structuralPayload(entry.value) ? require_ownership.isStablePayload(entry.value) ? entry.value : require_ownership.snapshotPayload(entry.value, "inverse") : entry.value
+	})));
 	if (copy.ids) copy.ids = Object.freeze([...copy.ids]);
 	if (copy.positions) copy.positions = Object.freeze([...copy.positions]);
+	if ("value" in copy && structuralPayload(copy.value)) {
+		const payload = copy;
+		payload.value = require_ownership.isStablePayload(payload.value) ? payload.value : require_ownership.snapshotPayload(payload.value, "inverse");
+	}
 	return Object.freeze(copy);
 };
 //#endregion
@@ -1860,32 +1874,32 @@ const inverse = (operation) => {
 const createMutationSession = (root, schema, options = {}) => {
 	const steps = [];
 	const journal = createChangeJournal(root);
-	let closed = false;
+	let state = "active";
 	const rollback = () => {
-		if (closed) return;
+		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);
 			if (result.status === "rejected") throw new Error(`Document rollback failed: ${result.issue.message}`);
 		}
-		closed = true;
+		state = "rolled-back";
 	};
 	return {
 		apply: (input) => {
-			if (closed) throw new Error("Mutation session is closed.");
-			require_dependency.profile.batch.operation();
+			if (state !== "active") throw new Error("Mutation session is closed.");
+			require_ownership.profile.batch.operation();
 			const decoded = decode(input);
 			if (decoded.status === "rejected") {
-				require_dependency.profile.batch.rejected();
+				require_ownership.profile.batch.rejected();
 				return decoded.issue;
 			}
 			const normalized = normalize(decoded.operation);
-			require_dependency.profile.batch.entry(normalized.type === "entity.create" ? normalized.entries.length : normalized.type === "entity.remove" ? normalized.ids.length : 1);
+			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);
-			if (resolved?.collection) require_dependency.profile.batch.collectionResolved();
-			require_dependency.profile.mutation.executed();
-			const result = execute(root, normalized, resolved, options.copyPayload === true);
+			if (resolved?.collection) require_ownership.profile.batch.collectionResolved();
+			require_ownership.profile.mutation.executed();
+			const result = execute(root, normalized, resolved, options.copyPayload === true || requiresPayloadCopy(normalized));
 			if (result.status === "rejected") {
-				require_dependency.profile.batch.rejected();
+				require_ownership.profile.batch.rejected();
 				return result.issue;
 			}
 			if (result.status === "unchanged") return void 0;
@@ -1894,8 +1908,8 @@ const createMutationSession = (root, schema, options = {}) => {
 			for (const rawInverse of result.inverse) {
 				const inverse$1 = inverse(rawInverse);
 				group.push(inverse$1);
-				require_dependency.profile.mutation.inverse();
-				require_dependency.profile.batch.inverse();
+				require_ownership.profile.mutation.inverse();
+				require_ownership.profile.batch.inverse();
 			}
 			steps.push({
 				forward: published,
@@ -1910,9 +1924,9 @@ const createMutationSession = (root, schema, options = {}) => {
 			}
 		},
 		finish: () => {
-			if (closed) throw new Error("Mutation session is closed.");
-			closed = true;
+			if (state !== "active") throw new Error("Mutation session is closed.");
 			const changes = journal.finish();
+			state = "finished";
 			if (changes.status === "unchanged") return { status: "unchanged" };
 			let inverseCount = 0;
 			for (const step of steps) inverseCount += step.inverse.length;
@@ -1949,6 +1963,191 @@ const mutateOperations = (root, schema, operations, options = {}) => {
 	return session.finish();
 };
 //#endregion
+//#region core/src/mutation/footprint.ts
+const sameAddress = (left, right) => left.length === right.length && left.every((segment, index) => segment === right[index]);
+const containsAddress = (parent, child) => parent.length <= child.length && parent.every((segment, index) => segment === child[index]);
+const address = (value) => Array.isArray(value) && value.every((segment) => typeof segment === "string") ? Object.freeze(value.slice()) : void 0;
+const targetKey = (target) => {
+	const at = target.at.join("\0");
+	if (target.kind === "dictionary-key" || target.kind === "list-item") return `${target.kind}:${at}:${target.key}`;
+	if (target.kind === "entity" || target.kind === "tree-node") return `${target.kind}:${at}:${target.id}`;
+	return `${target.kind}:${at}`;
+};
+const freezeTarget = (target) => Object.freeze({
+	...target,
+	at: Object.freeze(target.at.slice())
+});
+const add = (targets, target) => {
+	const stable = freezeTarget(target);
+	targets.set(targetKey(stable), stable);
+};
+const commandFootprint = (operations) => {
+	const targets = /* @__PURE__ */ new Map();
+	for (const operation of operations) switch (operation.type) {
+		case "field.set":
+		case "field.clear":
+		case "variant.replace":
+			add(targets, {
+				kind: "value",
+				at: operation.at
+			});
+			break;
+		case "dict.replace":
+			add(targets, {
+				kind: "dictionary",
+				at: operation.at
+			});
+			break;
+		case "dict.set":
+		case "dict.delete":
+			add(targets, {
+				kind: "dictionary-key",
+				at: operation.at,
+				key: operation.key
+			});
+			break;
+		case "entity.create":
+			add(targets, {
+				kind: "collection",
+				at: operation.at
+			});
+			for (const entry of operation.entries) add(targets, {
+				kind: "entity",
+				at: operation.at,
+				id: entry.id
+			});
+			break;
+		case "entity.remove":
+			add(targets, {
+				kind: "collection",
+				at: operation.at
+			});
+			for (const id of operation.ids) add(targets, {
+				kind: "entity",
+				at: operation.at,
+				id
+			});
+			break;
+		case "entity.move":
+			add(targets, {
+				kind: "collection",
+				at: operation.at
+			});
+			add(targets, {
+				kind: "entity",
+				at: operation.at,
+				id: operation.id
+			});
+			break;
+		case "list.insert":
+		case "list.move":
+		case "list.remove":
+			add(targets, {
+				kind: "list",
+				at: operation.at
+			});
+			add(targets, {
+				kind: "list-item",
+				at: operation.at,
+				key: operation.key
+			});
+			break;
+		case "list.replace":
+			add(targets, {
+				kind: "list",
+				at: operation.at
+			});
+			for (const key of operation.keys) add(targets, {
+				kind: "list-item",
+				at: operation.at,
+				key
+			});
+			break;
+		case "tree.insert":
+		case "tree.move":
+		case "tree.remove":
+		case "tree.set":
+			add(targets, {
+				kind: "tree",
+				at: operation.at
+			});
+			add(targets, {
+				kind: "tree-node",
+				at: operation.at,
+				id: operation.treeNodeId
+			});
+			break;
+		case "tree.replace":
+			add(targets, {
+				kind: "tree",
+				at: operation.at
+			});
+			break;
+	}
+	return Object.freeze(Array.from(targets.values()));
+};
+const overlapsValueAndEntity = (value, entity) => containsAddress([...entity.at, entity.id], value.at) || containsAddress(value.at, [...entity.at, entity.id]);
+const targetsOverlap = (left, right) => {
+	if (left.kind === "value" && right.kind === "value") return containsAddress(left.at, right.at) || containsAddress(right.at, left.at);
+	if (left.kind === "value" && right.kind === "entity") return overlapsValueAndEntity(left, right);
+	if (left.kind === "entity" && right.kind === "value") return overlapsValueAndEntity(right, left);
+	if (left.kind === "dictionary" && right.kind === "dictionary") return sameAddress(left.at, right.at);
+	if (left.kind === "dictionary" && right.kind === "dictionary-key") return sameAddress(left.at, right.at);
+	if (left.kind === "dictionary-key" && right.kind === "dictionary") return sameAddress(left.at, right.at);
+	if (left.kind === "dictionary-key" && right.kind === "dictionary-key") return sameAddress(left.at, right.at) && left.key === right.key;
+	if (left.kind === "collection" && right.kind === "collection") return sameAddress(left.at, right.at);
+	if (left.kind === "collection" && right.kind === "entity") return sameAddress(left.at, right.at);
+	if (left.kind === "entity" && right.kind === "collection") return sameAddress(left.at, right.at);
+	if (left.kind === "entity" && right.kind === "entity") return sameAddress(left.at, right.at) && left.id === right.id;
+	if (left.kind === "list" && (right.kind === "list" || right.kind === "list-item")) return sameAddress(left.at, right.at);
+	if (right.kind === "list" && left.kind === "list-item") return sameAddress(left.at, right.at);
+	if (left.kind === "list-item" && right.kind === "list-item") return sameAddress(left.at, right.at) && left.key === right.key;
+	if (left.kind === "tree" && (right.kind === "tree" || right.kind === "tree-node")) return sameAddress(left.at, right.at);
+	if (right.kind === "tree" && left.kind === "tree-node") return sameAddress(left.at, right.at);
+	if (left.kind === "tree-node" && right.kind === "tree-node") return sameAddress(left.at, right.at) && left.id === right.id;
+	return false;
+};
+const footprintsOverlap = (left, right) => left.some((leftTarget) => right.some((rightTarget) => targetsOverlap(leftTarget, rightTarget)));
+const decodedTarget = (value) => {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	const at = address(record.at);
+	if (!at || typeof record.kind !== "string") return void 0;
+	switch (record.kind) {
+		case "value":
+		case "dictionary":
+		case "collection":
+		case "list":
+		case "tree": return freezeTarget({
+			kind: record.kind,
+			at
+		});
+		case "dictionary-key":
+		case "list-item": return typeof record.key === "string" ? freezeTarget({
+			kind: record.kind,
+			at,
+			key: record.key
+		}) : void 0;
+		case "entity":
+		case "tree-node": return typeof record.id === "string" ? freezeTarget({
+			kind: record.kind,
+			at,
+			id: record.id
+		}) : void 0;
+		default: return;
+	}
+};
+const decodeCommandFootprint = (value) => {
+	if (!Array.isArray(value)) return void 0;
+	const targets = /* @__PURE__ */ new Map();
+	for (const entry of value) {
+		const target = decodedTarget(entry);
+		if (!target) return void 0;
+		targets.set(targetKey(target), target);
+	}
+	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();
@@ -1971,6 +2170,9 @@ const notificationOf = (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 = {
@@ -2122,20 +2324,57 @@ const publishDiagnostic = (value) => Object.freeze({
 const createDocument = (input) => {
 	const initialTreeError = invalidDocument(input.schema, input.initial);
 	if (initialTreeError) throw new TypeError(`Initial document contains an invalid tree at '${initialTreeError.join(".")}'.`);
-	require_dependency.profile.clone.initialDocument();
+	require_ownership.profile.clone.initialDocument();
 	const state = {
 		schema: input.schema,
-		document: require_dependency.cloneValue(input.initial, "initial"),
+		document: require_ownership.cloneValue(input.initial, "initial"),
 		disposed: false
 	};
 	let revision = 0;
 	let busy = false;
 	let runtime;
 	let notification;
-	const assertWritable = () => {
+	const assertWritable = (intent) => {
 		if (state.disposed) throw new require_dependency.DocumentDisposedError();
 		if (busy) throw new require_dependency.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),
+			write: documentWriter(input.schema, (operation) => {
+				if (!active) throw new Error("Document writer is no longer active.");
+				const rejected = session.apply(operation);
+				if (rejected) throw new RejectedUpdate([rejected]);
+			}),
+			reject: (diagnostic) => {
+				throw new RejectedUpdate((Array.isArray(diagnostic) ? diagnostic : [diagnostic]).map((entry) => publishDiagnostic(entry)));
+			},
+			report: (diagnostic) => {
+				if (!active) throw new Error("Document transaction is no longer active.");
+				(reports ??= []).push(publishDiagnostic(diagnostic));
+			}
+		};
+		try {
+			const value = run(transaction);
+			if (value !== null && typeof value === "object" && typeof value.then === "function") throw new TypeError("Document update callback must be synchronous.");
+			return {
+				value,
+				reports: Object.freeze(reports ? reports.slice() : EMPTY)
+			};
+		} finally {
+			active = false;
+		}
 	};
+	const impactFor = (batch, kind) => createImpact({
+		schema: input.schema,
+		operations: batch.operations,
+		paths: batch.paths,
+		collections: batch.collections,
+		reset: kind === "replace"
+	});
 	const history = createHistory({
 		capacity: input.history === false ? 0 : Math.max(0, input.history?.capacity ?? 100),
 		revision: () => revision,
@@ -2149,13 +2388,7 @@ const createDocument = (input) => {
 			source,
 			operations: batch.operations,
 			inverse: batch.inverse,
-			impact: createImpact({
-				schema: input.schema,
-				operations: batch.operations,
-				paths: batch.paths,
-				collections: batch.collections,
-				reset: kind === "replace"
-			})
+			impact: impactFor(batch, kind)
 		});
 		if (kind === "replace" || source === "remote") history.invalidate();
 		else if (recordHistory && (source === "local" || source === "system")) history.record(batch.operations, batch.inverse);
@@ -2173,7 +2406,10 @@ const createDocument = (input) => {
 		};
 	};
 	function applyBatch(operations, source, recordHistory) {
-		assertWritable();
+		assertWritable({
+			kind: "apply",
+			source
+		});
 		const batch = mutateOperations(state.document, input.schema, operations, { copyPayload: source === "history" });
 		if (batch.status === "rejected") return {
 			status: "rejected",
@@ -2187,6 +2423,7 @@ const createDocument = (input) => {
 		return publish(batch, source, "operations", recordHistory);
 	}
 	runtime = {
+		schema: input.schema,
 		address: {
 			resolve: (address) => require_dependency.resolveAddress(input.schema, address, state.document),
 			read: (address) => require_dependency.read(state.document, address),
@@ -2196,55 +2433,40 @@ const createDocument = (input) => {
 		},
 		revision: () => revision,
 		update: (run, options) => {
-			assertWritable();
+			const source = options?.source ?? "local";
+			assertWritable({
+				kind: "update",
+				source
+			});
 			busy = true;
 			const session = createMutationSession(state.document, input.schema);
-			let reports;
-			let active = true;
-			const transaction = {
-				read: require_dependency.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);
-					if (rejected) throw new RejectedUpdate([rejected]);
-				}),
-				reject: (diagnostic) => {
-					throw new RejectedUpdate((Array.isArray(diagnostic) ? diagnostic : [diagnostic]).map((entry) => publishDiagnostic(entry)));
-				},
-				report: (diagnostic) => {
-					if (!active) throw new Error("Document transaction is no longer active.");
-					(reports ??= []).push(publishDiagnostic(diagnostic));
-				}
-			};
+			let committed = false;
 			try {
-				const value = run(transaction);
-				if (value !== null && typeof value === "object" && typeof value.then === "function") throw new TypeError("Document update callback must be synchronous.");
-				active = false;
-				busy = false;
+				const { value, reports } = runTransaction(session, run);
 				const batch = session.finish();
 				if (batch.status === "unchanged") return {
 					status: "unchanged",
 					value,
 					revision,
-					reports: Object.freeze(reports ?? EMPTY)
+					reports
 				};
 				if (batch.status === "rejected") return {
 					status: "rejected",
 					issues: batch.issues,
 					revision
 				};
-				const result = publish(batch, options?.source ?? "local", "operations", options?.history ?? true);
+				const result = publish(batch, source, "operations", options?.history ?? true);
+				committed = true;
 				return {
 					status: "committed",
 					value,
 					commit: result.commit,
-					reports: Object.freeze(reports ?? EMPTY),
+					reports,
 					observerErrors: result.observerErrors
 				};
 			} catch (error) {
-				active = false;
 				try {
-					session.rollback();
+					if (!committed) session.rollback();
 				} finally {
 					busy = false;
 				}
@@ -2255,31 +2477,86 @@ const createDocument = (input) => {
 				};
 				throw error;
 			} finally {
-				active = false;
+				busy = false;
+			}
+		},
+		prepare: (run) => {
+			assertWritable({ kind: "prepare" });
+			busy = true;
+			const session = createMutationSession(state.document, input.schema);
+			try {
+				const { value, reports } = runTransaction(session, run);
+				const batch = session.finish();
+				if (batch.status === "unchanged") {
+					session.rollback();
+					return {
+						status: "unchanged",
+						value,
+						reports
+					};
+				}
+				if (batch.status === "rejected") {
+					session.rollback();
+					return {
+						status: "rejected",
+						issues: batch.issues
+					};
+				}
+				const impact = impactFor(batch, "operations");
+				session.rollback();
+				return {
+					status: "prepared",
+					value,
+					operations: batch.operations,
+					inverse: batch.inverse,
+					impact,
+					footprint: commandFootprint(batch.operations),
+					reports
+				};
+			} catch (error) {
+				try {
+					session.rollback();
+				} finally {
+					busy = false;
+				}
+				if (error instanceof RejectedUpdate) return {
+					status: "rejected",
+					issues: error.issues
+				};
+				throw error;
+			} finally {
 				busy = false;
 			}
 		},
 		apply: (operations, options) => applyBatch(operations, options?.source ?? "local", options?.history ?? true),
 		replace: (document, options) => {
-			assertWritable();
+			const source = options?.source ?? "system";
+			assertWritable({
+				kind: "replace",
+				source
+			});
 			const invalidTree = invalidDocument(input.schema, document);
 			if (invalidTree) return {
 				status: "rejected",
 				issues: [at$1(invalidTree, "invalid-tree", "Document replacement contains an invalid tree.")],
 				revision
 			};
-			if (require_dependency.deepEqual(state.document, document)) return {
+			if (require_ownership.deepEqual(state.document, document)) return {
 				status: "unchanged",
 				revision
 			};
-			state.document = require_dependency.cloneValue(document, "replace");
+			state.document = require_ownership.cloneValue(document, "replace");
 			return publish({
 				status: "changed",
 				operations: EMPTY,
 				inverse: EMPTY,
 				paths: EMPTY,
 				collections: EMPTY
-			}, options?.source ?? "system", "replace", false);
+			}, source, "replace", false);
+		},
+		snapshot: () => {
+			if (state.disposed) throw new require_dependency.DocumentDisposedError();
+			return require_ownership.cloneValue(state.document, "snapshot");
 		},
 		subscribe: ((targetOrListener, listener) => {
 			if (state.disposed) throw new require_dependency.DocumentDisposedError();
@@ -2294,13 +2571,27 @@ const createDocument = (input) => {
 			state.disposed = true;
 			disposeNotification(notification);
 			history.api.clear();
+			require_driver.disposeRuntimeDriver(runtime);
 		}
 	};
 	require_dependency.bindRuntimeAccess(runtime, state);
+	require_driver.bindRuntimeDriver(runtime);
 	notification = createNotification(runtime);
 	return runtime;
 };
 //#endregion
+//#region core/src/runtime/readable.ts
+const asReadable = (runtime) => {
+	const readable = {
+		address: runtime.address,
+		revision: runtime.revision,
+		subscribe: runtime.subscribe
+	};
+	require_dependency.bindRuntimeAccess(readable, require_dependency.accessOf(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
@@ -2318,7 +2609,7 @@ const createCollectionView = (input) => {
 		shape: {}
 	};
 	const mapEntry = (document, id) => {
-		require_dependency.profile.collectionView.mapped();
+		require_ownership.profile.collectionView.mapped();
 		const address = [...input.source.address, String(id)];
 		let active = true;
 		try {
@@ -2334,7 +2625,7 @@ const createCollectionView = (input) => {
 		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_dependency.profile.collectionView.idsScanned(ids.length);
+		require_ownership.profile.collectionView.idsScanned(ids.length);
 		const values = previous && changed ? previous.values : /* @__PURE__ */ new Map();
 		if (previous && changed) {
 			const nextIds = new Set(ids);
@@ -2362,7 +2653,7 @@ const createCollectionView = (input) => {
 	let state = build();
 	const ensureAll = () => {
 		if (!state.allDirty && state.all) return state.all;
-		require_dependency.profile.collectionView.arrayCopied();
+		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);
@@ -2519,7 +2810,7 @@ const createMaterializedView = (runtime, spec) => {
 			entry.change = meta?.change;
 			if (commitRevision !== void 0 && meta?.changedRevision === commitRevision) {
 				sourceChanged = true;
-				require_dependency.profile.materialized.sourceChanged();
+				require_ownership.profile.materialized.sourceChanged();
 			}
 		}
 		return sourceValuesRecord;
@@ -2566,7 +2857,7 @@ const createMaterializedView = (runtime, spec) => {
 		});
 	};
 	const build = () => {
-		require_dependency.profile.materialized.rebuilt();
+		require_ownership.profile.materialized.rebuilt();
 		dependencies.clear();
 		let active = true;
 		try {
@@ -2583,7 +2874,7 @@ const createMaterializedView = (runtime, spec) => {
 	};
 	build();
 	const emit = () => {
-		require_dependency.profile.materialized.notification();
+		require_ownership.profile.materialized.notification();
 		Array.from(listeners).forEach((listener) => listener());
 	};
 	const process = (commit) => {
@@ -2597,13 +2888,13 @@ const createMaterializedView = (runtime, spec) => {
 			}
 			const sourceSnapshot = sourceValues(commit.revision);
 			if (!sourceChanged && dependencies.size() > 0 && !dependencies.some(commit.impact.affects)) {
-				require_dependency.profile.materialized.skipped();
+				require_ownership.profile.materialized.skipped();
 				revision = commit.revision;
 				writeMeta(void 0, currentValue, commit.revision, false);
 				return;
 			}
 			dependencies.clear();
-			require_dependency.profile.materialized.updated();
+			require_ownership.profile.materialized.updated();
 			let active = true;
 			let result;
 			try {
@@ -2687,13 +2978,17 @@ const createMaterializedView = (runtime, spec) => {
 //#endregion
 exports.DocumentDisposedError = require_dependency.DocumentDisposedError;
 exports.DocumentReentrancyError = require_dependency.DocumentReentrancyError;
+exports.asReadable = asReadable;
+exports.commandFootprint = commandFootprint;
 exports.contains = require_dependency.contains;
 exports.createCollectionView = createCollectionView;
 exports.createDocument = createDocument;
 exports.createMaterializedView = createMaterializedView;
 exports.debugKey = require_dependency.debugKey;
+exports.decodeCommandFootprint = decodeCommandFootprint;
 exports.dict = require_dependency.dict;
 exports.field = require_dependency.field;
+exports.footprintsOverlap = footprintsOverlap;
 exports.list = require_dependency.list;
 exports.map = require_dependency.map;
 exports.object = require_dependency.object;