doxum 0.1.1 → 0.1.2

package/dist/index.cjs

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