doxum 0.1.7 → 0.1.9

package/dist/index.cjs

@@ -1,92 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_runtime = require("./runtime-0mOFbe_H.cjs");
-const require_ownership = require("./ownership-CY0nPXGF.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_runtime.overlaps(changed, address));
-	let collectionCache;
-	const findCollection = (address) => input.collections?.find((entry) => entry.address.length === address.length && entry.address.every((segment, index) => segment === address[index]));
-	return {
-		kind,
-		operations: input.operations,
-		affects: (value) => {
-			require_ownership.profile.impact.affects();
-			if (kind === "reset") return true;
-			if (!require_runtime.belongs(value, input.schema)) return false;
-			if (pathsAffect(require_runtime.address(value))) return true;
-			if (value.kind === "collection") {
-				const collection = findCollection(require_runtime.address(value));
-				if (!collection) return false;
-				const id$1 = require_runtime.id(value);
-				if (id$1 !== void 0) return collection.added.has(id$1) || collection.removed.has(id$1) || collection.updated.has(id$1);
-				return collection.added.size > 0 || collection.removed.size > 0 || collection.updated.size > 0 || collection.orderChanged;
-			}
-			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_runtime.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
+const require_issue = require("./issue-DhrNdQNg.cjs");
+const require_store = require("./store-1Uob0Ghk.cjs");
+const require_driver = require("./driver-xOIkwrB8.cjs");
 //#region core/src/history.ts
 const createHistory = (input) => {
 	let undos = [];
@@ -150,8 +65,8 @@ const createHistory = (input) => {
 		} else to.push(entry);
 		let committed = false;
 		try {
-			const operations = direction === "redo" ? entry.batches.flatMap((batch) => batch.operations) : entry.batches.slice().reverse().flatMap((batch) => batch.inverse);
-			const result = input.apply(operations);
+			const changes = direction === "redo" ? entry.batches : entry.batches.slice().reverse();
+			const result = input.apply(changes, direction === "redo" ? "forward" : "backward");
 			committed = result.status !== "rejected";
 			if (committed && direction === "cancel") group = void 0;
 			if (result.status === "unchanged") {
@@ -175,7 +90,7 @@ const createHistory = (input) => {
 			current: () => state,
 			revision: () => revision,
 			subscribe: (listener) => {
-				if (disposed) throw new require_runtime.DocumentDisposedError();
+				if (disposed) throw new require_store.DocumentDisposedError();
 				listeners.add(listener);
 				return () => {
 					listeners.delete(listener);
@@ -225,12 +140,8 @@ const createHistory = (input) => {
 				});
 			}
 		},
-		record: (operations, inverse) => {
+		record: (batch) => {
 			if (input.capacity <= 0) return;
-			const batch = {
-				operations,
-				inverse
-			};
 			if (group?.entry) group.entry.batches.push(batch);
 			else {
 				const entry = { batches: [batch] };
@@ -256,1990 +167,609 @@ const createHistory = (input) => {
 	};
 };
 //#endregion
-//#region core/src/access/writer.ts
-const schemaRoot = (schema) => require_runtime.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") 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
-		}),
-		...node.optional ? { clear: () => emit(sink, {
-			type: "value.clear",
-			at: address
-		}) } : {}
-	};
-	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)
-		}),
-		...node.optional ? { clear: () => emit(sink, {
-			type: "value.clear",
-			at: address
-		}) } : {}
-	};
-	if (node.kind === "tree") return {
-		insert: (treeNodeId, value, position) => emit(sink, {
-			type: "tree.insert",
-			at: address,
-			treeNodeId,
-			value,
-			parentId: position?.parentId,
-			index: position?.index
-		}),
-		move: (treeNodeId, position) => emit(sink, {
-			type: "tree.move",
-			at: address,
-			treeNodeId,
-			parentId: position?.parentId,
-			index: position?.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
-		}),
-		...node.optional ? { clear: () => emit(sink, {
-			type: "value.clear",
-			at: address
-		}) } : {}
-	};
-	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 === "variant") return {
-		replace: (value) => emit(sink, {
-			type: "variant.replace",
-			at: address,
-			value
-		}),
-		...node.optional ? { clear: () => emit(sink, {
-			type: "value.clear",
-			at: address
-		}) } : {}
-	};
-	let children;
-	return new Proxy({}, { get: (_target, property) => {
-		if (typeof property !== "string" || !node.shape[property]) return void 0;
-		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 = (address, code, message, operation) => Object.freeze({
-	source: "mutation",
-	code,
-	address: ownAddress$1(address),
-	message,
-	...operation === void 0 ? {} : { operation }
-});
-const from = (operation, code, message) => at(operation.at, code, message, operation.type);
-const input = (code, message) => at([], code, message);
-//#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" };
+//#region core/src/mutation/state.ts
+/** Install validated values, or captured before values during rollback. */
+const installMember = (parent, key, present, value) => {
+	if (Array.isArray(parent)) {
+		const index = Number(key);
+		if (present) if (index < 0) require_issue.insert(parent, parent.length, value);
+		else parent[index] = value;
+		else if (index >= 0) require_issue.remove(parent, index);
+	} else if (!present) delete parent[key];
+	else if (Object.hasOwn(parent, key)) parent[key] = value;
+	else Object.defineProperty(parent, key, {
+		value,
+		writable: true,
+		configurable: true,
+		enumerable: true
+	});
 };
-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 || !require_runtime.validPositions(ids.length, operation.positions)) return rejected$4(operation, "invalid-operation", "Entity restore positions are invalid.");
-		} else if (ids && !require_runtime.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) require_runtime.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 = require_runtime.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 (!require_runtime.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 = require_runtime.afterRemove(ids, position, operation.anchor);
-	if (nextIndex === position) return { status: "unchanged" };
-	const inverse = {
-		type: "entity.move",
-		at: operation.at,
-		id: operation.id,
-		anchor: require_runtime.at(ids, position)
-	};
-	ids.splice(position, 1);
-	ids.splice(nextIndex, 0, operation.id);
-	return {
-		status: "changed",
-		inverse: [inverse]
-	};
+const orderOf = (node, value) => {
+	if (node.kind === "list") return value.map(node.keyOf);
+	if (node.kind === "table") return [...value.ids];
+	throw new Error("Order requires a table or list.");
 };
-//#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 (target.node.kind !== "list") return rejected$3(operation, "invalid-address", "List target is invalid.");
-	const absent = target.value === void 0 && "optional" in target.node && target.node.optional === true;
-	if (!Array.isArray(target.value) && !absent) return rejected$3(operation, "invalid-address", "List target is invalid.");
-	if (absent && operation.type !== "list.replace") return rejected$3(operation, "invalid-address", "Only list replacement can initialize an optional list.");
-	const list = Array.isArray(target.value) ? target.value : [];
-	const orderedKeys = require_runtime.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 (!absent && require_ownership.sameStructuralValue(list, operation.value)) return { status: "unchanged" };
-		const keys = list.map(target.node.keyOf);
-		const inverse = absent ? {
-			type: "value.clear",
-			at: operation.at
-		} : {
-			type: "list.replace",
-			at: operation.at,
-			value: require_ownership.cloneValue(list, "inverse"),
-			keys
-		};
-		const owned = own(operation.value);
-		if (absent) target.parent[target.key] = owned;
-		else {
-			list.length = owned.length;
-			for (let index = 0; index < owned.length; index += 1) list[index] = owned[index];
-		}
-		return {
-			status: "changed",
-			inverse: [inverse]
-		};
-	}
-	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 (!require_runtime.valid(orderedKeys, operation.anchor)) return rejected$3(operation, "invalid-anchor", "List anchor is invalid.");
-		list.splice(require_runtime.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: require_runtime.at(orderedKeys, position)
-		};
-		list.splice(position, 1);
-		return {
-			status: "changed",
-			inverse: [inverse]
-		};
-	}
-	if (!require_runtime.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 = require_runtime.afterRemove(orderedKeys, position, operation.anchor);
-	if (nextIndex === position) return { status: "unchanged" };
-	const inverse = {
-		type: "list.move",
-		at: operation.at,
-		key: operation.key,
-		anchor: require_runtime.at(orderedKeys, position)
-	};
-	const [entry] = list.splice(position, 1);
-	list.splice(nextIndex, 0, entry);
-	return {
-		status: "changed",
-		inverse: [inverse]
-	};
+const installOrder = (node, value, order) => {
+	if (node.kind === "list") require_issue.install(value, node.keyOf, order);
+	else if (node.kind === "table") value.ids = [...order];
+	else throw new Error("Order requires a table or list.");
 };
 //#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
+//#region core/src/mutation/recorder.ts
+const firstMember = (group, key) => {
+	if (group.layout === "dynamic") return group.members?.get(key);
+	const member = group.definitions.get(key);
+	return member && group.members[member.slot];
+};
+const forgetMember = (group, key) => {
+	if (group.layout === "dynamic") group.members?.delete(key);
+	else {
+		const definition = group.definitions.get(key);
+		if (definition) group.members[definition.slot] = void 0;
+	}
+};
+const emptyGroup = (group) => !group.order && (group.layout === "fixed" ? !group.members.some(Boolean) : !group.members?.size);
+const copyNode = (node) => ({
+	...node,
+	children: [...node.children]
 });
-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 transition = (node, key, beforePresent, before, afterPresent, after) => {
+	if (beforePresent === afterPresent && (!beforePresent || Object.is(before, after))) return;
+	if (node.kind !== "field" && beforePresent === afterPresent && require_store.equalValue(node, before, after)) return;
+	const value = afterPresent ? node.kind === "field" ? after : require_store.copyValue(node, after) : void 0;
+	require_issue.profile.recorder("transitions");
+	return !beforePresent ? {
+		key,
+		kind: "added",
+		after: value
+	} : !afterPresent ? {
+		key,
+		kind: "removed",
+		before
+	} : {
+		key,
+		kind: "updated",
+		before,
+		after: value
+	};
+};
+const publishMembers = (changes, at, members, order) => {
+	if (!members.length && !order) return;
+	for (let i = 1; i < members.length; i++) if (members[i - 1].key > members[i].key) {
+		members.sort((a, b) => lexical(a.key, b.key));
+		break;
+	}
+	changes.push(order ? {
+		kind: "members",
+		at,
+		members,
+		order
+	} : {
+		kind: "members",
+		at,
+		members
+	});
 };
-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;
+/** Diff only the captured subtree; this algorithm has no recorder or session state. */
+const diffMember = (changes, members, node, at, key, beforePresent, before, afterPresent, after) => {
+	if (beforePresent === afterPresent && (!beforePresent || Object.is(before, after))) return;
+	if (beforePresent && afterPresent && before !== void 0 && after !== void 0) {
+		if (node.kind === "object" || node.kind === "variant" && before[node.tag] === after[node.tag]) {
+			const left = before, right = after;
+			const childAt = at.concat(key);
+			const children = [];
+			for (const [child, definition] of require_issue.compiledShape(node, before).members) diffMember(changes, children, definition.node, childAt, child, Object.hasOwn(left, child), left[child], Object.hasOwn(right, child), right[child]);
+			publishMembers(changes, childAt, children);
+			return;
 		}
-		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)));
+		if (node.kind === "map" || node.kind === "table") {
+			const a = before, b = after;
+			const left = node.kind === "table" ? a.byId : a;
+			const right = node.kind === "table" ? b.byId : b;
+			const childAt = at.concat(key);
+			const children = [];
+			for (const id of Object.keys(left)) diffMember(changes, children, node.value, childAt, id, true, left[id], Object.hasOwn(right, id), right[id]);
+			for (const id of Object.keys(right)) if (!Object.hasOwn(left, id)) diffMember(changes, children, node.value, childAt, id, false, void 0, true, right[id]);
+			let order;
+			if (node.kind === "table" && !require_issue.equal(a.ids, b.ids)) {
+				require_issue.profile.recorder("publishedOrderItems", b.ids.length);
+				order = {
+					before: a.ids,
+					after: [...b.ids]
+				};
+			}
+			publishMembers(changes, childAt, children, order);
+			return;
 		}
-		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)));
+	const member = transition(node, key, beforePresent, before, afterPresent, after);
+	if (member) members.push(member);
+};
+const restore = (fact, schema, root, skip = 0) => {
+	const at = skip ? fact.at.slice(skip) : fact.at;
+	if (fact.kind === "member") {
+		const member = fact.member;
+		const value = member.present ? require_store.copyValue(member.node, member.value) : void 0;
+		if (!at.length) return value;
+		const location = require_issue.resolveLocated(schema, root, at);
+		if (!location) throw new Error("Cannot restore an unresolved member.");
+		installMember(location.parent, location.key, member.present, value);
+		return root;
+	}
+	const location = require_issue.resolveValue(schema, root, at);
+	if (!location) throw new Error("Cannot restore an unresolved subtree.");
+	if (fact.kind === "order") installOrder(location.node, location.value, fact.group.order);
+	else {
+		const tree = location.value;
+		if (fact.before === null) delete tree.rootId;
+		else tree.rootId = fact.before;
+		for (const [id, node] of fact.nodes) installMember(tree.nodes, id, node !== void 0, node && copyNode(node));
+	}
+	return root;
+};
+const reconstructBefore = (node, current, records, offset) => {
+	let before = require_store.copyValue(node, current);
+	for (let i = records.length - 1; i >= 0; i--) if (records[i].kind !== "order") before = restore(records[i], node, before, offset);
+	for (const record of records) if (record.kind === "order") before = restore(record, node, before, offset);
+	return before;
+};
+const sealMembers = (fact, changes) => {
+	const members = [];
+	for (const member of fact.members?.values() ?? []) {
+		if (!member) continue;
+		const key = require_issue.memberKey(fact, member.key);
+		const present = Object.hasOwn(fact.parent, key);
+		const value = fact.parent[key];
+		if (member.node.kind === "field") {
+			const change = transition(member.node, member.key, member.present, member.value, present, value);
+			if (change) members.push(change);
+		} else diffMember(changes, members, member.node, fact.at, member.key, member.present, member.value, present, value);
+	}
+	let order;
+	if (fact.order) {
+		const current = fact.node.kind === "list" ? require_issue.keys(fact.value, fact.node.keyOf) : fact.value.ids;
+		if (!require_issue.equal(fact.order, current)) {
+			const after = orderOf(fact.node, fact.value);
+			require_issue.profile.recorder("publishedOrderItems", after.length);
+			order = {
+				before: fact.order,
+				after
+			};
 		}
-		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
+	publishMembers(changes, fact.at, members, order);
+};
+const sealTree = (fact, state, changes) => {
+	const location = require_issue.resolveValue(state.schema, state.document, fact.at);
+	const tree = location?.value;
+	const node = location?.node;
+	if (node?.kind !== "tree") throw new Error("Tree schema disappeared before sealing.");
+	const nodes = [];
+	for (const [id, before] of fact.nodes) {
+		const after = Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
+		if (!before && !after) continue;
+		if (before && after && before.parentId === after.parentId && require_issue.equal(before.children, after.children) && Object.hasOwn(before, "value") === Object.hasOwn(after, "value") && require_store.equalValue(node.value, before.value, after.value)) continue;
+		nodes.push(!before ? {
+			id,
+			kind: "added",
+			after: copyNode(after)
+		} : !after ? {
+			id,
+			kind: "removed",
+			before
+		} : {
+			id,
+			kind: "updated",
+			before,
+			after: copyNode(after)
 		});
-		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 = (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 after = tree.rootId ?? null;
+	if (nodes.length || fact.before !== after) changes.push({
+		kind: "tree",
+		at: fact.at,
+		before: fact.before,
+		after,
+		nodes: nodes.sort((a, b) => lexical(a.id, b.id))
+	});
 };
-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 === "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;
-		}
+/** One first-touch record per owning container, never a per-write operation log. */
+var ChangeRecorder = class {
+	facts = /* @__PURE__ */ new Set();
+	groups = /* @__PURE__ */ new WeakMap();
+	index;
+	indexedGroups = false;
+	resetBefore;
+	constructor(state) {
+		this.state = state;
+	}
+	indexGroups() {
+		const index = this.index ??= new require_issue.AddressIndex();
+		if (!this.indexedGroups) {
+			this.indexedGroups = true;
+			for (const fact of this.facts) if (fact.kind === "members") {
+				index.add(fact.at, fact);
+				require_issue.profile.recorder("indexedGroups");
+			}
+		}
+		return index;
+	}
+	covered(at) {
+		return this.resetBefore !== void 0 || this.indexedGroups && this.index.someAncestor(at, (fact) => fact.kind === "members" && fact.at.length < at.length && firstMember(fact, at[fact.at.length]) !== void 0);
+	}
+	absorb(at, node, value, present) {
+		const index = this.indexGroups();
+		const children = [];
+		index.query((fact) => {
+			if (fact.kind === "members") {
+				if (fact.at.length < at.length) {
+					if (fact.at.length + 1 === at.length) {
+						const member = firstMember(fact, at[fact.at.length]);
+						if (member) children.push({
+							kind: "member",
+							at,
+							group: fact,
+							member
+						});
+					}
+					return;
+				}
+				if (fact.order && require_issue.contains(at, fact.at)) children.push({
+					kind: "order",
+					at: fact.at,
+					group: fact
+				});
+				for (const member of fact.members?.values() ?? []) {
+					if (!member) continue;
+					const memberAt = fact.at.concat(member.key);
+					if (require_issue.contains(at, memberAt)) children.push({
+						kind: "member",
+						at: memberAt,
+						group: fact,
+						member
+					});
+				}
+			} else if (require_issue.contains(at, fact.at)) children.push(fact);
+		})(at);
+		if (present) value = reconstructBefore(node, value, children, at.length);
+		this.releaseCovered(children);
+		return value;
 	}
-};
-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(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: [],
+	releaseCovered(children) {
+		let changedGroups;
+		for (const child of children) {
+			require_issue.profile.recorder("absorbed");
+			if (child.kind === "member") {
+				const { group, member } = child;
+				forgetMember(group, member.key);
+				(changedGroups ??= /* @__PURE__ */ new Set()).add(group);
+			} else if (child.kind === "order") {
+				child.group.order = void 0;
+				(changedGroups ??= /* @__PURE__ */ new Set()).add(child.group);
+			} else this.unregister(child);
+		}
+		for (const group of changedGroups ?? []) if (emptyGroup(group)) this.unregister(group);
+	}
+	register(fact) {
+		this.facts.add(fact);
+		if (fact.kind === "members") {
+			this.groups.set(fact.parent, fact);
+			require_issue.profile.recorder("groups");
+			if (!this.indexedGroups) return;
+			require_issue.profile.recorder("indexedGroups");
+		}
+		(this.index ??= new require_issue.AddressIndex()).add(fact.at, fact);
+	}
+	unregister(fact) {
+		this.facts.delete(fact);
+		this.index?.delete(fact.at, fact);
+		if (fact.kind === "members") this.groups.delete(fact.parent);
+	}
+	member(container, key, definition, physicalKey) {
+		if (this.resetBefore) return;
+		const { node } = definition;
+		let group = this.groups.get(container.parent);
+		if (group?.layout === "dynamic" && group.members?.has(key)) return;
+		if (group?.layout === "fixed" && definition.kind === "fixed" && group.members[definition.slot]) return;
+		const at = this.indexedGroups || node.kind !== "field" ? container.at.concat(key) : void 0;
+		if (at && this.covered(at)) return;
+		const present = Object.hasOwn(container.parent, physicalKey);
+		let value = container.parent[physicalKey];
+		if (node.kind !== "field") value = this.absorb(at, node, value, present);
+		if (!group || !this.facts.has(group)) group = this.createGroup(container);
+		const member = {
+			key,
+			node,
+			present,
 			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.");
-	currentParent.children.splice(originalIndex, 1);
-	const nextIndex = Math.min(operation.index ?? nextParent.children.length, nextParent.children.length);
-	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 (target.node.kind !== "tree") return {
-		status: "rejected",
-		issue: from(operation, "invalid-address", "Tree target is invalid.")
-	};
-	const own = (value) => copyPayload ? require_ownership.ownPayload(value) : value;
-	const absent = target.value === void 0 && "optional" in target.node && target.node.optional === true;
-	if (operation.type === "tree.replace") {
-		if (absent) {
-			if (!validate(operation.value)) return {
-				status: "rejected",
-				issue: from(operation, "invalid-tree", "Tree replacement is malformed.")
-			};
-			target.parent[target.key] = own(operation.value);
-			return {
-				status: "changed",
-				inverse: [{
-					type: "value.clear",
-					at: operation.at
-				}]
-			};
-		}
-		if (!is(target.value)) return {
-			status: "rejected",
-			issue: from(operation, "invalid-address", "Tree target is invalid.")
-		};
-		const result = replace(target.value, operation);
-		if (result.status === "changed") require_runtime.set(root, operation.at, require_ownership.ownPayload(operation.value));
-		return outcome(operation, result);
-	}
-	if (!is(target.value)) return {
-		status: "rejected",
-		issue: from(operation, "invalid-address", "Tree target is invalid.")
-	};
-	if (operation.type === "tree.insert") return outcome(operation, insert(target.value, operation, own(operation.value)));
-	if (operation.type === "tree.set") return outcome(operation, set(target.value, operation, own(operation.value)));
-	if (operation.type === "tree.remove") return outcome(operation, remove(target.value, operation));
-	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
+		if (group.layout === "dynamic") (group.members ??= /* @__PURE__ */ new Map()).set(key, member);
+		else if (definition.kind === "fixed") group.members[definition.slot] = member;
+		else throw new Error("A fixed member group requires a fixed schema member.");
+		require_issue.profile.recorder("facts");
+	}
+	reset() {
+		if (this.resetBefore) return;
+		const value = this.absorb([], this.state.schema, this.state.document, true);
+		this.resetBefore = { value };
+		this.groups = /* @__PURE__ */ new WeakMap();
+		require_issue.profile.recorder("facts");
+	}
+	createGroup(container) {
+		const group = container.layout.kind === "fixed" ? {
+			kind: "members",
+			at: container.at,
+			node: container.node,
+			parent: container.parent,
+			value: container.value,
+			layout: "fixed",
+			definitions: container.layout.members,
+			members: new Array(container.layout.members.size)
 		} : {
-			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" };
-		if (target.value === void 0 && target.node.optional) {
-			target.parent[target.key] = own(operation.value);
-			return {
-				status: "changed",
-				inverse: [{
-					type: "value.clear",
-					at: operation.at
-				}]
+			kind: "members",
+			at: container.at,
+			node: container.node,
+			parent: container.parent,
+			value: container.value,
+			layout: "dynamic",
+			members: void 0
+		};
+		this.register(group);
+		return group;
+	}
+	order(container) {
+		require_issue.profile.recorder("orderCaptures");
+		let group = this.groups.get(container.parent);
+		if (group?.order || this.covered(container.at)) return;
+		group ??= this.createGroup(container);
+		group.order = orderOf(container.node, container.value);
+		require_issue.profile.recorder("orderSnapshots");
+		require_issue.profile.recorder("orderItems", group.order.length);
+	}
+	tree(container, id) {
+		const { at, value: tree } = container;
+		if (this.covered(at)) return;
+		const index = this.index ??= new require_issue.AddressIndex();
+		let fact;
+		for (const item of index.exact(at) ?? []) if (item.kind === "tree") fact = item;
+		if (!fact) {
+			fact = {
+				kind: "tree",
+				at,
+				before: tree.rootId ?? null,
+				nodes: /* @__PURE__ */ new Map()
 			};
+			this.register(fact);
 		}
-		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 (operation.type === "dict.replace" && target.value === void 0) {
-		if (!("optional" in target.node) || !target.node.optional) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
-		const inverse = {
-			type: "value.clear",
-			at: operation.at
-		};
-		target.parent[target.key] = own(operation.value);
-		return {
-			status: "changed",
-			inverse: [inverse]
-		};
-	}
-	if (!require_ownership.isRecord(target.value)) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
-	if (operation.type === "dict.replace") {
-		if (require_ownership.sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
-		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 hasOwn$1 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
-const executeClear = (target, operation) => {
-	if (!("optional" in target.node) || !target.node.optional) return {
-		status: "rejected",
-		issue: from(operation, "required-field", "Only optional values can be cleared.")
-	};
-	if (!hasOwn$1(target.parent, target.key)) return { status: "unchanged" };
-	if (target.node.kind !== "field" && target.node.kind !== "variant" && target.node.kind !== "dict" && target.node.kind !== "list" && target.node.kind !== "tree") return {
-		status: "rejected",
-		issue: from(operation, "invalid-operation", "This optional value has no clear operation.")
-	};
-	const inverse = (() => {
-		switch (target.node.kind) {
-			case "field": return {
-				type: "field.set",
-				at: operation.at,
-				value: target.value
-			};
-			case "variant": return {
-				type: "variant.replace",
-				at: operation.at,
-				value: require_ownership.cloneValue(target.value, "inverse")
-			};
-			case "dict": return {
-				type: "dict.replace",
-				at: operation.at,
-				value: require_ownership.cloneValue(target.value, "inverse")
-			};
-			case "list":
-				if (!Array.isArray(target.value)) return {
-					type: "list.replace",
-					at: operation.at,
-					value: [],
-					keys: []
-				};
-				return {
-					type: "list.replace",
-					at: operation.at,
-					value: require_ownership.cloneValue(target.value, "inverse"),
-					keys: target.value.map(target.node.keyOf)
-				};
-			case "tree": return {
-				type: "tree.replace",
-				at: operation.at,
-				value: require_ownership.cloneValue(target.value, "inverse")
-			};
+		if (id !== void 0 && !fact.nodes.has(id)) {
+			require_issue.profile.recorder("treeNodes");
+			fact.nodes.set(id, Object.hasOwn(tree.nodes, id) ? copyNode(tree.nodes[id]) : void 0);
 		}
-	})();
-	delete target.parent[target.key];
-	return {
-		status: "changed",
-		inverse: [inverse]
-	};
-};
-const invalidTarget = (operation) => ({
-	status: "rejected",
-	issue: from(operation, "invalid-address", `Operation '${operation.type}' does not match the schema address.`)
-});
-const execute = (root, operation, target, copyPayload) => {
-	if (operation.type === "value.clear") return !target ? invalidTarget(operation) : executeClear(target, operation);
-	if (operation.type === "field.set" || operation.type === "field.clear") return !target || target.node.kind !== "field" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
-	if (operation.type === "variant.replace") return !target || target.node.kind !== "variant" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
-	if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") return !target || target.node.kind !== "dict" ? 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 = (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_runtime.locate(root, address);
-	if (!target) return;
-	if (before.status === "present") target.parent[target.key] = before.value;
-	else if (Array.isArray(target.parent)) target.parent.splice(Number(target.key), 1);
-	else delete target.parent[String(target.key)];
-};
-const writeContainer = (root, address, value) => {
-	const target = require_runtime.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.status === "present" ? subject.before.value : void 0;
-	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(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") {
-		writePresence(value, address, subject.before);
-		return value;
-	}
-	const current = require_runtime.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_runtime.locate(root, subject.address);
-	const exists = !!target && hasOwn(target.parent, target.key);
-	if (subject.before.status === "absent") return exists;
-	return !exists || !Object.is(subject.before.value, target?.value);
-};
-const dictChanged = (root, subject) => {
-	const value = require_runtime.read(root, subject.address);
-	if (!require_ownership.isRecord(value)) return true;
-	if (subject.state.mode === "whole") return !require_ownership.sameStructuralValue(subject.state.value, value);
-	for (const [key, before] of subject.state.entries) {
-		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_runtime.read(root, subject.address);
-	if (!Array.isArray(value)) return true;
-	if (subject.state.mode === "whole") return !require_ownership.sameStructuralValue(subject.state.value, value);
-	const positions = /* @__PURE__ */ new Map();
-	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_runtime.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") {
-		const target = require_runtime.locate(root, subject.address);
-		const exists = !!target && hasOwn(target.parent, target.key);
-		return subject.before.status === "absent" ? exists : !exists || !require_ownership.sameStructuralValue(subject.before.value, target?.value);
-	}
-	if (subject.kind === "dict") return dictChanged(root, subject);
-	if (subject.kind === "list") return listChanged(root, subject);
-	return changeChanged(subject.state, require_runtime.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(require_runtime.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(require_runtime.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") {
-			require_runtime.restore(order, inverse.ids, inverse.positions);
-			continue;
-		}
-		const position = order.indexOf(inverse.id);
-		if (position < 0 || !require_runtime.valid(order, inverse.anchor)) throw new Error(`Entity order inverse cannot restore '${inverse.id}'.`);
-		const nextIndex = require_runtime.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(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" && first?.type !== "value.clear" && !("value" in (first ?? {}))) return inverseMismatch(operation);
-		const before = first.type === "field.clear" || first.type === "value.clear" ? absent : "value" in first ? present(first.value) : inverseMismatch(operation);
-		add({
-			...base(resolved, operation),
-			kind: "value",
-			before
-		});
-	};
-	const recordVariant = (resolved, operation, inverse) => {
-		if (find("variant", operation.at, resolved.addressHash)) return;
-		const first = inverse[0];
-		if (first?.type !== "variant.replace" && first?.type !== "value.clear") return inverseMismatch(operation);
-		add({
-			...base(resolved, operation),
-			kind: "variant",
-			before: first.type === "value.clear" ? absent : present(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 === "value.clear") {
-				add({
-					...base(resolved, operation),
-					kind: "list",
-					node: resolved.node,
-					state: {
-						mode: "whole",
-						value: void 0
-					}
-				});
-				return;
-			}
-			if (first.type === "list.replace") {
-				add({
-					...base(resolved, operation),
-					kind: "list",
-					node: resolved.node,
-					state: {
-						mode: "whole",
-						value: first.value
-					}
-				});
-				return;
-			}
-			const value = require_runtime.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_runtime.read(root, operation.at));
-		if (resolution.status === "invalid") return inverseMismatch(operation);
-		const collection = resolution.collection;
-		const subject = find("entity", operation.at, resolved.addressHash) ?? add({
-			...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);
+	rollback() {
+		if (this.resetBefore) {
+			this.state.document = this.resetBefore.value;
 			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)));
+		const facts = [...this.facts];
+		for (let i = facts.length - 1; i >= 0; i--) {
+			const fact = facts[i];
+			if (fact.kind === "members") for (const member of fact.members?.values() ?? []) {
+				if (!member) continue;
+				installMember(fact.parent, require_issue.memberKey(fact, member.key), member.present, member.present ? require_store.copyValue(member.node, member.value) : void 0);
 			}
-			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_runtime.read(root, operation.at);
-		if (inverse.length === 1 && inverse[0].type === "value.clear" && operation.type === "tree.replace") {
-			const subject = find("tree", operation.at, resolved.addressHash);
-			if (subject) subject.state = {
-				mode: "whole",
-				value: void 0
-			};
-			else add({
-				...base(resolved, operation),
-				kind: "tree",
-				state: {
-					mode: "whole",
-					value: void 0
-				}
-			});
-			return;
+			else if (fact.kind === "tree") restore(fact, this.state.schema, this.state.document);
 		}
-		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 === "value.clear" && resolved.node.kind === "variant") {
-				recordVariant(resolved, operation, inverse);
-				return;
-			}
-			if (operation.type === "field.set" || operation.type === "field.clear" || operation.type === "value.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") {
-				if (operation.type === "dict.replace" && inverse[0]?.type === "value.clear") recordValue(resolved, operation, inverse);
-				else recordDict(resolved, operation, inverse);
-				return;
-			}
-			if (operation.type === "entity.create" || operation.type === "entity.remove" || operation.type === "entity.move") {
-				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(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
-			};
+		for (const fact of facts) if (fact.kind === "members" && fact.order) installOrder(fact.node, fact.value, fact.order);
+	}
+	seal() {
+		if (this.resetBefore) {
+			if (require_store.equalValue(this.state.schema, this.resetBefore.value, this.state.document)) return require_driver.sealChanges([]);
+			require_issue.profile.recorder("sealed");
+			return require_driver.sealChanges([{
+				kind: "reset",
+				before: this.resetBefore.value,
+				after: require_store.copyValue(this.state.schema, this.state.document)
+			}]);
 		}
-	};
-};
-//#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 = (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(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":
-		case "value.clear": return decoded(input);
-		case "dict.set": return typeof input.key === "string" && has(input, "value") ? decoded(input) : rejected("invalid-operation", "Dictionary set requires a string key and value.");
-		case "dict.delete": return typeof input.key === "string" ? decoded(input) : rejected("invalid-operation", "Dictionary delete requires a string key.");
-		case "dict.replace": return require_ownership.isRecord(input.value) ? decoded(input) : rejected("invalid-operation", "Dictionary replacement must be an object.");
-		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 changes = [];
+		for (const fact of this.facts) if (fact.kind === "members") sealMembers(fact, changes);
+		else sealTree(fact, this.state, changes);
+		const result = require_driver.sealChanges(changes);
+		require_issue.profile.recorder("sealed", result.changes.length);
+		return result;
 	}
 };
-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");
+const lexical = (a, b) => a < b ? -1 : a === b ? 0 : 1;
+//#endregion
+//#region core/src/mutation/session.ts
+var MutationSession = class {
+	identity = {};
+	generation = 0;
+	recorder;
+	resolver;
+	resolvedRoot;
+	constructor(state) {
+		this.state = state;
+		this.recorder = new ChangeRecorder(state);
+		this.resolver = require_issue.createAddressResolver(state.schema, state.document);
+		this.resolvedRoot = state.document;
+	}
+	validate(node, value, at) {
+		const issue = require_store.checkValue(node, value, at);
+		if (issue) require_issue.invalidValue(issue);
+	}
+	resolveContainer(at) {
+		return this.resolver.container(this.identity, this.generation, at) ?? require_issue.fail(at, "invalid-address", "Container does not exist.");
+	}
+	/** Bind access-resolved canonical facts without walking the address again. */
+	bind(at, node, value) {
+		return require_issue.resolveContainer(this.identity, this.generation, at, node, value) ?? require_issue.fail(at, "invalid-address", "Container does not exist.");
+	}
+	bindTree(at, node, value) {
+		return require_issue.resolveTreeContainer(this.identity, this.generation, at, node, value) ?? require_issue.fail(at, "invalid-tree", "Expected a tree.");
+	}
+	resolveTree(at) {
+		const location = require_issue.resolveValue(this.state.schema, this.state.document, at);
+		return this.bindTree(at, location?.node, location?.value);
+	}
+	replace(at, value) {
+		if (!at.length) {
+			this.validate(this.state.schema, value, at);
+			if (Object.is(this.state.document, value)) return;
+			this.recorder.reset();
+			this.state.document = require_store.copyValue(this.state.schema, value);
+			this.invalidate();
+			return;
+		}
+		this.writeMember(this.resolveContainer(at.slice(0, -1)), at[at.length - 1], value, "set");
+	}
+	assignMember(container, key, value) {
+		container = this.refresh(container);
+		const member = this.definition(container, key);
+		if (container.layout.kind === "fixed" && member.node.kind !== "field" && member.node.kind !== "variant" && !member.node.optional) return require_issue.fail(container.at.concat(key), "invalid-value", "Replace fields, variants, or collection entries; edit object members individually.");
+		this.writeLocatedMember(container, key, member, require_issue.memberKey(container, key), value, "set");
+	}
+	removeMember(container, key) {
+		this.writeMember(this.refresh(container), key, void 0, "remove");
+	}
+	refresh(container) {
+		if (container.owner !== this.identity) return require_issue.fail(container.at, "invalid-address", "Container belongs to another mutation session.");
+		return container.generation === this.generation ? container : this.resolveContainer(container.at);
+	}
+	definition(container, key) {
+		const layout = container.layout;
+		const member = layout.kind === "dynamic" ? layout.entry : layout.members.get(key);
+		if (!member) return require_issue.fail(container.at.concat(key), "invalid-address", "Address does not exist.");
+		return member;
+	}
+	/** Consume a current command-local container; bulk writes retain its storage. */
+	writeMember(container, key, value, operation, physicalKey = require_issue.memberKey(container, key)) {
+		const member = this.definition(container, key);
+		return this.writeLocatedMember(container, key, member, physicalKey, value, operation);
+	}
+	/** Location and definition are resolved once by the calling operation. */
+	writeLocatedMember(container, key, member, physicalKey, value, operation) {
+		const parentNode = container.node;
+		const node = member.node;
+		const present = operation === "set";
+		if (parentNode.kind === "variant" && parentNode.tag === key) return require_issue.fail(container.at.concat(key), "invalid-value", "Variant discriminants are read-only.");
+		const entry = container.layout.kind === "dynamic";
+		if (!present && !node.optional && !entry) return require_issue.fail(container.at.concat(key), "required-field", "A required value cannot be removed.");
+		const existed = Object.hasOwn(container.parent, physicalKey);
+		const previous = container.parent[physicalKey];
+		if (existed === present && (!present || Object.is(previous, value))) return false;
+		if (parentNode.kind === "map" || parentNode.kind === "table") {
+			const issue = require_store.checkKey(parentNode.key, key, []);
+			if (issue) return require_issue.fail(container.at.concat(key, ...issue.address), "invalid-key", issue.message);
+		}
+		if (present) {
+			if (node.kind === "field") {
+				const issue = require_store.checkValue(node, value, []);
+				if (issue) return require_issue.invalidValue(issue, container.at.concat(key, ...issue.address));
+			} else this.validate(node, value, container.at.concat(key));
+			if (parentNode.kind === "list" && parentNode.keyOf(value) !== key) return require_issue.fail(container.at.concat(key), "invalid-list-key", "Replacing an item must retain its addressed key.");
+		}
+		const membershipChanged = entry && existed !== present;
+		if (membershipChanged && (parentNode.kind === "list" || parentNode.kind === "table")) this.recorder.order(container);
+		this.recorder.member(container, key, member, physicalKey);
+		const next = present ? node.kind === "field" ? value : require_store.copyValue(node, value) : void 0;
+		installMember(container.parent, physicalKey, present, next);
+		if (node.kind !== "field" || membershipChanged) this.invalidate();
+		return membershipChanged;
+	}
+	invalidate() {
+		this.generation++;
+		if (this.resolvedRoot !== this.state.document) {
+			this.resolvedRoot = this.state.document;
+			this.resolver = require_issue.createAddressResolver(this.state.schema, this.state.document);
+		} else this.resolver.invalidate();
+	}
+	finish() {
+		return this.recorder.seal();
+	}
+	rollback() {
+		this.recorder.rollback();
+		this.invalidate();
 	}
-	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_runtime.resolveLocated(schema, root, inverse.at), true);
-			if (result.status === "rejected") throw new Error(`Document rollback failed: ${result.issue.message}`);
+//#region core/src/mutation/operations/replay.ts
+function apply(session, changes, direction) {
+	const side = direction === "forward" ? "after" : "before";
+	for (const change of changes.changes) if (change.kind === "reset") session.replace([], change[side]);
+	else if (change.kind === "members") {
+		const container = session.resolveContainer(change.at);
+		const { node, value: current } = container;
+		if (change.order) {
+			if (node.kind !== "table" && node.kind !== "list") return require_issue.fail(change.at, "invalid-changes", "Order requires an ordered container.");
+			session.recorder.order(container);
+		}
+		let membershipChanged = false;
+		for (const member of change.members) {
+			const present = side === "after" ? member.kind !== "removed" : member.kind !== "added";
+			const value = side === "after" ? member.kind !== "removed" ? member.after : void 0 : member.kind !== "added" ? member.before : void 0;
+			membershipChanged = session.writeMember(container, member.key, value, present ? "set" : "remove") || membershipChanged;
+		}
+		if (change.order) {
+			const keys = node.kind === "table" ? Object.keys(container.parent) : orderOf(node, current);
+			if (!require_issue.matches(change.order[side], keys)) return require_issue.fail(change.at, "invalid-changes", "Order must contain exactly the resulting keys.");
+			installOrder(node, current, change.order[side]);
+			session.invalidate();
+		} else if (membershipChanged && node.kind === "table") {
+			const ids = current.ids;
+			if (!require_issue.matches(ids, Object.keys(container.parent))) return require_issue.fail(change.at, "invalid-changes", "Table membership changes require a matching order.");
 		}
-		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_runtime.resolveLocated(schema, root, normalized.at);
-			if (resolved?.collection) require_ownership.profile.batch.collectionResolved();
-			require_ownership.profile.mutation.executed();
-			const result = execute(root, normalized, resolved, options.copyPayload === true || requiresPayloadCopy(normalized));
-			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)
+	} else {
+		const container = session.resolveTree(change.at);
+		const { value: current, node } = container;
+		session.recorder.tree(container);
+		for (const item of change.nodes) session.recorder.tree(container, item.id);
+		const root = change[side];
+		if (root === null) delete current.rootId;
+		else current.rootId = root;
+		for (const item of change.nodes) {
+			const next = side === "after" ? item.kind !== "removed" ? item.after : void 0 : item.kind !== "added" ? item.before : void 0;
+			installMember(current.nodes, item.id, next !== void 0, next && {
+				...next,
+				children: [...next.children]
 			});
-			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])
-		};
+		}
+		session.validate(node, current, change.at);
+		session.invalidate();
 	}
-	return session.finish();
-};
+}
 //#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,
-	source: "application",
-	...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();
+	if (input.schema.kind !== "object") throw new TypeError("Document schema must be a root object node.");
+	const invalid = require_store.checkValue(input.schema, input.initial);
+	if (invalid) throw new require_store.ParseError(invalid);
 	const state = {
 		schema: input.schema,
-		document: require_ownership.cloneValue(input.initial, "initial"),
+		document: require_store.copyValue(input.schema, input.initial),
 		disposed: false
 	};
-	let revision = 0;
-	let busy = false;
-	let runtime;
-	let notification;
-	const assertWritable = (intent) => {
-		if (state.disposed) throw new require_runtime.DocumentDisposedError();
-		if (busy) throw new require_runtime.DocumentReentrancyError();
-		if (require_runtime.accessOf(runtime).projectionLocks) throw new require_runtime.DocumentReentrancyError();
-		require_driver.assertRuntimeWritable(runtime, intent);
+	let revision = 0, busy = false;
+	let runtime, notification;
+	const idle = () => {
+		if (state.disposed) throw new require_store.DocumentDisposedError();
+		if (busy || require_store.accessOf(runtime).projectionLocks) throw new require_store.DocumentReentrancyError();
 	};
-	const runTransaction = (session, run) => {
-		let reports;
-		let active = true;
-		const transaction = {
-			read: require_runtime.documentReader(input.schema, () => state.document, () => active),
-			write: documentWriter(input.schema, (operation) => {
-				if (!active) throw new Error("Document writer is no longer active.");
-				const rejected = session.apply(operation);
-				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 writable = (intent) => {
+		idle();
+		require_driver.assertRuntimeWritable(runtime, intent);
 	};
-	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),
-		assertIdle: () => {
-			if (state.disposed) throw new require_runtime.DocumentDisposedError();
-			if (busy || require_runtime.accessOf(runtime).projectionLocks) throw new require_runtime.DocumentReentrancyError();
-		},
+		apply: (changes, direction) => mutate({
+			kind: "apply",
+			source: "history"
+		}, false, (session) => {
+			for (const change of changes) apply(session, change, direction);
+		}),
+		assertIdle: idle,
 		notify: (run) => {
 			busy = true;
 			try {
@@ -2249,210 +779,125 @@ const createDocument = (input) => {
 			}
 		}
 	});
-	const publish = (batch, source, kind, recordHistory) => {
-		revision += 1;
-		const commit = Object.freeze({
-			revision,
-			kind,
+	const publish = (changes, source, recordHistory) => {
+		const commit = {
+			revision: ++revision,
 			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);
+			changes,
+			impact: require_store.createImpact(input.schema, changes)
+		};
+		if (source === "remote") history.invalidate();
+		else if (recordHistory && (source === "local" || source === "system")) history.record(changes);
 		else if (source === "history") history.publish();
 		else history.endGroup();
-		busy = true;
-		let observerErrors;
-		try {
-			observerErrors = require_runtime.notify(notification, commit, history.flush);
-		} finally {
-			busy = false;
-		}
 		return {
 			status: "committed",
 			commit,
-			observerErrors
+			observerErrors: require_store.notify(notification, commit, history.flush)
 		};
 	};
-	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_runtime.resolveAddress(input.schema, address, state.document),
-			read: (address) => require_runtime.read(state.document, address),
-			contains: require_runtime.contains,
-			overlaps: require_runtime.overlaps,
-			debugKey: require_runtime.debugKey
-		},
-		revision: () => revision,
-		update: (run, options) => {
-			const source = options?.source ?? "local";
-			assertWritable({
-				kind: "update",
-				source
-			});
-			busy = true;
-			const session = createMutationSession(state.document, input.schema);
-			let committed = false;
+	function mutate(intent, recordHistory, execute) {
+		writable(intent);
+		busy = true;
+		try {
+			const session = new MutationSession(state);
+			let changes;
 			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 {
+				execute(session);
+				changes = session.finish();
+			} catch (error) {
+				session.rollback();
+				if (error instanceof require_issue.MutationRejected) return {
 					status: "rejected",
-					issues: batch.issues,
+					issues: [error.issue],
 					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 {
+				if (intent.kind === "update" && error instanceof require_store.TransactionRejected) return {
 					status: "rejected",
 					issues: error.issues,
 					revision
 				};
 				throw error;
-			} finally {
-				busy = false;
 			}
+			if (!changes.changes.length) return {
+				status: "unchanged",
+				revision
+			};
+			return publish(changes, intent.source, recordHistory);
+		} finally {
+			busy = false;
+		}
+	}
+	runtime = {
+		schema: input.schema,
+		address: {
+			resolve: (at) => require_issue.resolveAddress(input.schema, at, state.document),
+			read: (at) => require_issue.read(state.document, at, input.schema),
+			contains: require_issue.contains,
+			overlaps: require_issue.overlaps,
+			debugKey: require_issue.debugKey
 		},
-		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: require_runtime.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;
-			}
+		revision: () => revision,
+		update: (run, options) => {
+			const source = options?.source ?? "local";
+			let value;
+			const result = mutate({
+				kind: "update",
+				source
+			}, options?.history ?? true, (session) => {
+				value = run(require_store.createAccess({
+					state,
+					session
+				}));
+				if (value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function") throw new TypeError("Document updates must be synchronous.");
+			});
+			return result.status === "rejected" ? result : {
+				...result,
+				value
+			};
 		},
-		apply: (operations, options) => applyBatch(operations, options?.source ?? "local", options?.history ?? true),
-		replace: (document, options) => {
+		apply: (inputChanges, options) => mutate({
+			kind: "apply",
+			source: options?.source ?? "local"
+		}, options?.history ?? true, (session) => {
+			if (!options || options.expectedRevision !== revision) require_issue.fail([], "baseline-mismatch", "apply requires the current expectedRevision.");
+			apply(session, require_driver.decodeChanges(inputChanges), "forward");
+		}),
+		replace: (value, options) => {
 			const source = options?.source ?? "system";
-			assertWritable({
+			return mutate({
 				kind: "replace",
 				source
-			});
-			const invalidTree = invalidDocument(input.schema, document);
-			if (invalidTree) return {
-				status: "rejected",
-				issues: [at(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);
+			}, source !== "remote", (session) => session.replace([], value));
 		},
 		snapshot: () => {
-			if (state.disposed) throw new require_runtime.DocumentDisposedError();
-			return require_ownership.cloneValue(state.document, "snapshot");
+			if (state.disposed) throw new require_store.DocumentDisposedError();
+			return require_store.copyValue(input.schema, state.document);
 		},
-		subscribe: ((targetOrListener, listener) => {
-			if (state.disposed) throw new require_runtime.DocumentDisposedError();
-			if (typeof targetOrListener === "function") return require_runtime.subscribeRoot(notification, targetOrListener);
-			const targets = Array.isArray(targetOrListener) ? targetOrListener : [targetOrListener];
-			if (targets.length === 0 || !listener) throw new TypeError("Filtered subscribe requires at least one target and a listener.");
-			return require_runtime.subscribeTargets(notification, targets, listener);
+		subscribe: ((pick, listener) => {
+			if (state.disposed) throw new require_store.DocumentDisposedError();
+			if (!listener) return require_store.subscribeRoot(notification, pick);
+			const picks = Array.isArray(pick) ? pick : [pick];
+			if (!picks.length) throw new TypeError("Expected at least one subscription path.");
+			return require_store.subscribeTargets(notification, picks.map((p) => require_store.compilePath(input.schema, "value", p)), listener);
 		}),
 		history: history.api,
 		dispose: () => {
 			if (state.disposed) return;
-			if (busy || require_runtime.accessOf(runtime).projectionLocks) throw new require_runtime.DocumentReentrancyError();
+			idle();
 			state.disposed = true;
 			try {
-				require_runtime.disposeNotification(notification);
+				require_store.disposeNotification(notification);
 			} finally {
 				history.dispose();
 				require_driver.disposeRuntimeDriver(runtime);
 			}
 		}
 	};
-	require_runtime.bindRuntimeAccess(runtime, state);
+	require_store.bindRuntimeAccess(runtime, state);
 	require_driver.bindRuntimeDriver(runtime);
-	notification = require_runtime.createNotification(runtime);
-	require_runtime.bindDocumentReadable(history.api, runtime);
+	notification = require_store.createNotification(runtime);
+	require_store.bindDocumentReadable(history.api, runtime);
 	return runtime;
 };
 //#endregion
@@ -2463,37 +908,36 @@ const asReadable = (runtime) => {
 		revision: runtime.revision,
 		subscribe: runtime.subscribe
 	};
-	require_runtime.bindRuntimeAccess(readable, require_runtime.accessOf(runtime));
-	require_runtime.shareNotification(runtime, readable);
+	require_store.bindRuntimeAccess(readable, require_store.accessOf(runtime));
+	require_store.shareNotification(runtime, readable);
 	return Object.freeze(readable);
 };
 //#endregion
 //#region core/src/projection/select.ts
-const select = (runtime, selector) => require_runtime.readWith(runtime, selector);
+const select = (runtime, selector) => require_store.readWith(runtime, selector);
 //#endregion
-exports.DocumentDisposedError = require_runtime.DocumentDisposedError;
-exports.DocumentReentrancyError = require_runtime.DocumentReentrancyError;
-exports.ProjectionDisposedError = require_runtime.ProjectionDisposedError;
-exports.ProjectionError = require_runtime.ProjectionError;
+exports.DocumentDisposedError = require_store.DocumentDisposedError;
+exports.DocumentReentrancyError = require_store.DocumentReentrancyError;
+exports.ParseError = require_store.ParseError;
+exports.ProjectionDisposedError = require_store.ProjectionDisposedError;
+exports.ProjectionError = require_store.ProjectionError;
+exports.TransactionRejected = require_store.TransactionRejected;
 exports.asReadable = asReadable;
+exports.assign = require_store.assign;
 exports.createDocument = createDocument;
-exports.createProjectionRuntime = require_runtime.createProjectionRuntime;
-exports.dict = require_runtime.dict;
-exports.field = require_runtime.field;
-exports.list = require_runtime.list;
-exports.map = require_runtime.map;
-exports.object = require_runtime.object;
-exports.optional = require_runtime.optional;
-exports.schema = require_runtime.schema;
+exports.createProjectionStore = require_store.createProjectionStore;
+exports.field = require_store.field;
+exports.input = require_store.input;
+exports.list = require_store.list;
+exports.map = require_store.map;
+exports.object = require_store.object;
+exports.optional = require_store.optional;
+exports.parse = require_store.parse;
+exports.project = require_store.project;
 exports.select = select;
-exports.table = require_runtime.table;
-Object.defineProperty(exports, "target", {
-	enumerable: true,
-	get: function() {
-		return require_runtime.impact_target_exports;
-	}
-});
-exports.tree = require_runtime.tree;
-exports.variant = require_runtime.variant;
+exports.snapshot = require_store.snapshot;
+exports.table = require_store.table;
+exports.tree = require_store.tree;
+exports.variant = require_store.variant;
 
 //# sourceMappingURL=index.cjs.map