doxum 0.1.2 → 0.1.3

package/dist/index.cjs

@@ -1,29 +1,2619 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_access = require("./access-z56fVqZ2.cjs");
-const require_readable = require("./readable-B8E3FMq6.cjs");
-const require_dependency = require("./dependency-DmQXyj7q.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",
+	added: /* @__PURE__ */ new Set(),
+	removed: /* @__PURE__ */ new Set(),
+	updated: /* @__PURE__ */ new Set(),
+	orderChanged: false
+});
+const resetCollectionImpact = Object.freeze({ kind: "reset" });
+const createImpact = (input) => {
+	const kind = input.reset ? "reset" : "incremental";
+	const paths = input.paths ?? input.operations.map((operation) => operation.at);
+	let pathBuckets;
+	const somePath = (address, test) => {
+		if (address.length === 0 || paths.length <= 8) return paths.some(test);
+		if (!pathBuckets) {
+			pathBuckets = /* @__PURE__ */ new Map();
+			for (const changed of paths) {
+				const first = changed[0];
+				const bucket = pathBuckets.get(first) ?? [];
+				bucket.push(changed);
+				pathBuckets.set(first, bucket);
+			}
+		}
+		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));
+	let collectionCache;
+	const findCollection = (address) => input.collections?.find((entry) => entry.address.length === address.length && entry.address.every((segment, index) => segment === address[index]));
+	return {
+		kind,
+		operations: input.operations,
+		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 (value.kind === "collection") {
+				const collection = findCollection(require_dependency.address(value));
+				if (!collection) return false;
+				const id$1 = require_dependency.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;
+			}
+			return false;
+		},
+		collection: (selector) => {
+			if (selector.schema !== input.schema) throw new Error("Collection selector belongs to another schema.");
+			if (kind === "reset") return resetCollectionImpact;
+			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)) {
+				const reset = { kind: "reset" };
+				(collectionCache ??= []).push({
+					address: selector.address,
+					value: reset
+				});
+				return reset;
+			}
+			if (!exact) {
+				const empty = emptyCollectionImpact;
+				(collectionCache ??= []).push({
+					address: selector.address,
+					value: empty
+				});
+				return empty;
+			}
+			const incremental = {
+				kind: "incremental",
+				added: exact.added,
+				removed: exact.removed,
+				updated: exact.updated,
+				orderChanged: exact.orderChanged
+			};
+			(collectionCache ??= []).push({
+				address: selector.address,
+				value: incremental
+			});
+			return incremental;
+		}
+	};
+};
+//#endregion
+//#region core/src/history.ts
+const createHistory = (input) => {
+	const undos = [];
+	const redos = [];
+	const listeners = /* @__PURE__ */ new Set();
+	let state = Object.freeze({
+		undoDepth: 0,
+		redoDepth: 0
+	});
+	const current = () => {
+		if (state.undoDepth !== undos.length || state.redoDepth !== redos.length) state = Object.freeze({
+			undoDepth: undos.length,
+			redoDepth: redos.length
+		});
+		return state;
+	};
+	const emit = () => {
+		if (listeners.size === 0) return;
+		current();
+		Array.from(listeners).forEach((listener) => listener());
+	};
+	const clear = () => {
+		if (undos.length || redos.length) {
+			undos.length = 0;
+			redos.length = 0;
+			emit();
+		}
+	};
+	return {
+		api: {
+			current,
+			subscribe: (listener) => {
+				listeners.add(listener);
+				return () => listeners.delete(listener);
+			},
+			undo: () => {
+				const entry = undos.pop();
+				if (!entry) return {
+					status: "unchanged",
+					revision: input.revision()
+				};
+				const result = input.apply(entry.inverse);
+				if (result.status === "committed") {
+					redos.push(entry);
+					emit();
+				} else undos.push(entry);
+				return result;
+			},
+			redo: () => {
+				const entry = redos.pop();
+				if (!entry) return {
+					status: "unchanged",
+					revision: input.revision()
+				};
+				const result = input.apply(entry.operations);
+				if (result.status === "committed") {
+					undos.push(entry);
+					emit();
+				} else redos.push(entry);
+				return result;
+			},
+			clear
+		},
+		record: (operations, inverse) => {
+			if (input.capacity <= 0) return;
+			undos.push({
+				operations,
+				inverse
+			});
+			if (undos.length > input.capacity) undos.shift();
+			redos.length = 0;
+			emit();
+		},
+		invalidate: clear
+	};
+};
+//#endregion
+//#region core/src/access/writer.ts
+const schemaRoot = (schema) => require_dependency.object(schema.shape);
+const emit = (sink, operation) => sink(operation);
+const writerFor = (node, inputAddress, sink) => {
+	const address = Object.freeze(inputAddress);
+	if (node.kind === "field") return {
+		set: (value) => emit(sink, {
+			type: "field.set",
+			at: address,
+			value
+		}),
+		clear: node.optional ? () => emit(sink, {
+			type: "field.clear",
+			at: address
+		}) : void 0
+	};
+	if (node.kind === "dict" || node.kind === "record") return {
+		set: (key, value) => emit(sink, {
+			type: "dict.set",
+			at: address,
+			key,
+			value
+		}),
+		delete: (key) => emit(sink, {
+			type: "dict.delete",
+			at: address,
+			key
+		}),
+		replace: (value) => emit(sink, {
+			type: "dict.replace",
+			at: address,
+			value
+		})
+	};
+	if (node.kind === "list") return {
+		insert: (value, anchor) => emit(sink, {
+			type: "list.insert",
+			at: address,
+			key: node.keyOf(value),
+			value,
+			anchor
+		}),
+		move: (key, anchor) => emit(sink, {
+			type: "list.move",
+			at: address,
+			key,
+			anchor
+		}),
+		remove: (key) => emit(sink, {
+			type: "list.remove",
+			at: address,
+			key
+		}),
+		replace: (value) => emit(sink, {
+			type: "list.replace",
+			at: address,
+			value,
+			keys: value.map(node.keyOf)
+		})
+	};
+	if (node.kind === "tree") return {
+		insert: (treeNodeId, value, parentId, index) => emit(sink, {
+			type: "tree.insert",
+			at: address,
+			treeNodeId,
+			value,
+			parentId,
+			index
+		}),
+		move: (treeNodeId, parentId, index) => emit(sink, {
+			type: "tree.move",
+			at: address,
+			treeNodeId,
+			parentId,
+			index
+		}),
+		remove: (treeNodeId) => emit(sink, {
+			type: "tree.remove",
+			at: address,
+			treeNodeId
+		}),
+		set: (treeNodeId, value) => emit(sink, {
+			type: "tree.set",
+			at: address,
+			treeNodeId,
+			value
+		}),
+		replace: (value) => emit(sink, {
+			type: "tree.replace",
+			at: address,
+			value
+		})
+	};
+	if (node.kind === "table") {
+		let items;
+		return {
+			create: (input, anchor) => {
+				emit(sink, {
+					type: "entity.create",
+					at: address,
+					entries: (Array.isArray(input) ? input : [input]).map(({ id, value }) => ({
+						id,
+						value
+					})),
+					anchor
+				});
+			},
+			item: (id) => {
+				const cached = items?.get(id);
+				if (cached) return cached;
+				const writer = writerFor(node.value, [...address, id], sink);
+				(items ??= /* @__PURE__ */ new Map()).set(id, writer);
+				return writer;
+			},
+			remove: (input) => emit(sink, {
+				type: "entity.remove",
+				at: address,
+				ids: Array.isArray(input) ? [...input] : [input]
+			}),
+			move: (id, anchor) => emit(sink, {
+				type: "entity.move",
+				at: address,
+				id,
+				anchor
+			})
+		};
+	}
+	if (node.kind === "map") {
+		let items;
+		return {
+			create: (input) => {
+				emit(sink, {
+					type: "entity.create",
+					at: address,
+					entries: (Array.isArray(input) ? input : [input]).map(({ id, value }) => ({
+						id,
+						value
+					}))
+				});
+			},
+			item: (id) => {
+				const cached = items?.get(id);
+				if (cached) return cached;
+				const writer = writerFor(node.value, [...address, id], sink);
+				(items ??= /* @__PURE__ */ new Map()).set(id, writer);
+				return writer;
+			},
+			remove: (input) => emit(sink, {
+				type: "entity.remove",
+				at: address,
+				ids: Array.isArray(input) ? [...input] : [input]
+			})
+		};
+	}
+	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
+	}) };
+	let children;
+	return new Proxy({}, { get: (_target, property) => {
+		if (typeof property !== "string" || !node.shape[property]) return void 0;
+		const cached = children?.get(property);
+		if (cached) return cached;
+		const writer = writerFor(node.shape[property], [...address, property], sink);
+		(children ??= /* @__PURE__ */ new Map()).set(property, writer);
+		return writer;
+	} });
+};
+const documentWriter = (schema, sink) => writerFor(schemaRoot(schema), [], sink);
+//#endregion
+//#region core/src/mutation/issue.ts
+const ownAddress$1 = (address) => Object.freeze(address.slice());
+const at$1 = (address, code, message, operation) => Object.freeze({
+	source: "mutation",
+	code,
+	address: ownAddress$1(address),
+	message,
+	...operation === void 0 ? {} : { operation }
+});
+const from = (operation, code, message) => at$1(operation.at, code, message, operation.type);
+const input = (code, message) => at$1([], code, message);
+//#endregion
+//#region core/src/mutation/anchor.ts
+const length = (keys) => keys.length;
+const keyAt = (keys, index) => Array.isArray(keys) ? keys[index] : keys.at(index);
+const keyIndex = (keys, key) => Array.isArray(keys) ? keys.indexOf(key) : keys.index(key);
+const keys = (values, keyOf) => ({
+	length: values.length,
+	at: (index) => index >= 0 && index < values.length ? keyOf(values[index]) : void 0,
+	index: (key) => {
+		for (let index = 0; index < values.length; index += 1) if (keyOf(values[index]) === key) return index;
+		return -1;
+	}
+});
+const index = (keys, anchor) => {
+	if (!anchor) return length(keys);
+	if ("at" in anchor) return anchor.at === "start" ? 0 : length(keys);
+	if ("before" in anchor) return keyIndex(keys, anchor.before);
+	return keyIndex(keys, anchor.after) + 1;
+};
+const at = (keys, position) => position <= 0 ? { at: "start" } : { after: keyAt(keys, position - 1) };
+const valid = (keys, anchor) => {
+	if (!anchor) return true;
+	if (typeof anchor !== "object" || anchor === null) return false;
+	if (Number("at" in anchor) + Number("before" in anchor) + Number("after" in anchor) !== 1) return false;
+	if ("at" in anchor) return anchor.at === "start" || anchor.at === "end";
+	return keyIndex(keys, "before" in anchor ? anchor.before : anchor.after) >= 0;
+};
+const afterRemove = (keys, removedIndex, anchor) => {
+	const position = index(keys, anchor);
+	return position > removedIndex ? position - 1 : position;
+};
+const validPositions = (length, positions) => {
+	let previous = -1;
+	for (let index = 0; index < positions.length; index += 1) {
+		const position = positions[index];
+		if (!Number.isInteger(position) || position < 0 || position <= previous || position > length + index) return false;
+		previous = position;
+	}
+	return true;
+};
+const restore = (keys, inserted, positions) => {
+	const currentLength = keys.length;
+	if (inserted.length !== positions.length || !validPositions(currentLength, positions)) throw new Error("Ordered restore positions are invalid.");
+	let readIndex = currentLength - 1;
+	let insertedIndex = inserted.length - 1;
+	keys.length = currentLength + inserted.length;
+	for (let writeIndex = keys.length - 1; writeIndex >= 0; writeIndex -= 1) if (insertedIndex >= 0 && positions[insertedIndex] === writeIndex) {
+		keys[writeIndex] = inserted[insertedIndex];
+		insertedIndex -= 1;
+	} else {
+		keys[writeIndex] = keys[readIndex];
+		readIndex -= 1;
+	}
+};
+//#endregion
+//#region core/src/mutation/execute-entity.ts
+const resolveEntityCollection = (node, value) => {
+	if (node.kind === "table") {
+		if (!require_ownership.isRecord(value) || !Array.isArray(value.ids) || !require_ownership.isRecord(value.byId)) return { status: "invalid" };
+		return {
+			status: "resolved",
+			collection: {
+				kind: "table",
+				ids: value.ids,
+				byId: value.byId
+			}
+		};
+	}
+	return require_ownership.isRecord(value) ? {
+		status: "resolved",
+		collection: {
+			kind: "map",
+			byId: value
+		}
+	} : { status: "invalid" };
+};
+const rejected$4 = (operation, code, message) => ({
+	status: "rejected",
+	issue: from(operation, code, message)
+});
+const executeEntity = (target, operation, copyPayload) => {
+	if (target.node.kind !== "table" && target.node.kind !== "map") return rejected$4(operation, "invalid-address", "Collection target is invalid.");
+	const resolution = resolveEntityCollection(target.node, target.value);
+	if (resolution.status === "invalid") return rejected$4(operation, "invalid-address", "Collection target is invalid.");
+	const collection = resolution.collection;
+	const ids = collection.kind === "table" ? collection.ids : void 0;
+	if (operation.type === "entity.move" && collection.kind === "map") return rejected$4(operation, "invalid-operation", "Map entries are unordered.");
+	const byId = collection.byId;
+	if (operation.type === "entity.create") {
+		if (operation.entries.length === 0) return { status: "unchanged" };
+		const seen = /* @__PURE__ */ new Set();
+		for (const entry of operation.entries) {
+			if (seen.has(entry.id)) return rejected$4(operation, "duplicate-entity", "Entity ids must be unique within a batch.");
+			seen.add(entry.id);
+			if (Object.prototype.hasOwnProperty.call(byId, entry.id)) return rejected$4(operation, "duplicate-entity", `Entity '${entry.id}' already exists.`);
+		}
+		if (collection.kind === "map" && (operation.anchor || operation.positions)) return rejected$4(operation, "invalid-anchor", "Map entries do not support ordering metadata.");
+		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_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 {
+			const insertion = index(ids, operation.anchor);
+			const currentLength = ids.length;
+			ids.length = currentLength + operation.entries.length;
+			for (let index = currentLength - 1; index >= insertion; index -= 1) ids[index + operation.entries.length] = ids[index];
+			for (let index = 0; index < operation.entries.length; index += 1) ids[insertion + index] = operation.entries[index].id;
+		}
+		return {
+			status: "changed",
+			inverse: [{
+				type: "entity.remove",
+				at: operation.at,
+				ids: operation.entries.map((entry) => entry.id)
+			}]
+		};
+	}
+	if (operation.type === "entity.remove") {
+		if (operation.ids.length === 0) return { status: "unchanged" };
+		const seen = /* @__PURE__ */ new Set();
+		for (const id of operation.ids) {
+			if (seen.has(id)) return rejected$4(operation, "duplicate-entity", "Entity ids must be unique within a batch.");
+			seen.add(id);
+			if (!Object.prototype.hasOwnProperty.call(byId, id)) return rejected$4(operation, "missing-entity", `Entity '${id}' does not exist.`);
+		}
+		const entries = [];
+		const positions = [];
+		if (ids) {
+			const positionsById = /* @__PURE__ */ new Map();
+			for (let index = 0; index < ids.length; index += 1) {
+				const id = ids[index];
+				if (seen.has(id)) positionsById.set(id, index);
+			}
+			for (const id of operation.ids) if (!positionsById.has(id)) return rejected$4(operation, "invalid-collection", `Collection index is missing '${id}'.`);
+			let writeIndex = 0;
+			for (let index = 0; index < ids.length; index += 1) {
+				const id = ids[index];
+				if (seen.has(id)) {
+					entries.push({
+						id,
+						value: require_ownership.cloneValue(byId[id], "inverse")
+					});
+					positions.push(index);
+					delete byId[id];
+				} else ids[writeIndex++] = id;
+			}
+			ids.length = writeIndex;
+		} else for (const id of operation.ids) {
+			entries.push({
+				id,
+				value: require_ownership.cloneValue(byId[id], "inverse")
+			});
+			delete byId[id];
+		}
+		return {
+			status: "changed",
+			inverse: [{
+				type: "entity.create",
+				at: operation.at,
+				entries,
+				...ids ? { positions } : {}
+			}]
+		};
+	}
+	const exists = Object.prototype.hasOwnProperty.call(byId, operation.id);
+	const position = ids?.indexOf(operation.id) ?? -1;
+	if (!exists) return rejected$4(operation, "missing-entity", `Entity '${operation.id}' does not exist.`);
+	if (!ids || position < 0) return rejected$4(operation, "invalid-collection", `Collection index is missing '${operation.id}'.`);
+	if (!valid(ids, operation.anchor)) return rejected$4(operation, "invalid-anchor", "Collection anchor is invalid.");
+	if (operation.anchor && ("before" in operation.anchor && operation.anchor.before === operation.id || "after" in operation.anchor && operation.anchor.after === operation.id)) return rejected$4(operation, "invalid-anchor", "An entity cannot be moved relative to itself.");
+	const nextIndex = afterRemove(ids, position, operation.anchor);
+	if (nextIndex === position) return { status: "unchanged" };
+	const inverse = {
+		type: "entity.move",
+		at: operation.at,
+		id: operation.id,
+		anchor: at(ids, position)
+	};
+	ids.splice(position, 1);
+	ids.splice(nextIndex, 0, operation.id);
+	return {
+		status: "changed",
+		inverse: [inverse]
+	};
+};
+//#endregion
+//#region core/src/mutation/execute-list.ts
+const rejected$3 = (operation, code, message) => ({
+	status: "rejected",
+	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;
+	const orderedKeys = keys(list, target.node.keyOf);
+	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();
+		for (let index = 0; index < operation.value.length; index += 1) {
+			const key = operation.keys[index];
+			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 = {
+			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];
+		return {
+			status: "changed",
+			inverse: [inverse]
+		};
+	}
+	if (operation.type === "list.insert") {
+		if (target.node.keyOf(operation.value) !== operation.key) return rejected$3(operation, "invalid-list-key", "List item key does not match schema.");
+		if (orderedKeys.index(operation.key) >= 0) return rejected$3(operation, "duplicate-list-item", `List item '${operation.key}' already exists.`);
+		if (!valid(orderedKeys, operation.anchor)) return rejected$3(operation, "invalid-anchor", "List anchor is invalid.");
+		list.splice(index(orderedKeys, operation.anchor), 0, own(operation.value));
+		return {
+			status: "changed",
+			inverse: [{
+				type: "list.remove",
+				at: operation.at,
+				key: operation.key
+			}]
+		};
+	}
+	const position = orderedKeys.index(operation.key);
+	if (position < 0) return rejected$3(operation, "missing-list-item", `List item '${operation.key}' does not exist.`);
+	if (operation.type === "list.remove") {
+		const inverse = {
+			type: "list.insert",
+			at: operation.at,
+			key: operation.key,
+			value: require_ownership.cloneValue(list[position], "inverse"),
+			anchor: at(orderedKeys, position)
+		};
+		list.splice(position, 1);
+		return {
+			status: "changed",
+			inverse: [inverse]
+		};
+	}
+	if (!valid(orderedKeys, operation.anchor)) return rejected$3(operation, "invalid-anchor", "List anchor is invalid.");
+	if (operation.anchor && ("before" in operation.anchor && operation.anchor.before === operation.key || "after" in operation.anchor && operation.anchor.after === operation.key)) return rejected$3(operation, "invalid-anchor", "A list item cannot be moved relative to itself.");
+	const nextIndex = afterRemove(orderedKeys, position, operation.anchor);
+	if (nextIndex === position) return { status: "unchanged" };
+	const inverse = {
+		type: "list.move",
+		at: operation.at,
+		key: operation.key,
+		anchor: at(orderedKeys, position)
+	};
+	const [entry] = list.splice(position, 1);
+	list.splice(nextIndex, 0, entry);
+	return {
+		status: "changed",
+		inverse: [inverse]
+	};
+};
+//#endregion
+//#region core/src/mutation/tree.ts
+const has$1 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const validIndex = (index) => index === void 0 || Number.isInteger(index) && index >= 0;
+const rejected$2 = (code, message) => ({
+	status: "rejected",
+	code,
+	message
+});
+const node = (tree, id) => tree.nodes[id];
+const childIndex = (parent, id) => parent.children.indexOf(id);
+const sameOrder$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;
+};
+const rootPresence = (id) => id === void 0 ? { status: "absent" } : {
+	status: "present",
+	id
+};
+const capture = (change, id, presence) => {
+	if (!change.nodes.has(id)) change.nodes.set(id, presence);
+};
+const without = (values, id) => {
+	const result = [];
+	for (const value of values) if (value !== id) result.push(value);
+	return result;
+};
+const inserted = (values, id, index) => {
+	const result = [...values];
+	result.splice(Math.min(index, result.length), 0, id);
+	return result;
+};
+const moved = (values, id, index) => {
+	const result = without(values, id);
+	result.splice(Math.min(index, result.length), 0, id);
+	return result;
+};
+const parentPresence = (tree, id, children) => {
+	const entry = node(tree, id);
+	return entry ? {
+		status: "present",
+		...entry.parentId === void 0 ? {} : { parentId: entry.parentId },
+		children,
+		value: entry.value
+	} : { status: "absent" };
+};
+const restoreIncremental = (value, change) => {
+	if (!is(value)) return value;
+	if (change.root.status === "absent") delete value.rootId;
+	else value.rootId = change.root.id;
+	for (const [id, before] of change.nodes) {
+		if (before.status === "absent") {
+			delete value.nodes[id];
+			continue;
+		}
+		value.nodes[id] = {
+			...before.parentId === void 0 ? {} : { parentId: before.parentId },
+			children: [...before.children],
+			value: before.value
+		};
+	}
+	return value;
+};
+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",
+		value: inverse.value
+	};
+	if (previous.mode === "whole") return previous;
+	return {
+		mode: "whole",
+		value: restoreIncremental(require_ownership.ownPayload(inverse.value, "journal"), previous)
+	};
+};
+const removedNodePresences = (inverses) => {
+	const children = /* @__PURE__ */ new Map();
+	for (const inverse of inverses) {
+		if (inverse.parentId === void 0) continue;
+		const entries = children.get(inverse.parentId);
+		const child = {
+			id: inverse.treeNodeId,
+			index: inverse.index ?? Number.MAX_SAFE_INTEGER
+		};
+		if (entries) entries.push(child);
+		else children.set(inverse.parentId, [child]);
+	}
+	const result = /* @__PURE__ */ new Map();
+	for (const inverse of inverses) {
+		const ordered = children.get(inverse.treeNodeId) ?? [];
+		ordered.sort((left, right) => left.index - right.index);
+		result.set(inverse.treeNodeId, {
+			status: "present",
+			...inverse.parentId === void 0 ? {} : { parentId: inverse.parentId },
+			children: ordered.map((entry) => entry.id),
+			value: inverse.value
+		});
+	}
+	return result;
+};
+const recordChange = (previous, current, forward, inverses) => {
+	const replacement = inverses[0];
+	if (replacement?.type === "tree.replace") return wholeChange(replacement, previous);
+	if (previous?.mode === "whole") return previous;
+	const change = previous ?? {
+		mode: "incremental",
+		root: forward.type === "tree.insert" && forward.parentId === void 0 ? { status: "absent" } : forward.type === "tree.remove" && inverses[0]?.type === "tree.insert" ? rootPresence(inverses[0].parentId === void 0 ? inverses[0].treeNodeId : current.rootId) : rootPresence(current.rootId),
+		nodes: /* @__PURE__ */ new Map()
+	};
+	if (forward.type === "tree.insert") {
+		capture(change, forward.treeNodeId, { status: "absent" });
+		if (forward.parentId !== void 0) {
+			const parentNode = node(current, forward.parentId);
+			if (parentNode) capture(change, forward.parentId, parentPresence(current, forward.parentId, without(parentNode.children, forward.treeNodeId)));
+		}
+		return change;
+	}
+	if (forward.type === "tree.remove") {
+		const inserts = inverses.filter((inverse) => inverse.type === "tree.insert");
+		const removed = removedNodePresences(inserts);
+		for (const [id, presence] of removed) capture(change, id, presence);
+		const first = inserts[0];
+		if (first?.parentId !== void 0) {
+			const parentNode = node(current, first.parentId);
+			if (parentNode) capture(change, first.parentId, parentPresence(current, first.parentId, inserted(parentNode.children, first.treeNodeId, first.index ?? parentNode.children.length)));
+		}
+		return change;
+	}
+	if (forward.type === "tree.set") {
+		const inverse = inverses[0];
+		const entry = node(current, forward.treeNodeId);
+		if (entry && inverse?.type === "tree.set") capture(change, forward.treeNodeId, {
+			status: "present",
+			...entry.parentId === void 0 ? {} : { parentId: entry.parentId },
+			children: [...entry.children],
+			value: inverse.value
+		});
+		return change;
+	}
+	if (forward.type === "tree.move") {
+		const inverse = inverses[0];
+		const entry = node(current, forward.treeNodeId);
+		if (!entry || inverse?.type !== "tree.move" || inverse.parentId === void 0) return change;
+		capture(change, forward.treeNodeId, {
+			status: "present",
+			parentId: inverse.parentId,
+			children: [...entry.children],
+			value: entry.value
+		});
+		const oldParent = node(current, inverse.parentId);
+		if (oldParent) {
+			const children = inverse.parentId === forward.parentId ? moved(oldParent.children, forward.treeNodeId, inverse.index ?? oldParent.children.length) : inserted(oldParent.children, forward.treeNodeId, inverse.index ?? oldParent.children.length);
+			capture(change, inverse.parentId, parentPresence(current, inverse.parentId, children));
+		}
+		if (forward.parentId !== void 0 && forward.parentId !== inverse.parentId) {
+			const nextParent = node(current, forward.parentId);
+			if (nextParent) capture(change, forward.parentId, parentPresence(current, forward.parentId, without(nextParent.children, forward.treeNodeId)));
+		}
+	}
+	return change;
+};
+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_ownership.sameStructuralValue(before.value, value.value);
+};
+const changeChanged = (change, 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_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;
+	const ids = Object.keys(value.nodes);
+	if (ids.length === 0) return value.rootId === void 0;
+	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_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) {
+			if (entry.parentId !== void 0) return false;
+		} else if (entry.parentId === void 0 || !has$1(value.nodes, entry.parentId)) return false;
+		for (const child of entry.children) {
+			const childNode = value.nodes[child];
+			if (!childNode || childNode.parentId !== id) return false;
+		}
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [value.rootId];
+	while (stack.length) {
+		const id = stack.pop();
+		if (seen.has(id)) return false;
+		seen.add(id);
+		const entry = value.nodes[id];
+		if (!entry) return false;
+		for (const child of entry.children) stack.push(child);
+	}
+	return seen.size === ids.length;
+};
+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_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;
+		}
+		return;
+	}
+	if (node.kind === "single") return documentTreeError(node.value, value, address);
+	if (node.kind === "variant") {
+		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_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;
+		}
+		return;
+	}
+	if (node.kind === "map") {
+		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;
+		}
+	}
+};
+const invalidDocument = (schema, value) => documentTreeError({
+	kind: "object",
+	shape: schema.shape
+}, value, []);
+const replace = (current, operation) => {
+	if (!validate(operation.value)) return rejected$2("invalid-tree", "Tree replacement is malformed.");
+	if (require_ownership.sameStructuralValue(current, operation.value)) return { status: "unchanged" };
+	return {
+		status: "changed",
+		inverse: [{
+			type: "tree.replace",
+			at: operation.at,
+			value: require_ownership.cloneValue(current, "inverse")
+		}]
+	};
+};
+const insert = (tree, operation, value) => {
+	if (contains$1(tree, operation.treeNodeId)) return rejected$2("duplicate-tree-node", `Tree node '${operation.treeNodeId}' already exists.`);
+	if (!validIndex(operation.index)) return rejected$2("invalid-tree-index", "Tree index is invalid.");
+	if (tree.rootId === void 0) {
+		if (operation.parentId !== void 0) return rejected$2("missing-tree-parent", `Tree parent '${operation.parentId}' does not exist.`);
+		tree.nodes[operation.treeNodeId] = {
+			children: [],
+			value
+		};
+		tree.rootId = operation.treeNodeId;
+	} else {
+		if (operation.parentId === void 0) return rejected$2("invalid-tree", "A non-empty tree has exactly one root.");
+		const parentNode = node(tree, operation.parentId);
+		if (!parentNode) return rejected$2("missing-tree-parent", `Tree parent '${operation.parentId}' does not exist.`);
+		tree.nodes[operation.treeNodeId] = {
+			parentId: operation.parentId,
+			children: [],
+			value
+		};
+		parentNode.children.splice(Math.min(operation.index ?? parentNode.children.length, parentNode.children.length), 0, operation.treeNodeId);
+	}
+	return {
+		status: "changed",
+		inverse: [{
+			type: "tree.remove",
+			at: operation.at,
+			treeNodeId: operation.treeNodeId
+		}]
+	};
+};
+const set = (tree, operation, value) => {
+	const entry = node(tree, operation.treeNodeId);
+	if (!entry) return rejected$2("missing-tree-node", `Tree node '${operation.treeNodeId}' does not exist.`);
+	if (Object.is(entry.value, value)) return { status: "unchanged" };
+	const inverse = {
+		type: "tree.set",
+		at: operation.at,
+		treeNodeId: operation.treeNodeId,
+		value: require_ownership.cloneValue(entry.value, "inverse")
+	};
+	entry.value = value;
+	return {
+		status: "changed",
+		inverse: [inverse]
+	};
+};
+const remove = (tree, operation) => {
+	const first = node(tree, operation.treeNodeId);
+	if (!first) return rejected$2("missing-tree-node", `Tree node '${operation.treeNodeId}' does not exist.`);
+	const parentId = first.parentId;
+	const parentNode = parentId === void 0 ? void 0 : node(tree, parentId);
+	const originalIndex = parentNode ? childIndex(parentNode, operation.treeNodeId) : 0;
+	if (parentId !== void 0 && (!parentNode || originalIndex < 0) || parentId === void 0 && tree.rootId !== operation.treeNodeId) return rejected$2("invalid-tree", "Tree parent links are inconsistent.");
+	const entries = [];
+	const seen = /* @__PURE__ */ new Set();
+	const stack = [{
+		id: operation.treeNodeId,
+		parentId,
+		index: originalIndex
+	}];
+	while (stack.length) {
+		const frame = stack.pop();
+		const entry = node(tree, frame.id);
+		if (!entry || seen.has(frame.id) || entry.parentId !== frame.parentId) return rejected$2("invalid-tree", "Tree contains an invalid descendant.");
+		seen.add(frame.id);
+		entries.push({
+			id: frame.id,
+			parentId: frame.parentId,
+			index: frame.index,
+			value: require_ownership.cloneValue(entry.value, "inverse")
+		});
+		for (let index = entry.children.length - 1; index >= 0; index -= 1) {
+			const childId = entry.children[index];
+			const child = node(tree, childId);
+			if (!child || child.parentId !== frame.id) return rejected$2("invalid-tree", "Tree child links are inconsistent.");
+			stack.push({
+				id: childId,
+				parentId: frame.id,
+				index
+			});
+		}
+	}
+	if (parentNode) parentNode.children.splice(originalIndex, 1);
+	for (let index = entries.length - 1; index >= 0; index -= 1) delete tree.nodes[entries[index].id];
+	if (tree.rootId === operation.treeNodeId) delete tree.rootId;
+	return {
+		status: "changed",
+		inverse: entries.map((entry) => ({
+			type: "tree.insert",
+			at: operation.at,
+			treeNodeId: entry.id,
+			...entry.parentId === void 0 ? {} : { parentId: entry.parentId },
+			index: entry.index,
+			value: entry.value
+		}))
+	};
+};
+const move = (tree, operation) => {
+	const entry = node(tree, operation.treeNodeId);
+	if (!entry) return rejected$2("missing-tree-node", `Tree node '${operation.treeNodeId}' does not exist.`);
+	if (!validIndex(operation.index)) return rejected$2("invalid-tree-index", "Tree index is invalid.");
+	if (tree.rootId === operation.treeNodeId) return rejected$2("invalid-tree", "The root cannot be moved.");
+	if (operation.parentId === void 0) return rejected$2("invalid-tree", "Only the root can have no parent.");
+	const nextParent = node(tree, operation.parentId);
+	if (!nextParent) return rejected$2("missing-tree-parent", `Tree parent '${operation.parentId}' does not exist.`);
+	if (operation.parentId === operation.treeNodeId) return rejected$2("tree-cycle", "A tree node cannot parent itself.");
+	const descendants = [operation.treeNodeId];
+	const seen = /* @__PURE__ */ new Set();
+	while (descendants.length) {
+		const id = descendants.pop();
+		if (seen.has(id)) return rejected$2("invalid-tree", "Tree contains a cycle.");
+		seen.add(id);
+		const current = node(tree, id);
+		if (!current) return rejected$2("invalid-tree", "Tree contains a missing node.");
+		for (const childId of current.children) {
+			const child = node(tree, childId);
+			if (!child || child.parentId !== id) return rejected$2("invalid-tree", "Tree child links are inconsistent.");
+			if (childId === operation.parentId) return rejected$2("tree-cycle", "Tree move would create a cycle.");
+			descendants.push(childId);
+		}
+	}
+	const parentId = entry.parentId;
+	const currentParent = parentId === void 0 ? void 0 : node(tree, parentId);
+	if (!currentParent || parentId === void 0) return rejected$2("invalid-tree", "Tree parent links are inconsistent.");
+	const originalIndex = childIndex(currentParent, operation.treeNodeId);
+	if (originalIndex < 0) return rejected$2("invalid-tree", "Tree parent links are inconsistent.");
+	let nextIndex = Math.min(operation.index ?? nextParent.children.length, nextParent.children.length);
+	currentParent.children.splice(originalIndex, 1);
+	if (parentId === operation.parentId && nextIndex > originalIndex) nextIndex -= 1;
+	if (parentId === operation.parentId && nextIndex === originalIndex) {
+		currentParent.children.splice(originalIndex, 0, operation.treeNodeId);
+		return { status: "unchanged" };
+	}
+	nextParent.children.splice(nextIndex, 0, operation.treeNodeId);
+	entry.parentId = operation.parentId;
+	return {
+		status: "changed",
+		inverse: [{
+			type: "tree.move",
+			at: operation.at,
+			treeNodeId: operation.treeNodeId,
+			parentId,
+			index: originalIndex
+		}]
+	};
+};
+//#endregion
+//#region core/src/mutation/execute-tree.ts
+const outcome = (operation, value) => value.status === "rejected" ? {
+	status: "rejected",
+	issue: from(operation, value.code, value.message)
+} : value;
+const executeTree = (root, target, operation, copyPayload) => {
+	if (!is(target.value)) return {
+		status: "rejected",
+		issue: from(operation, "invalid-address", "Tree target is invalid.")
+	};
+	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_ownership.ownPayload(operation.value));
+		return outcome(operation, result);
+	}
+	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));
+	return outcome(operation, move(target.value, operation));
+};
+//#endregion
+//#region core/src/mutation/execute-value.ts
+const rejected$1 = (operation, code, message) => ({
+	status: "rejected",
+	issue: from(operation, code, message)
+});
+const executeValue = (target, operation, copyPayload) => {
+	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") {
+			if (target.node.kind !== "field" || !target.node.optional) return rejected$1(operation, "required-field", "Only optional fields can be cleared.");
+			if (!existed) return { status: "unchanged" };
+			const inverse = {
+				type: "field.set",
+				at: operation.at,
+				value: target.value
+			};
+			delete target.parent[target.key];
+			return {
+				status: "changed",
+				inverse: [inverse]
+			};
+		}
+		if (existed && Object.is(target.value, operation.value)) return { status: "unchanged" };
+		const inverse = existed ? {
+			type: "field.set",
+			at: operation.at,
+			value: target.value
+		} : {
+			type: "field.clear",
+			at: operation.at
+		};
+		target.parent[target.key] = operation.value;
+		return {
+			status: "changed",
+			inverse: [inverse]
+		};
+	}
+	if (operation.type === "variant.replace") {
+		if (require_ownership.sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
+		const inverse = {
+			type: "variant.replace",
+			at: operation.at,
+			value: require_ownership.ownPayload(target.value, "inverse")
+		};
+		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" };
+		const inverse = {
+			type: "dict.replace",
+			at: operation.at,
+			value: require_ownership.cloneValue(target.value, "inverse")
+		};
+		target.parent[target.key] = own(operation.value);
+		return {
+			status: "changed",
+			inverse: [inverse]
+		};
+	}
+	const existed = Object.prototype.hasOwnProperty.call(target.value, operation.key);
+	if (operation.type === "dict.delete") {
+		if (!existed) return { status: "unchanged" };
+		const inverse = {
+			type: "dict.set",
+			at: operation.at,
+			key: operation.key,
+			value: target.value[operation.key]
+		};
+		delete target.value[operation.key];
+		return {
+			status: "changed",
+			inverse: [inverse]
+		};
+	}
+	if (existed && Object.is(target.value[operation.key], operation.value)) return { status: "unchanged" };
+	const inverse = existed ? {
+		type: "dict.set",
+		at: operation.at,
+		key: operation.key,
+		value: target.value[operation.key]
+	} : {
+		type: "dict.delete",
+		at: operation.at,
+		key: operation.key
+	};
+	target.value[operation.key] = operation.value;
+	return {
+		status: "changed",
+		inverse: [inverse]
+	};
+};
+//#endregion
+//#region core/src/mutation/execute.ts
+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 === "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);
+	if (operation.type === "entity.create" || operation.type === "entity.remove" || operation.type === "entity.move") return !target || target.node.kind !== "table" && target.node.kind !== "map" ? invalidTarget(operation) : executeEntity(target, operation, copyPayload);
+	if (operation.type === "list.insert" || operation.type === "list.move" || operation.type === "list.remove" || operation.type === "list.replace") return !target || target.node.kind !== "list" ? invalidTarget(operation) : executeList(target, operation, copyPayload);
+	if (operation.type === "tree.insert" || operation.type === "tree.move" || operation.type === "tree.remove" || operation.type === "tree.set" || operation.type === "tree.replace") return !target || target.node.kind !== "tree" ? invalidTarget(operation) : executeTree(root, target, operation, copyPayload);
+	return {
+		status: "rejected",
+		issue: from(operation, "unknown-operation", "Unknown document operation.")
+	};
+};
+//#endregion
+//#region core/src/mutation/journal.ts
+const indexNode = () => ({ children: /* @__PURE__ */ new Map() });
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+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;
+};
+const sameOrder = (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;
+};
+const replaceArray = (target, value) => {
+	target.length = value.length;
+	for (let index = 0; index < value.length; index += 1) target[index] = value[index];
+};
+const present = (value) => ({
+	status: "present",
+	value
+});
+const absent = Object.freeze({ status: "absent" });
+const inverseMismatch = (operation) => {
+	throw new Error(`Mutation inverse does not match '${operation.type}'.`);
+};
+const ownsDescendant = (subject, address) => {
+	if (subject.address.length >= address.length) return false;
+	if (subject.kind === "variant") return true;
+	if (subject.kind !== "entity") return false;
+	return subject.entries.has(address[subject.address.length]);
+};
+const nodeAt = (root, address) => {
+	let node = root;
+	for (const segment of address) {
+		node = node.children.get(segment);
+		if (!node) return void 0;
+	}
+	return node;
+};
+const indexedSubjects = (root, address) => {
+	const start = nodeAt(root, address);
+	if (!start) return [];
+	const subjects = [];
+	const stack = [start];
+	while (stack.length) {
+		const node = stack.pop();
+		if (!node) break;
+		if (node.subject) subjects.push(node.subject);
+		for (const child of node.children.values()) stack.push(child);
+	}
+	return subjects;
+};
+const writePresence = (root, address, before) => {
+	const target = require_dependency.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);
+	if (!target) return;
+	target.parent[target.key] = value;
+};
+const restoreDict = (value, state) => {
+	if (state.mode === "whole") {
+		for (const key of Object.keys(value)) delete value[key];
+		for (const [key, entry] of Object.entries(state.value)) value[key] = entry;
+		return;
+	}
+	for (const [key, before] of state.entries) if (before.status === "present") value[key] = before.value;
+	else delete value[key];
+};
+const restoreList = (value, subject) => {
+	if (subject.state.mode === "whole") {
+		replaceArray(value, subject.state.value);
+		return;
+	}
+	const entries = /* @__PURE__ */ new Map();
+	for (const entry of value) entries.set(subject.node.keyOf(entry), entry);
+	for (const [key, before] of subject.state.items) if (before.status === "present") entries.set(key, before.value);
+	else entries.delete(key);
+	const restored = new Array(subject.state.order.length);
+	for (let index = 0; index < subject.state.order.length; index += 1) restored[index] = entries.get(subject.state.order[index]);
+	replaceArray(value, restored);
+};
+const entityCollection = (subject, value) => resolveEntityCollection(subject.node, value);
+const restoreEntity = (value, subject) => {
+	const resolution = entityCollection(subject, value);
+	if (resolution.status === "invalid") return;
+	const collection = resolution.collection;
+	for (const [id, before] of subject.entries) if (before.status === "present") collection.byId[id] = before.value;
+	else delete collection.byId[id];
+	if (collection.kind !== "table") return;
+	if (subject.order.kind === "tracked") {
+		replaceArray(collection.ids, subject.order.before);
+		return;
+	}
+	if (subject.order.kind === "stable") restoreEntityOrder(collection.ids, subject.order.inverses);
+};
+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_ownership.isRecord(value)) restoreDict(value, subject.state);
+		return value;
+	}
+	if (subject.kind === "entity") {
+		restoreEntity(value, subject);
+		return value;
+	}
+	if (subject.kind === "list") {
+		if (Array.isArray(value)) restoreList(value, subject);
+		return value;
+	}
+	return restoreChange(value, subject.state);
+};
+const restoreSubject = (value, prefix, 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);
+		return value;
+	}
+	if (subject.kind === "variant") {
+		writeContainer(value, address, subject.before);
+		return value;
+	}
+	const current = require_dependency.read(value, address);
+	if (subject.kind === "dict") {
+		if (require_ownership.isRecord(current)) restoreDict(current, subject.state);
+		return value;
+	}
+	if (subject.kind === "entity") {
+		restoreEntity(current, subject);
+		return value;
+	}
+	if (subject.kind === "list") {
+		if (Array.isArray(current)) restoreList(current, subject);
+		return value;
+	}
+	const restored = restoreChange(current, subject.state);
+	if (restored !== current) writeContainer(value, address, restored);
+	return value;
+};
+const valueChanged = (root, subject) => {
+	const target = require_dependency.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);
+	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;
+	}
+	return false;
+};
+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_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) {
+		const key = subject.node.keyOf(value[index]);
+		order[index] = key;
+		positions.set(key, index);
+	}
+	if (!sameOrder(subject.state.order, order)) return true;
+	for (const [key, before] of subject.state.items) {
+		const position = positions.get(key);
+		if (before.status === "absent") {
+			if (position !== void 0) return true;
+		} else if (position === void 0 || !require_ownership.sameStructuralValue(before.value, value[position])) return true;
+	}
+	return false;
+};
+const commonOrderChanged = (before, after) => {
+	const finalPositions = /* @__PURE__ */ new Map();
+	for (let index = 0; index < after.length; index += 1) finalPositions.set(after[index], index);
+	let previous = -1;
+	for (const id of before) {
+		const position = finalPositions.get(id);
+		if (position === void 0) continue;
+		if (position < previous) return true;
+		previous = position;
+	}
+	return false;
+};
+const analyzeEntity = (root, subject) => {
+	const resolution = entityCollection(subject, require_dependency.read(root, subject.address));
+	const added = /* @__PURE__ */ new Set();
+	const removed = /* @__PURE__ */ new Set();
+	const updated = /* @__PURE__ */ new Set();
+	if (resolution.status === "invalid") return {
+		changed: true,
+		added,
+		removed,
+		updated,
+		orderChanged: false
+	};
+	const collection = resolution.collection;
+	for (const [id, before] of subject.entries) {
+		const exists = hasOwn(collection.byId, id);
+		if (before.status === "absent") {
+			if (exists) added.add(id);
+		} else if (!exists) removed.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 : [];
+	const netOrderChanged = beforeOrder !== void 0 && !sameOrder(beforeOrder, finalOrder);
+	return {
+		changed: added.size > 0 || removed.size > 0 || updated.size > 0 || netOrderChanged,
+		added,
+		removed,
+		updated,
+		orderChanged: beforeOrder !== void 0 && commonOrderChanged(beforeOrder, finalOrder)
+	};
+};
+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 === "dict") return dictChanged(root, subject);
+	if (subject.kind === "list") return listChanged(root, subject);
+	return changeChanged(subject.state, require_dependency.read(root, subject.address));
+};
+const listOrderBefore = (value, node, inverse) => {
+	const order = value.map(node.keyOf);
+	if (inverse.type === "list.remove") return order.filter((key) => key !== inverse.key);
+	if (inverse.type === "list.insert") {
+		order.splice(index(order, inverse.anchor), 0, inverse.key);
+		return order;
+	}
+	if (inverse.type === "list.move") {
+		const position = order.indexOf(inverse.key);
+		if (position >= 0) order.splice(position, 1);
+		order.splice(index(order, inverse.anchor), 0, inverse.key);
+	}
+	return order;
+};
+const recordListPresence = (state, inverse) => {
+	if (inverse.type === "list.remove" && !state.items.has(inverse.key)) state.items.set(inverse.key, absent);
+	else if (inverse.type === "list.insert" && !state.items.has(inverse.key)) state.items.set(inverse.key, present(inverse.value));
+};
+const entityOrderInverse = (operation, inverse) => {
+	if (inverse.type === "entity.remove") return {
+		kind: "remove",
+		ids: inverse.ids
+	};
+	if (inverse.type === "entity.create") {
+		if (!inverse.positions || inverse.positions.length !== inverse.entries.length) return inverseMismatch(operation);
+		return {
+			kind: "restore",
+			ids: inverse.entries.map((entry) => entry.id),
+			positions: inverse.positions
+		};
+	}
+	if (inverse.type === "entity.move") return {
+		kind: "move",
+		id: inverse.id,
+		...inverse.anchor ? { anchor: inverse.anchor } : {}
+	};
+	return inverseMismatch(operation);
+};
+const removeEntityIds = (order, ids) => {
+	const removed = new Set(ids);
+	let writeIndex = 0;
+	for (const id of order) if (!removed.has(id)) order[writeIndex++] = id;
+	order.length = writeIndex;
+};
+const restoreEntityOrder = (order, inverses) => {
+	for (let index = inverses.length - 1; index >= 0; index -= 1) {
+		const inverse = inverses[index];
+		if (inverse.kind === "remove") {
+			removeEntityIds(order, inverse.ids);
+			continue;
+		}
+		if (inverse.kind === "restore") {
+			restore(order, inverse.ids, inverse.positions);
+			continue;
+		}
+		const position = order.indexOf(inverse.id);
+		if (position < 0 || !valid(order, inverse.anchor)) throw new Error(`Entity order inverse cannot restore '${inverse.id}'.`);
+		const nextIndex = afterRemove(order, position, inverse.anchor);
+		order.splice(position, 1);
+		order.splice(nextIndex, 0, inverse.id);
+	}
+};
+const treeOperation = (operation) => operation.type.startsWith("tree.");
+const createChangeJournal = (root) => {
+	const active = /* @__PURE__ */ new Set();
+	const index = indexNode();
+	const buckets = /* @__PURE__ */ new Map();
+	const add = (subject) => {
+		active.add(subject);
+		const candidates = buckets.get(subject.addressHash);
+		if (candidates) candidates.push(subject);
+		else buckets.set(subject.addressHash, [subject]);
+		let node = index;
+		for (const segment of subject.address) {
+			const existing = node.children.get(segment);
+			if (existing) node = existing;
+			else {
+				const created = indexNode();
+				node.children.set(segment, created);
+				node = created;
+			}
+		}
+		if (node.subject) throw new Error(`Change journal already owns '${subject.address.join(".")}'.`);
+		node.subject = subject;
+		require_ownership.profile.journal.subject();
+		return subject;
+	};
+	const remove = (subject) => {
+		if (!active.delete(subject)) return;
+		const candidates = buckets.get(subject.addressHash);
+		if (candidates) {
+			const position = candidates.indexOf(subject);
+			if (position >= 0) candidates.splice(position, 1);
+			if (candidates.length === 0) buckets.delete(subject.addressHash);
+		}
+		const nodes = [index];
+		let node = index;
+		for (const segment of subject.address) {
+			const child = node.children.get(segment);
+			if (!child) return;
+			nodes.push(child);
+			node = child;
+		}
+		if (node.subject === subject) delete node.subject;
+		for (let position = subject.address.length - 1; position >= 0; position -= 1) {
+			const child = nodes[position + 1];
+			if (child.subject || child.children.size > 0) break;
+			nodes[position].children.delete(subject.address[position]);
+		}
+	};
+	function find(kind, address, addressHash) {
+		const candidates = buckets.get(addressHash) ?? [];
+		for (const subject of candidates) {
+			require_ownership.profile.journal.comparison();
+			if (subject.kind === kind && sameAddress$1(subject.address, address)) return subject;
+		}
+	}
+	const ownerOf = (address) => {
+		let node = index;
+		for (let position = 0; position < address.length; position += 1) {
+			if (node.subject && ownsDescendant(node.subject, address)) return node.subject;
+			const child = node.children.get(address[position]);
+			if (!child) return void 0;
+			node = child;
+		}
+	};
+	const absorb = (value, address) => {
+		const subjects = indexedSubjects(index, address);
+		if (subjects.length === 0) return value;
+		subjects.sort((left, right) => left.address.length - right.address.length);
+		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_ownership.profile.journal.absorbed();
+		}
+		return before;
+	};
+	const base = (resolved, operation) => ({
+		address: operation.at,
+		addressHash: resolved.addressHash,
+		...resolved.collection ? { collection: resolved.collection } : {}
+	});
+	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);
+		add({
+			...base(resolved, operation),
+			kind: "value",
+			before: first.type === "field.set" ? present(first.value) : absent
+		});
+	};
+	const recordVariant = (resolved, operation, inverse) => {
+		if (find("variant", operation.at, resolved.addressHash)) return;
+		const first = inverse[0];
+		if (first?.type !== "variant.replace") return inverseMismatch(operation);
+		add({
+			...base(resolved, operation),
+			kind: "variant",
+			before: absorb(first.value, operation.at)
+		});
+	};
+	const recordDict = (resolved, operation, inverse) => {
+		const first = inverse[0];
+		if (!first) return inverseMismatch(operation);
+		const subject = find("dict", operation.at, resolved.addressHash) ?? add({
+			...base(resolved, operation),
+			kind: "dict",
+			state: {
+				mode: "incremental",
+				entries: /* @__PURE__ */ new Map()
+			}
+		});
+		if (subject.state.mode === "whole") return;
+		if (first.type === "dict.replace") {
+			const value = require_ownership.ownPayload(first.value, "journal");
+			restoreDict(value, subject.state);
+			subject.state = {
+				mode: "whole",
+				value
+			};
+			return;
+		}
+		if (first.type !== "dict.set" && first.type !== "dict.delete") return inverseMismatch(operation);
+		if (!subject.state.entries.has(first.key)) subject.state.entries.set(first.key, first.type === "dict.set" ? present(first.value) : absent);
+	};
+	const recordList = (resolved, operation, inverse) => {
+		if (resolved.node.kind !== "list") return inverseMismatch(operation);
+		const first = inverse[0];
+		if (!first) return inverseMismatch(operation);
+		let subject = find("list", operation.at, resolved.addressHash);
+		if (!subject) {
+			if (first.type === "list.replace") {
+				add({
+					...base(resolved, operation),
+					kind: "list",
+					node: resolved.node,
+					state: {
+						mode: "whole",
+						value: first.value
+					}
+				});
+				return;
+			}
+			const value = require_dependency.read(root, operation.at);
+			if (!Array.isArray(value)) return inverseMismatch(operation);
+			subject = add({
+				...base(resolved, operation),
+				kind: "list",
+				node: resolved.node,
+				state: {
+					mode: "incremental",
+					items: /* @__PURE__ */ new Map(),
+					order: listOrderBefore(value, resolved.node, first)
+				}
+			});
+		}
+		if (subject.state.mode === "whole") return;
+		if (first.type === "list.replace") {
+			const value = Array.from(require_ownership.ownPayload(first.value, "journal"));
+			restoreList(value, subject);
+			subject.state = {
+				mode: "whole",
+				value
+			};
+			return;
+		}
+		if (first.type !== "list.insert" && first.type !== "list.move" && first.type !== "list.remove") return inverseMismatch(operation);
+		recordListPresence(subject.state, first);
+	};
+	const trackEntityOrder = (subject, collection) => {
+		if (subject.order.kind !== "stable") return;
+		require_ownership.profile.journal.orderSnapshot(collection.ids.length);
+		const before = [...collection.ids];
+		restoreEntityOrder(before, subject.order.inverses);
+		subject.order = {
+			kind: "tracked",
+			before
+		};
+	};
+	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));
+		if (resolution.status === "invalid") return inverseMismatch(operation);
+		const collection = resolution.collection;
+		const subject = find("entity", operation.at, resolved.addressHash) ?? add({
+			...base(resolved, operation),
+			kind: "entity",
+			node: resolved.node,
+			entries: /* @__PURE__ */ new Map(),
+			order: collection.kind === "table" ? {
+				kind: "stable",
+				inverses: []
+			} : { kind: "unordered" }
+		});
+		const first = inverse[0];
+		if (!first) return inverseMismatch(operation);
+		if (collection.kind === "table" && subject.order.kind === "stable") subject.order.inverses.push(entityOrderInverse(operation, first));
+		if (first.type === "entity.remove") {
+			for (const id of first.ids) if (!subject.entries.has(id)) subject.entries.set(id, absent);
+			if (collection.kind === "table" && first.ids.some((id) => subject.entries.get(id)?.status === "present")) trackEntityOrder(subject, collection);
+			return;
+		}
+		if (first.type === "entity.create") {
+			for (const entry of first.entries) {
+				if (subject.entries.has(entry.id)) continue;
+				const address = [...operation.at, entry.id];
+				subject.entries.set(entry.id, present(absorb(entry.value, address)));
+			}
+			return;
+		}
+		if (first.type === "entity.move") {
+			if (collection.kind === "table" && subject.entries.get(first.id)?.status !== "absent") trackEntityOrder(subject, collection);
+			return;
+		}
+		return inverseMismatch(operation);
+	};
+	const recordTree = (resolved, operation, inverse) => {
+		const current = require_dependency.read(root, operation.at);
+		if (!is(current)) return inverseMismatch(operation);
+		const inverses = inverse.filter(treeOperation);
+		if (inverses.length === 0 || inverses.length !== inverse.length) return inverseMismatch(operation);
+		const subject = find("tree", operation.at, resolved.addressHash);
+		const state = recordChange(subject?.state, current, operation, inverses);
+		if (subject) subject.state = state;
+		else add({
+			...base(resolved, operation),
+			kind: "tree",
+			state
+		});
+	};
+	return {
+		record: (resolved, operation, inverse) => {
+			require_ownership.profile.batch.journalRecord();
+			if (ownerOf(operation.at)) return;
+			if (operation.type === "field.set" || operation.type === "field.clear") {
+				recordValue(resolved, operation, inverse);
+				return;
+			}
+			if (operation.type === "variant.replace") {
+				recordVariant(resolved, operation, inverse);
+				return;
+			}
+			if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") {
+				recordDict(resolved, operation, inverse);
+				return;
+			}
+			if (operation.type === "entity.create" || operation.type === "entity.remove" || operation.type === "entity.move") {
+				recordEntity(resolved, operation, inverse);
+				return;
+			}
+			if (operation.type === "list.insert" || operation.type === "list.move" || operation.type === "list.remove" || operation.type === "list.replace") {
+				recordList(resolved, operation, inverse);
+				return;
+			}
+			recordTree(resolved, operation, inverse);
+		},
+		finish: () => {
+			const changed = [];
+			const entityChanges = /* @__PURE__ */ new Map();
+			for (const subject of active) {
+				require_ownership.profile.journal.comparison();
+				if (subject.kind === "entity") {
+					const analysis = analyzeEntity(root, subject);
+					if (!analysis.changed) continue;
+					entityChanges.set(subject, analysis);
+					changed.push(subject);
+				} else if (subjectChanged(root, subject)) changed.push(subject);
+			}
+			if (changed.length === 0) return { status: "unchanged" };
+			const collections = [];
+			const collectionBuckets = /* @__PURE__ */ new Map();
+			const changeAt = (address, addressHash) => {
+				const candidates = collectionBuckets.get(addressHash) ?? [];
+				collectionBuckets.set(addressHash, candidates);
+				let change = candidates.find((entry) => sameAddress$1(entry.address, address));
+				if (!change) {
+					change = {
+						address,
+						added: /* @__PURE__ */ new Set(),
+						removed: /* @__PURE__ */ new Set(),
+						updated: /* @__PURE__ */ new Set(),
+						orderChanged: false
+					};
+					candidates.push(change);
+					collections.push(change);
+				}
+				return change;
+			};
+			for (const subject of changed) {
+				if (subject.kind === "entity") {
+					const analysis = entityChanges.get(subject);
+					if (analysis) {
+						const change = changeAt(subject.address, subject.addressHash);
+						analysis.added.forEach((id) => change.added.add(id));
+						analysis.removed.forEach((id) => change.removed.add(id));
+						analysis.updated.forEach((id) => change.updated.add(id));
+						if (analysis.orderChanged) change.orderChanged = true;
+					}
+				}
+				for (let collection = subject.collection; collection; collection = collection.parent) changeAt(collection.address, collection.addressHash).updated.add(collection.id);
+			}
+			for (const change of collections) {
+				change.added.forEach((id) => change.updated.delete(id));
+				change.removed.forEach((id) => change.updated.delete(id));
+			}
+			return {
+				status: "changed",
+				paths: Object.freeze(changed.map((subject) => subject.address)),
+				collections
+			};
+		}
+	};
+};
+//#endregion
+//#region core/src/mutation/operation.ts
+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$1 = (value) => stringArray(value);
+const anchor = (value) => {
+	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";
+};
+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_ownership.isRecord(entry) && typeof entry.id === "string" && has(entry, "value"));
+const decoded = (operation) => ({
+	status: "decoded",
+	operation
+});
+const rejected = (code, message) => ({
+	status: "rejected",
+	issue: input(code, message)
+});
+const decode = (input) => {
+	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":
+		case "variant.replace": return has(input, "value") ? decoded(input) : rejected("invalid-operation", "Operation value is required.");
+		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_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.");
+		case "list.insert": return typeof input.key === "string" && has(input, "value") && optionalAnchor(input) ? decoded(input) : rejected("invalid-operation", "List insert payload is malformed.");
+		case "list.move": return typeof input.key === "string" && optionalAnchor(input) ? decoded(input) : rejected("invalid-operation", "List move payload is malformed.");
+		case "list.remove": return typeof input.key === "string" ? decoded(input) : rejected("invalid-operation", "List remove requires a string key.");
+		case "list.replace": return Array.isArray(input.value) && stringArray(input.keys) ? decoded(input) : rejected("invalid-operation", "List replacement payload is malformed.");
+		case "tree.insert": return typeof input.treeNodeId === "string" && optionalParent(input) && optionalIndex(input) ? decoded(input) : rejected("invalid-operation", "Tree insert payload is malformed.");
+		case "tree.move": return typeof input.treeNodeId === "string" && optionalParent(input) && optionalIndex(input) ? decoded(input) : rejected("invalid-operation", "Tree move payload is malformed.");
+		case "tree.remove": return typeof input.treeNodeId === "string" ? decoded(input) : rejected("invalid-operation", "Tree remove requires a node id.");
+		case "tree.set": return typeof input.treeNodeId === "string" && has(input, "value") ? decoded(input) : rejected("invalid-operation", "Tree set payload is malformed.");
+		case "tree.replace": return has(input, "value") ? decoded(input) : rejected("invalid-operation", "Tree replacement value is required.");
+		default: return rejected("unknown-operation", "Unknown document operation.");
+	}
+};
+const decodeBatch = (input$1) => Array.isArray(input$1) ? {
+	status: "decoded",
+	operations: input$1
+} : {
+	status: "rejected",
+	issue: input("invalid-operation", "Operation batch must be an array.")
+};
+const ownAddress = (value) => {
+	if (Object.isFrozen(value)) return value;
+	require_ownership.profile.address.arrayCopied();
+	return Object.freeze(value.slice());
+};
+const structuralPayload = (value) => Array.isArray(value) || require_ownership.isPlainObject(value);
+const normalize = (operation) => {
+	require_ownership.profile.mutation.normalized();
+	const copy = {
+		...operation,
+		at: ownAddress(operation.at)
+	};
+	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.ids) copy.ids = Object.freeze([...copy.ids]);
+	if (copy.positions) copy.positions = Object.freeze([...copy.positions]);
+	return Object.freeze(copy);
+};
+const publish = (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: structuralPayload(entry.value) ? require_ownership.isStablePayload(entry.value) ? entry.value : require_ownership.snapshotPayload(entry.value, "commit") : entry.value
+	})));
+	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({
+		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
+//#region core/src/mutation/session.ts
+const createMutationSession = (root, schema, options = {}) => {
+	const steps = [];
+	const journal = createChangeJournal(root);
+	let state = "active";
+	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);
+			if (result.status === "rejected") throw new Error(`Document rollback failed: ${result.issue.message}`);
+		}
+		state = "rolled-back";
+	};
+	return {
+		apply: (input) => {
+			if (state !== "active") throw new Error("Mutation session is closed.");
+			require_ownership.profile.batch.operation();
+			const decoded = decode(input);
+			if (decoded.status === "rejected") {
+				require_ownership.profile.batch.rejected();
+				return decoded.issue;
+			}
+			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);
+			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_ownership.profile.batch.rejected();
+				return result.issue;
+			}
+			if (result.status === "unchanged") return void 0;
+			const published = publish(normalized);
+			const group = [];
+			for (const rawInverse of result.inverse) {
+				const inverse$1 = inverse(rawInverse);
+				group.push(inverse$1);
+				require_ownership.profile.mutation.inverse();
+				require_ownership.profile.batch.inverse();
+			}
+			steps.push({
+				forward: published,
+				inverse: Object.freeze(group)
+			});
+			try {
+				if (!resolved) throw new Error(`Changed operation '${normalized.type}' was not resolved.`);
+				journal.record(resolved, normalized, result.inverse);
+			} catch (error) {
+				rollback();
+				throw error;
+			}
+		},
+		finish: () => {
+			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;
+			const inverse = new Array(inverseCount);
+			let writeIndex = 0;
+			for (let stepIndex = steps.length - 1; stepIndex >= 0; stepIndex -= 1) for (const entry of steps[stepIndex].inverse) inverse[writeIndex++] = entry;
+			return {
+				status: "changed",
+				operations: Object.freeze(steps.map((step) => step.forward)),
+				inverse: Object.freeze(inverse),
+				paths: changes.paths,
+				collections: changes.collections
+			};
+		},
+		rollback
+	};
+};
+const mutateOperations = (root, schema, operations, options = {}) => {
+	const decodedBatch = decodeBatch(operations);
+	if (decodedBatch.status === "rejected") return {
+		status: "rejected",
+		issues: Object.freeze([decodedBatch.issue])
+	};
+	const session = createMutationSession(root, schema, options);
+	for (const input of decodedBatch.operations) {
+		const issue = session.apply(input);
+		if (!issue) continue;
+		session.rollback();
+		return {
+			status: "rejected",
+			issues: Object.freeze([issue])
+		};
+	}
+	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();
+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;
+	constructor(issues) {
+		super("Document update rejected.");
+		this.issues = Object.freeze(issues.slice());
+	}
+};
+const EMPTY = Object.freeze([]);
+const publishDiagnostic = (value) => Object.freeze({
+	...value,
+	...value.address === void 0 ? {} : { address: Object.freeze(value.address.slice()) }
+});
+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_ownership.profile.clone.initialDocument();
+	const state = {
+		schema: input.schema,
+		document: require_ownership.cloneValue(input.initial, "initial"),
+		disposed: false
+	};
+	let revision = 0;
+	let busy = false;
+	let runtime;
+	let notification;
+	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,
+		apply: (operations) => applyBatch(operations, "history", false)
+	});
+	const publish = (batch, source, kind, recordHistory) => {
+		revision += 1;
+		const commit = Object.freeze({
+			revision,
+			kind,
+			source,
+			operations: batch.operations,
+			inverse: batch.inverse,
+			impact: impactFor(batch, kind)
+		});
+		if (kind === "replace" || source === "remote") history.invalidate();
+		else if (recordHistory && (source === "local" || source === "system")) history.record(batch.operations, batch.inverse);
+		busy = true;
+		let observerErrors;
+		try {
+			observerErrors = notify(notification, commit);
+		} finally {
+			busy = false;
+		}
+		return {
+			status: "committed",
+			commit,
+			observerErrors
+		};
+	};
+	function applyBatch(operations, source, recordHistory) {
+		assertWritable({
+			kind: "apply",
+			source
+		});
+		const batch = mutateOperations(state.document, input.schema, operations, { copyPayload: source === "history" });
+		if (batch.status === "rejected") return {
+			status: "rejected",
+			issues: batch.issues,
+			revision
+		};
+		if (batch.status === "unchanged") return {
+			status: "unchanged",
+			revision
+		};
+		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),
+			contains: require_dependency.contains,
+			overlaps: require_dependency.overlaps,
+			debugKey: require_dependency.debugKey
+		},
+		revision: () => revision,
+		update: (run, options) => {
+			const source = options?.source ?? "local";
+			assertWritable({
+				kind: "update",
+				source
+			});
+			busy = true;
+			const session = createMutationSession(state.document, input.schema);
+			let committed = false;
+			try {
+				const { value, reports } = runTransaction(session, run);
+				const batch = session.finish();
+				if (batch.status === "unchanged") return {
+					status: "unchanged",
+					value,
+					revision,
+					reports
+				};
+				if (batch.status === "rejected") return {
+					status: "rejected",
+					issues: batch.issues,
+					revision
+				};
+				const result = publish(batch, source, "operations", options?.history ?? true);
+				committed = true;
+				return {
+					status: "committed",
+					value,
+					commit: result.commit,
+					reports,
+					observerErrors: result.observerErrors
+				};
+			} catch (error) {
+				try {
+					if (!committed) session.rollback();
+				} finally {
+					busy = false;
+				}
+				if (error instanceof RejectedUpdate) return {
+					status: "rejected",
+					issues: error.issues,
+					revision
+				};
+				throw error;
+			} finally {
+				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) => {
+			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_ownership.deepEqual(state.document, document)) return {
+				status: "unchanged",
+				revision
+			};
+			state.document = require_ownership.cloneValue(document, "replace");
+			return publish({
+				status: "changed",
+				operations: EMPTY,
+				inverse: EMPTY,
+				paths: EMPTY,
+				collections: EMPTY
+			}, 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();
+			if (typeof targetOrListener === "function") return 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);
+		}),
+		history: history.api,
+		dispose: () => {
+			if (state.disposed) return;
+			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_access.readWith(runtime, selector);
+const select = (runtime, selector) => require_dependency.readWith(runtime, selector);
 //#endregion
 //#region core/src/projection/collection-view.ts
 const createCollectionView = (input) => {
-	if (require_access.schemaOf(input.runtime) !== input.source.schema) throw new Error("Collection selector belongs to another schema.");
+	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_access.nodeAt(input.source.schema, input.source.address);
+	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_access.profile.collectionView.mapped();
+		require_ownership.profile.collectionView.mapped();
 		const address = [...input.source.address, String(id)];
 		let active = true;
 		try {
-			return input.map(id, require_access.readerFor(entryNode, {
+			return input.map(id, require_dependency.readerFor(entryNode, {
 				root: () => document,
 				active: () => active
 			}, address));
@@ -32,10 +2622,10 @@ const createCollectionView = (input) => {
 		}
 	};
 	const build = (previous, changed) => {
-		const document = require_access.documentOf(input.runtime);
-		const collection = require_access.read(document, input.source.address);
+		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_access.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);
@@ -63,7 +2653,7 @@ const createCollectionView = (input) => {
 	let state = build();
 	const ensureAll = () => {
 		if (!state.allDirty && state.all) return state.all;
-		require_access.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);
@@ -80,7 +2670,7 @@ const createCollectionView = (input) => {
 		if (impact.kind === "incremental" && impact.added.size === 0 && impact.removed.size === 0 && !impact.orderChanged) {
 			const previous = state;
 			const changes = [];
-			const document = require_access.documentOf(input.runtime);
+			const document = require_dependency.documentOf(input.runtime);
 			impact.updated.forEach((id) => {
 				if (!previous.values.has(id)) return;
 				const before = previous.values.get(id);
@@ -220,7 +2810,7 @@ const createMaterializedView = (runtime, spec) => {
 			entry.change = meta?.change;
 			if (commitRevision !== void 0 && meta?.changedRevision === commitRevision) {
 				sourceChanged = true;
-				require_access.profile.materialized.sourceChanged();
+				require_ownership.profile.materialized.sourceChanged();
 			}
 		}
 		return sourceValuesRecord;
@@ -267,12 +2857,12 @@ const createMaterializedView = (runtime, spec) => {
 		});
 	};
 	const build = () => {
-		require_access.profile.materialized.rebuilt();
+		require_ownership.profile.materialized.rebuilt();
 		dependencies.clear();
 		let active = true;
 		try {
 			instance = spec.build({
-				read: require_access.documentReader(require_access.schemaOf(runtime), () => require_access.documentOf(runtime), () => active),
+				read: require_dependency.documentReader(require_dependency.schemaOf(runtime), () => require_dependency.documentOf(runtime), () => active),
 				sources: sourceValues()
 			});
 			currentValue = instance.value;
@@ -284,7 +2874,7 @@ const createMaterializedView = (runtime, spec) => {
 	};
 	build();
 	const emit = () => {
-		require_access.profile.materialized.notification();
+		require_ownership.profile.materialized.notification();
 		Array.from(listeners).forEach((listener) => listener());
 	};
 	const process = (commit) => {
@@ -298,19 +2888,19 @@ const createMaterializedView = (runtime, spec) => {
 			}
 			const sourceSnapshot = sourceValues(commit.revision);
 			if (!sourceChanged && dependencies.size() > 0 && !dependencies.some(commit.impact.affects)) {
-				require_access.profile.materialized.skipped();
+				require_ownership.profile.materialized.skipped();
 				revision = commit.revision;
 				writeMeta(void 0, currentValue, commit.revision, false);
 				return;
 			}
 			dependencies.clear();
-			require_access.profile.materialized.updated();
+			require_ownership.profile.materialized.updated();
 			let active = true;
 			let result;
 			try {
 				activeImpact = commit.impact;
 				result = instance.update({
-					read: require_access.documentReader(require_access.schemaOf(runtime), () => require_access.documentOf(runtime), () => active),
+					read: require_dependency.documentReader(require_dependency.schemaOf(runtime), () => require_dependency.documentOf(runtime), () => active),
 					revision: commit.revision,
 					source: commit.source,
 					impact: trackedImpact,
@@ -375,7 +2965,7 @@ const createMaterializedView = (runtime, spec) => {
 		revision,
 		changedRevision: -1
 	});
-	const unregister = require_readable.registerProcessor(runtime, {
+	const unregister = registerProcessor(runtime, {
 		process,
 		flush: () => {
 			if (!pendingEmit) return;
@@ -386,38 +2976,38 @@ const createMaterializedView = (runtime, spec) => {
 	return view;
 };
 //#endregion
-exports.DocumentDisposedError = require_access.DocumentDisposedError;
-exports.DocumentReentrancyError = require_access.DocumentReentrancyError;
-exports.asReadable = require_readable.asReadable;
-exports.commandFootprint = require_readable.commandFootprint;
-exports.contains = require_access.contains;
+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 = require_readable.createDocument;
+exports.createDocument = createDocument;
 exports.createMaterializedView = createMaterializedView;
-exports.debugKey = require_access.debugKey;
-exports.decodeCommandFootprint = require_readable.decodeCommandFootprint;
-exports.dict = require_access.dict;
-exports.field = require_access.field;
-exports.footprintsOverlap = require_readable.footprintsOverlap;
-exports.list = require_access.list;
-exports.map = require_access.map;
-exports.object = require_access.object;
-exports.optional = require_access.optional;
-exports.overlaps = require_access.overlaps;
-exports.readAddress = require_access.read;
-exports.record = require_access.record;
-exports.resolveAddress = require_access.resolveAddress;
-exports.schema = require_access.schema;
+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;
+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.select = select;
-exports.single = require_access.single;
-exports.table = require_access.table;
+exports.single = require_dependency.single;
+exports.table = require_dependency.table;
 Object.defineProperty(exports, "target", {
 	enumerable: true,
 	get: function() {
-		return require_access.impact_target_exports;
+		return require_dependency.impact_target_exports;
 	}
 });
-exports.tree = require_access.tree;
-exports.variant = require_access.variant;
+exports.tree = require_dependency.tree;
+exports.variant = require_dependency.variant;
 
 //# sourceMappingURL=index.cjs.map