doxum 0.1.7 → 0.1.9

package/dist/runtime-DF1q9Gje.js

@@ -1,2129 +0,0 @@
-import { t as __exportAll } from "./chunk-pbuEa-1d.js";
-import { i as isRecord$1, t as cloneValue, u as profile } from "./ownership-CduRygE7.js";
-//#region core/src/schema.ts
-const node = (value) => Object.freeze(value);
-const field = () => node({ kind: "field" });
-const optional = (value) => {
-	if (![
-		"field",
-		"variant",
-		"dict",
-		"list",
-		"tree"
-	].includes(value.kind)) throw new TypeError("Only field, variant, dict, list and tree nodes support optional presence.");
-	return node({
-		...value,
-		optional: true
-	});
-};
-const object = (shape) => node({
-	kind: "object",
-	shape
-});
-const variant = (tag, variants) => node({
-	kind: "variant",
-	tag,
-	variants
-});
-const table = (value) => node({
-	kind: "table",
-	value
-});
-const map = (value) => node({
-	kind: "map",
-	value
-});
-const dict = () => node({ kind: "dict" });
-const list = (config) => ({
-	kind: "list",
-	keyOf: config.keyOf
-});
-const tree = () => node({ kind: "tree" });
-const paths = /* @__PURE__ */ new WeakMap();
-const collectionSchemas = /* @__PURE__ */ new WeakMap();
-const collectionSchema = (selector) => {
-	const node = collectionSchemas.get(selector);
-	if (!node) throw new TypeError("Expected a schema-owned collection selector.");
-	return node;
-};
-const pathProxy = (nodes, address, owner) => {
-	const proxy = new Proxy({}, { get: (_target, property) => {
-		if (typeof property !== "string") return void 0;
-		if (nodes.every((node) => node.kind === "table" || node.kind === "map") && property === "item") return (id) => {
-			if (typeof id !== "string") throw new TypeError("Collection keys must be strings.");
-			return pathProxy(nodes.map((node) => node.value), [...address, id], owner);
-		};
-		const children = nodes.flatMap((node) => {
-			if (node.kind === "object") return node.shape[property] ? [node.shape[property]] : [];
-			if (node.kind !== "variant") return [];
-			if (property === node.tag) return [field()];
-			return Object.values(node.variants).flatMap((branch) => branch.shape[property] ? [branch.shape[property]] : []);
-		});
-		if (!children.length) throw new TypeError(`Invalid schema path segment: ${property}`);
-		return pathProxy(children, [...address, property], owner);
-	} });
-	paths.set(proxy, {
-		nodes,
-		address,
-		owner
-	});
-	return proxy;
-};
-const select = (owner, kind, pick) => {
-	const scope = {};
-	const value = pick(pathProxy([object(owner.shape)], [], scope));
-	const selected = typeof value === "object" && value !== null ? paths.get(value) : void 0;
-	if (!selected || selected.owner !== scope) throw new TypeError("Selector must return a path from its callback.");
-	if (kind === "collection" && !selected.nodes.every((node) => node.kind === "table" || node.kind === "map")) throw new TypeError("Collection selectors require a table or map path.");
-	const result = Object.freeze({
-		kind,
-		schema: owner,
-		address: Object.freeze([...selected.address])
-	});
-	if (kind === "collection") collectionSchemas.set(result, selected.nodes[0]);
-	return result;
-};
-const schema = (shape) => {
-	const result = {
-		kind: "schema",
-		shape,
-		collection: (pick) => select(result, "collection", pick),
-		value: (pick) => select(result, "value", pick)
-	};
-	return Object.freeze(result);
-};
-//#endregion
-//#region core/src/address.ts
-const registries = /* @__PURE__ */ new WeakMap();
-const registryNode = () => ({ static: /* @__PURE__ */ new Map() });
-const registryFor = (schema) => {
-	const cached = registries.get(schema);
-	if (cached) return cached;
-	const registry = {
-		root: registryNode(),
-		nextPath: 0
-	};
-	registries.set(schema, registry);
-	return registry;
-};
-const hashText = (value, seed) => {
-	let hash = seed;
-	for (let index = 0; index < value.length; index += 1) hash = Math.imul(hash ^ value.charCodeAt(index), 16777619);
-	return hash >>> 0;
-};
-const appendAddressHash = (hash, segment) => hashText(segment, hashText("/", hash));
-const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const variantNode = (node, value) => {
-	const tag = isRecord(value) && typeof value[node.tag] === "string" ? value[node.tag] : void 0;
-	return node.variants[String(tag ?? Object.keys(node.variants)[0] ?? "")];
-};
-const schemaRoot$1 = (schema) => ({
-	kind: "object",
-	shape: schema.shape
-});
-const step = (nodeInput, value, segment) => {
-	let node = nodeInput;
-	if (!node) return {
-		node: void 0,
-		dynamic: false
-	};
-	if (node.kind === "variant") node = variantNode(node, value);
-	if (!node) return {
-		node: void 0,
-		dynamic: false
-	};
-	if (node.kind === "object") return {
-		node: node.shape[segment],
-		dynamic: false
-	};
-	if (node.kind === "table" || node.kind === "map") return {
-		node: node.value,
-		dynamic: true
-	};
-	if (node.kind === "dict" || node.kind === "list" || node.kind === "tree") return {
-		node,
-		dynamic: true
-	};
-	return {
-		node: void 0,
-		dynamic: false
-	};
-};
-const pathFor = (schema, address, document) => {
-	const registry = registryFor(schema);
-	let trie = registry.root;
-	let node = schemaRoot$1(schema);
-	let value = document;
-	for (const segment of address) {
-		profile.address.schemaStep();
-		profile.address.documentStep();
-		const resolved = step(node, value, segment);
-		if (!resolved.node) return void 0;
-		trie = resolved.dynamic ? trie.dynamic ??= registryNode() : (() => {
-			const existing = trie.static.get(segment);
-			if (existing) return existing;
-			const created = registryNode();
-			trie.static.set(segment, created);
-			return created;
-		})();
-		node = resolved.node;
-		value = readSegment(value, segment);
-	}
-	if (trie.path === void 0) trie.path = registry.nextPath++;
-	return trie.path;
-};
-const resolveAddress = (schema, address, document) => {
-	if (!Array.isArray(address)) return void 0;
-	for (const segment of address) if (typeof segment !== "string") return void 0;
-	profile.address.arrayCopied();
-	const owned = Object.freeze(address.slice());
-	const path = pathFor(schema, owned, document);
-	return path === void 0 ? void 0 : {
-		path,
-		address: owned
-	};
-};
-const nodeAt = (schema, address, document) => {
-	let node = schemaRoot$1(schema);
-	let value = document;
-	for (const segment of address) {
-		node = step(node, value, segment).node;
-		value = readSegment(value, segment);
-		if (!node) return void 0;
-	}
-	return node;
-};
-const readSegment = (value, segment) => {
-	if (!isRecord(value) && !Array.isArray(value)) return void 0;
-	if (isRecord(value) && "byId" in value && isRecord(value.byId)) {
-		const entity = value.byId[segment];
-		if (entity !== void 0 || Object.prototype.hasOwnProperty.call(value.byId, segment)) return entity;
-	}
-	return value[segment];
-};
-const read = (root, address) => {
-	let value = root;
-	for (const segment of address) {
-		value = readSegment(value, segment);
-		if (value === void 0) return void 0;
-	}
-	return value;
-};
-/** Resolves schema and document location in one address traversal. */
-const resolveLocated = (schema, root, address) => {
-	if (address.length === 0) return void 0;
-	let node = schemaRoot$1(schema);
-	let current = root;
-	let collection;
-	let addressHash = 2166136261;
-	for (let index = 0; index < address.length - 1; index += 1) {
-		profile.address.schemaStep();
-		profile.address.documentStep();
-		const resolved = step(node, current, address[index]);
-		if (!resolved.node) return void 0;
-		if (node?.kind === "table" || node?.kind === "map") collection = {
-			address: address.slice(0, index),
-			addressHash,
-			id: address[index],
-			...collection ? { parent: collection } : {}
-		};
-		addressHash = appendAddressHash(addressHash, address[index]);
-		node = resolved.node;
-		current = readSegment(current, address[index]);
-		if (!node) return void 0;
-	}
-	profile.address.schemaStep();
-	profile.address.documentStep();
-	const last = address[address.length - 1];
-	const resolved = step(node, current, last);
-	if (!resolved.node || !isRecord(current) && !Array.isArray(current)) return void 0;
-	if (node?.kind === "table" || node?.kind === "map") collection = {
-		address: address.slice(0, -1),
-		addressHash,
-		id: last,
-		...collection ? { parent: collection } : {}
-	};
-	addressHash = appendAddressHash(addressHash, last);
-	if (isRecord(current) && "byId" in current && isRecord(current.byId) && last in current.byId) return {
-		addressHash,
-		node: resolved.node,
-		parent: current.byId,
-		key: last,
-		value: current.byId[last],
-		...collection ? { collection } : {}
-	};
-	return {
-		addressHash,
-		node: resolved.node,
-		parent: current,
-		key: Array.isArray(current) && /^\d+$/.test(last) ? Number(last) : last,
-		value: readSegment(current, last),
-		...collection ? { collection } : {}
-	};
-};
-const locate = (root, address) => {
-	if (address.length === 0) return void 0;
-	let current = root;
-	for (let index = 0; index < address.length - 1; index += 1) current = readSegment(current, address[index]);
-	if (!isRecord(current) && !Array.isArray(current)) return void 0;
-	const last = address[address.length - 1];
-	if (isRecord(current) && "byId" in current && isRecord(current.byId) && last in current.byId) return {
-		parent: current.byId,
-		key: last,
-		value: current.byId[last]
-	};
-	return {
-		parent: current,
-		key: Array.isArray(current) && /^\d+$/.test(last) ? Number(last) : last,
-		value: readSegment(current, last)
-	};
-};
-const set = (root, address, value) => {
-	const target = locate(root, address);
-	if (!target) return false;
-	target.parent[target.key] = value;
-	return true;
-};
-const contains = (parent, child) => {
-	profile.address.prefixComparison();
-	if (parent.length > child.length) return false;
-	for (let index = 0; index < parent.length; index += 1) {
-		profile.address.segmentCompared();
-		if (parent[index] !== child[index]) return false;
-	}
-	return true;
-};
-const overlaps = (a, b) => contains(a, b) || contains(b, a);
-const debugKey = (address) => {
-	let result = "";
-	for (let index = 0; index < address.length; index += 1) {
-		if (index > 0) result += "/";
-		result += address[index].replaceAll("~", "~~").replaceAll("/", "~/");
-	}
-	return result;
-};
-//#endregion
-//#region core/src/impact-target.ts
-var impact_target_exports = /* @__PURE__ */ __exportAll({
-	address: () => address$1,
-	belongs: () => belongs,
-	bucket: () => bucket,
-	id: () => id,
-	same: () => same
-});
-const address$1 = (target) => "at" in target ? target.at : target.address;
-const id = (target) => target.kind === "collection" && "id" in target ? target.id : void 0;
-const belongs = (target, schema) => !("schema" in target) || target.schema === schema;
-const same = (left, right) => {
-	if (left.kind !== right.kind) return false;
-	if ("schema" in left && "schema" in right && left.schema !== right.schema) return false;
-	const leftAddress = address$1(left);
-	const rightAddress = address$1(right);
-	if (leftAddress.length !== rightAddress.length) return false;
-	for (let index = 0; index < leftAddress.length; index += 1) if (leftAddress[index] !== rightAddress[index]) return false;
-	return left.kind !== "collection" || id(left) === id(right);
-};
-const bucket = (target) => address$1(target)[0];
-//#endregion
-//#region core/src/runtime/contract.ts
-var DocumentReentrancyError = class extends Error {
-	constructor() {
-		super("Document writes cannot be re-entered during an update or notification.");
-		this.name = "DocumentReentrancyError";
-	}
-};
-var DocumentDisposedError = class extends Error {
-	constructor() {
-		super("Doxum runtime has been disposed.");
-		this.name = "DocumentDisposedError";
-	}
-};
-//#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/access/reader.ts
-const schemaRoot = (schema) => object(schema.shape);
-const assertActive = (context) => {
-	if (!context.active()) throw new Error("Document reader is no longer active.");
-};
-const readAt = (context, address) => {
-	assertActive(context);
-	profile.reader.lookup();
-	return read(context.root(), address);
-};
-const collectValue = (context, address) => {
-	context.dependencies?.record({
-		kind: "value",
-		at: address
-	});
-};
-const collectCollection = (context, address, id) => {
-	const target = {
-		kind: "collection",
-		at: address,
-		...id === void 0 ? {} : { id }
-	};
-	context.dependencies?.record(target);
-};
-const readerFor = (node, context, address = []) => {
-	if (node.kind === "field") return { get: () => {
-		collectValue(context, address);
-		return readAt(context, address);
-	} };
-	if (node.kind === "dict") return {
-		get: (key) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return cloneValue(isRecord$1(value) && Object.prototype.hasOwnProperty.call(value, key) ? value[key] : void 0, "reader");
-		},
-		has: (key) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return isRecord$1(value) && Object.prototype.hasOwnProperty.call(value, key);
-		},
-		keys: () => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return isRecord$1(value) ? Object.keys(value) : [];
-		},
-		values: () => {
-			collectValue(context, address);
-			profile.reader.structuralSnapshot();
-			return cloneValue(readAt(context, address) ?? {}, "reader");
-		}
-	};
-	if (node.kind === "list") return {
-		get: (key) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			if (!Array.isArray(value)) return void 0;
-			return cloneValue(value[keys(value, node.keyOf).index(key)], "reader");
-		},
-		has: (key) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return Array.isArray(value) && keys(value, node.keyOf).index(key) >= 0;
-		},
-		values: () => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			profile.reader.structuralSnapshot();
-			return cloneValue(Array.isArray(value) ? value : [], "reader");
-		},
-		length: () => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return Array.isArray(value) ? value.length : 0;
-		},
-		at: (index) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			profile.reader.structuralSnapshot();
-			return cloneValue(Array.isArray(value) ? value[index] : void 0, "reader");
-		}
-	};
-	if (node.kind === "tree") return {
-		rootId: () => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return isRecord$1(value) && typeof value.rootId === "string" ? value.rootId : void 0;
-		},
-		has: (id) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return isRecord$1(value) && isRecord$1(value.nodes) && Object.prototype.hasOwnProperty.call(value.nodes, id);
-		},
-		value: (id) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			profile.reader.structuralSnapshot();
-			return cloneValue(isRecord$1(value) && isRecord$1(value.nodes) && isRecord$1(value.nodes[id]) ? value.nodes[id].value : void 0, "reader");
-		},
-		parent: (id) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			const entry = isRecord$1(value) && isRecord$1(value.nodes) ? value.nodes[id] : void 0;
-			return isRecord$1(entry) && typeof entry.parentId === "string" ? entry.parentId : void 0;
-		},
-		children: (id) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			const entry = isRecord$1(value) && isRecord$1(value.nodes) ? value.nodes[id] : void 0;
-			return isRecord$1(entry) && Array.isArray(entry.children) ? [...entry.children] : [];
-		}
-	};
-	if (node.kind === "table" || node.kind === "map") {
-		let items;
-		return {
-			ids: () => {
-				collectCollection(context, address);
-				const value = readAt(context, address);
-				const ids = node.kind === "table" && isRecord$1(value) && Array.isArray(value.ids) ? [...value.ids] : isRecord$1(value) ? Object.keys(value) : [];
-				profile.reader.collectionIds(ids.length);
-				return ids;
-			},
-			has: (id) => {
-				collectCollection(context, address, id);
-				const value = readAt(context, address);
-				const byId = node.kind === "table" && isRecord$1(value) && isRecord$1(value.byId) ? value.byId : value;
-				return isRecord$1(byId) && Object.prototype.hasOwnProperty.call(byId, id);
-			},
-			get: (id) => {
-				collectCollection(context, address, id);
-				const value = readAt(context, address);
-				const byId = node.kind === "table" && isRecord$1(value) && isRecord$1(value.byId) ? value.byId : value;
-				if (!isRecord$1(byId) || !Object.prototype.hasOwnProperty.call(byId, id)) return void 0;
-				const cached = items?.get(id);
-				if (cached) return cached;
-				const reader = readerFor(node.value, context, [...address, id]);
-				(items ??= /* @__PURE__ */ new Map()).set(id, reader);
-				return reader;
-			}
-		};
-	}
-	if (node.kind === "variant") return { get: () => {
-		collectValue(context, address);
-		return cloneValue(readAt(context, address), "reader");
-	} };
-	let children;
-	return new Proxy({}, { get: (_target, property) => {
-		if (typeof property === "symbol") return void 0;
-		const child = node.shape[property];
-		if (!child) return void 0;
-		const cached = children?.get(property);
-		if (cached) return cached;
-		const reader = readerFor(child, context, [...address, property]);
-		(children ??= /* @__PURE__ */ new Map()).set(property, reader);
-		return reader;
-	} });
-};
-const documentReader = (schema, root, active, dependencies) => {
-	profile.reader.session();
-	return readerFor(schemaRoot(schema), {
-		root,
-		active,
-		dependencies
-	});
-};
-//#endregion
-//#region core/src/mutation/footprint.ts
-const sameAddress = (left, right) => left.length === right.length && left.every((segment, index) => segment === right[index]);
-const containsAddress = (parent, child) => parent.length <= child.length && parent.every((segment, index) => segment === child[index]);
-const address = (value) => Array.isArray(value) && value.every((segment) => typeof segment === "string") ? Object.freeze(value.slice()) : void 0;
-const targetKey = (target) => {
-	const at = target.at.join("\0");
-	if (target.kind === "dictionary-key" || target.kind === "list-item") return `${target.kind}:${at}:${target.key}`;
-	if (target.kind === "entity" || target.kind === "tree-node") return `${target.kind}:${at}:${target.id}`;
-	return `${target.kind}:${at}`;
-};
-const freezeTarget = (target) => Object.freeze({
-	...target,
-	at: Object.freeze(target.at.slice())
-});
-const add = (targets, target) => {
-	const stable = freezeTarget(target);
-	targets.set(targetKey(stable), stable);
-};
-const commandFootprint = (operations) => {
-	const targets = /* @__PURE__ */ new Map();
-	for (const operation of operations) switch (operation.type) {
-		case "field.set":
-		case "field.clear":
-		case "value.clear":
-		case "variant.replace":
-			add(targets, {
-				kind: "value",
-				at: operation.at
-			});
-			break;
-		case "dict.replace":
-			add(targets, {
-				kind: "dictionary",
-				at: operation.at
-			});
-			break;
-		case "dict.set":
-		case "dict.delete":
-			add(targets, {
-				kind: "dictionary-key",
-				at: operation.at,
-				key: operation.key
-			});
-			break;
-		case "entity.create":
-			add(targets, {
-				kind: "collection",
-				at: operation.at
-			});
-			for (const entry of operation.entries) add(targets, {
-				kind: "entity",
-				at: operation.at,
-				id: entry.id
-			});
-			break;
-		case "entity.remove":
-			add(targets, {
-				kind: "collection",
-				at: operation.at
-			});
-			for (const id of operation.ids) add(targets, {
-				kind: "entity",
-				at: operation.at,
-				id
-			});
-			break;
-		case "entity.move":
-			add(targets, {
-				kind: "collection",
-				at: operation.at
-			});
-			add(targets, {
-				kind: "entity",
-				at: operation.at,
-				id: operation.id
-			});
-			break;
-		case "list.insert":
-		case "list.move":
-		case "list.remove":
-			add(targets, {
-				kind: "list",
-				at: operation.at
-			});
-			add(targets, {
-				kind: "list-item",
-				at: operation.at,
-				key: operation.key
-			});
-			break;
-		case "list.replace":
-			add(targets, {
-				kind: "list",
-				at: operation.at
-			});
-			for (const key of operation.keys) add(targets, {
-				kind: "list-item",
-				at: operation.at,
-				key
-			});
-			break;
-		case "tree.insert":
-		case "tree.move":
-		case "tree.remove":
-		case "tree.set":
-			add(targets, {
-				kind: "tree",
-				at: operation.at
-			});
-			add(targets, {
-				kind: "tree-node",
-				at: operation.at,
-				id: operation.treeNodeId
-			});
-			break;
-		case "tree.replace":
-			add(targets, {
-				kind: "tree",
-				at: operation.at
-			});
-			break;
-	}
-	return Object.freeze(Array.from(targets.values()));
-};
-const overlapsValueAndEntity = (value, entity) => containsAddress([...entity.at, entity.id], value.at) || containsAddress(value.at, [...entity.at, entity.id]);
-const targetsOverlap = (left, right) => {
-	if (left.kind === "value" && right.kind === "value") return containsAddress(left.at, right.at) || containsAddress(right.at, left.at);
-	if (left.kind === "value" && right.kind === "entity") return overlapsValueAndEntity(left, right);
-	if (left.kind === "entity" && right.kind === "value") return overlapsValueAndEntity(right, left);
-	if (left.kind === "dictionary" && right.kind === "dictionary") return sameAddress(left.at, right.at);
-	if (left.kind === "dictionary" && right.kind === "dictionary-key") return sameAddress(left.at, right.at);
-	if (left.kind === "dictionary-key" && right.kind === "dictionary") return sameAddress(left.at, right.at);
-	if (left.kind === "dictionary-key" && right.kind === "dictionary-key") return sameAddress(left.at, right.at) && left.key === right.key;
-	if (left.kind === "collection" && right.kind === "collection") return sameAddress(left.at, right.at);
-	if (left.kind === "collection" && right.kind === "entity") return sameAddress(left.at, right.at);
-	if (left.kind === "entity" && right.kind === "collection") return sameAddress(left.at, right.at);
-	if (left.kind === "entity" && right.kind === "entity") return sameAddress(left.at, right.at) && left.id === right.id;
-	if (left.kind === "list" && (right.kind === "list" || right.kind === "list-item")) return sameAddress(left.at, right.at);
-	if (right.kind === "list" && left.kind === "list-item") return sameAddress(left.at, right.at);
-	if (left.kind === "list-item" && right.kind === "list-item") return sameAddress(left.at, right.at) && left.key === right.key;
-	if (left.kind === "tree" && (right.kind === "tree" || right.kind === "tree-node")) return sameAddress(left.at, right.at);
-	if (right.kind === "tree" && left.kind === "tree-node") return sameAddress(left.at, right.at);
-	if (left.kind === "tree-node" && right.kind === "tree-node") return sameAddress(left.at, right.at) && left.id === right.id;
-	return false;
-};
-const footprintsOverlap = (left, right) => left.some((leftTarget) => right.some((rightTarget) => targetsOverlap(leftTarget, rightTarget)));
-const decodedTarget = (value) => {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
-	const record = value;
-	const at = address(record.at);
-	if (!at || typeof record.kind !== "string") return void 0;
-	switch (record.kind) {
-		case "value":
-		case "dictionary":
-		case "collection":
-		case "list":
-		case "tree": return freezeTarget({
-			kind: record.kind,
-			at
-		});
-		case "dictionary-key":
-		case "list-item": return typeof record.key === "string" ? freezeTarget({
-			kind: record.kind,
-			at,
-			key: record.key
-		}) : void 0;
-		case "entity":
-		case "tree-node": return typeof record.id === "string" ? freezeTarget({
-			kind: record.kind,
-			at,
-			id: record.id
-		}) : void 0;
-		default: return;
-	}
-};
-const decodeCommandFootprint = (value) => {
-	if (!Array.isArray(value)) return void 0;
-	const targets = /* @__PURE__ */ new Map();
-	for (const entry of value) {
-		const target = decodedTarget(entry);
-		if (!target) return void 0;
-		targets.set(targetKey(target), target);
-	}
-	return Object.freeze(Array.from(targets.values()));
-};
-//#endregion
-//#region core/src/runtime/access.ts
-const states = /* @__PURE__ */ new WeakMap();
-const bindRuntimeAccess = (runtime, state) => {
-	states.set(runtime, state);
-};
-const accessOf = (runtime) => {
-	const state = states.get(runtime);
-	if (!state) throw new Error("Unknown Doxum runtime.");
-	return state;
-};
-const readWith = (runtime, run, dependencies) => {
-	const state = accessOf(runtime);
-	if (state.disposed) throw new DocumentDisposedError();
-	let active = true;
-	const reader = documentReader(state.schema, () => state.document, () => active, dependencies);
-	try {
-		return run(reader);
-	} finally {
-		active = false;
-	}
-};
-//#endregion
-//#region core/src/runtime/notification.ts
-const ROOT_BUCKET = Symbol("document-root");
-const notifications = /* @__PURE__ */ new WeakMap();
-const readableOwners = /* @__PURE__ */ new WeakMap();
-const bindDocumentReadable = (readable, runtime) => {
-	readableOwners.set(readable, runtime);
-};
-const documentReadableOwner = (readable) => readableOwners.get(readable);
-const key = (value) => bucket(value) ?? ROOT_BUCKET;
-const createNotification = (runtime) => {
-	const notification = {
-		root: /* @__PURE__ */ new Set(),
-		filtered: /* @__PURE__ */ new Set(),
-		buckets: /* @__PURE__ */ new Map(),
-		processors: [],
-		candidates: /* @__PURE__ */ new Set(),
-		rootSnapshot: [],
-		notifying: false
-	};
-	notifications.set(runtime, notification);
-	return notification;
-};
-const notificationOf = (runtime) => {
-	const value = notifications.get(runtime);
-	if (!value) throw new Error("Unknown Doxum runtime.");
-	return value;
-};
-const shareNotification = (source, target) => {
-	notifications.set(target, notificationOf(source));
-};
-const attachProjection = (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, afterSettle) => {
-	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.capture(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.settle();
-			} 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 {
-				errors.push(...entry.processor.flush());
-			} catch (error) {
-				errors.push(Object.freeze({
-					phase: "flush",
-					error
-				}));
-			}
-		}
-		if (afterSettle) errors.push(...afterSettle());
-		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) => {
-	const attachments = notification.processors.slice();
-	notification.root.clear();
-	notification.filtered.clear();
-	notification.buckets.clear();
-	notification.processors.length = 0;
-	notification.candidates.clear();
-	notification.rootSnapshot.length = 0;
-	const errors = [];
-	attachments.forEach((entry) => {
-		if (!entry.active) return;
-		try {
-			entry.processor.dispose();
-		} catch (error) {
-			errors.push(error);
-		}
-	});
-	if (errors.length) throw new AggregateError(errors, "Projection disposal notification failed.");
-};
-//#endregion
-//#region core/src/projection/contract.ts
-var ProjectionError = class extends Error {
-	constructor(phase, identity, revisions, cause) {
-		super(`Projection ${phase} failed: ${identity}`, { cause });
-		this.phase = phase;
-		this.identity = identity;
-		this.revisions = revisions;
-		this.name = "ProjectionError";
-	}
-};
-var ProjectionDisposedError = class extends Error {
-	constructor() {
-		super("Projection has been disposed.");
-		this.name = "ProjectionDisposedError";
-	}
-};
-//#endregion
-//#region core/src/projection/scheduler.ts
-const projectionHandles = /* @__PURE__ */ new WeakSet();
-const createScheduler = (onError) => {
-	let disposed = false;
-	let depth = 0;
-	let phase = "idle";
-	let sequence = 0;
-	const records = /* @__PURE__ */ new Map();
-	const nodes = /* @__PURE__ */ new Set();
-	const pending = /* @__PURE__ */ new Set();
-	const heap = [];
-	const queued = /* @__PURE__ */ new Set();
-	const completed = [];
-	const emissions = /* @__PURE__ */ new Set();
-	const errors = [];
-	let reportingFailures = [];
-	const guards = /* @__PURE__ */ new Set();
-	const cleanups = /* @__PURE__ */ new Set();
-	const assertActive = () => {
-		if (disposed) throw new ProjectionDisposedError();
-	};
-	const assertIdle = () => {
-		assertActive();
-		if (phase !== "idle") throw new Error("Projection cannot be re-entered during processing or notification.");
-	};
-	const lock = (value) => guards.forEach((guard) => guard(value));
-	const enqueue = (node) => {
-		if (node.disposed || queued.has(node)) return;
-		queued.add(node);
-		profile.projection("scheduledNodes");
-		let i = heap.length;
-		heap.push(node);
-		while (i > 0) {
-			const p = i - 1 >> 1;
-			if (heap[p].order < node.order) break;
-			heap[i] = heap[p];
-			i = p;
-		}
-		heap[i] = node;
-	};
-	const pop = () => {
-		const first = heap[0];
-		const last = heap.pop();
-		if (heap.length) {
-			let i = 0;
-			while (i * 2 + 1 < heap.length) {
-				let c = i * 2 + 1;
-				if (c + 1 < heap.length && heap[c + 1].order < heap[c].order) c++;
-				if (last.order < heap[c].order) break;
-				heap[i] = heap[c];
-				i = c;
-			}
-			heap[i] = last;
-		}
-		return first;
-	};
-	const errorFor = (node, cause, kind = "processor") => new ProjectionError(kind, node.name, node.sources.map((source) => source.revision()), cause);
-	const capture = (source) => {
-		if (disposed) return;
-		if (phase !== "idle") {
-			source.fault = new ProjectionError("source", "reentrant source", [source.revision()], /* @__PURE__ */ new Error("Source changed while projection was running."));
-			errors.push(source.fault);
-			throw source.fault;
-		}
-		pending.add(source);
-		profile.projection("sourceEvents");
-		if (source.fault) errors.push(source.fault);
-	};
-	const settle = () => {
-		if (disposed || depth || phase !== "idle") return;
-		phase = "compute";
-		lock(true);
-		try {
-			pending.forEach((source) => source.consumers.forEach(enqueue));
-			while (heap.length) {
-				const node = pop();
-				if (node.disposed) continue;
-				const wasFaulted = node.fault !== void 0;
-				profile.projection("processedNodes");
-				let changed = false;
-				const blocked = node.sources.find((source) => source.fault || source.disposed);
-				if (blocked) node.fault = errorFor(node, blocked.fault ?? new ProjectionDisposedError(), "blocked");
-				else {
-					const build = node.forced || wasFaulted || node.sources.some((source) => source.reset());
-					try {
-						changed = node.evaluate(build);
-						const failure = node.sources.find((source) => source.fault)?.fault;
-						if (failure) throw failure;
-						node.fault = void 0;
-					} catch (cause) {
-						const error = errorFor(node, cause);
-						errors.push(error);
-						node.fault = error;
-						if (!build) try {
-							changed = node.evaluate(true);
-							const failure = node.sources.find((source) => source.fault)?.fault;
-							if (failure) throw failure;
-							node.fault = void 0;
-						} catch (cause) {
-							node.fault = errorFor(node, cause);
-							errors.push(node.fault);
-						}
-					}
-				}
-				node.forced = false;
-				node.statusChanged = wasFaulted !== (node.fault !== void 0);
-				completed.push(node);
-				if (changed || wasFaulted || node.fault) {
-					profile.projection("publishedNodes");
-					emissions.add(node);
-					node.consumers.forEach(enqueue);
-				}
-			}
-			completed.forEach((node) => node.publish());
-		} finally {
-			lock(false);
-			phase = "idle";
-		}
-	};
-	const flush = () => {
-		if (disposed || depth) return [];
-		if (pending.size || completed.length) profile.projection("flushes");
-		phase = "notify";
-		lock(true);
-		const reportFailures = [];
-		try {
-			emissions.forEach((node) => node.emit((listener) => {
-				try {
-					listener();
-				} catch (cause) {
-					errors.push(errorFor(node, cause, "listener"));
-				}
-			}));
-			for (const error of errors.slice()) try {
-				onError(error);
-			} catch (cause) {
-				reportFailures.push(cause);
-			}
-			return Object.freeze([...errors.map((error) => Object.freeze({
-				phase: error.phase === "listener" ? "listener" : "processor",
-				error
-			})), ...reportFailures.map((error) => Object.freeze({
-				phase: "listener",
-				error
-			}))]);
-		} finally {
-			pending.forEach((source) => source.clear());
-			completed.forEach((node) => node.clear());
-			pending.clear();
-			queued.clear();
-			completed.length = 0;
-			emissions.clear();
-			errors.length = 0;
-			reportingFailures = reportFailures;
-			lock(false);
-			phase = "idle";
-		}
-	};
-	const run = () => {
-		settle();
-		const result = flush();
-		const failures = reportingFailures;
-		reportingFailures = [];
-		if (failures.length) throw new AggregateError(failures, "Projection error reporter failed.");
-		return result;
-	};
-	return {
-		assertActive,
-		assertIdle,
-		capture,
-		settle,
-		flush,
-		run,
-		records,
-		guards,
-		cleanups,
-		get active() {
-			return !disposed;
-		},
-		register(handle, record) {
-			assertIdle();
-			records.set(handle, record);
-			projectionHandles.add(handle);
-		},
-		unregisterSource(handle) {
-			const record = records.get(handle);
-			if (record) {
-				record.disposed = true;
-				pending.delete(record);
-				record.clear();
-				records.delete(handle);
-			}
-		},
-		source(handle) {
-			assertActive();
-			const source = records.get(handle);
-			if (!source || source.disposed) throw new Error("Unknown, disposed, or foreign projection source.");
-			return source;
-		},
-		addNode(node) {
-			nodes.add(node);
-			node.sources.forEach((source) => source.consumers.add(node));
-		},
-		order: () => sequence++,
-		initialize(run) {
-			assertIdle();
-			phase = "compute";
-			lock(true);
-			try {
-				return run();
-			} finally {
-				lock(false);
-				phase = "idle";
-			}
-		},
-		rebuild(node) {
-			assertIdle();
-			if (node.disposed) throw new ProjectionDisposedError();
-			node.forced = true;
-			enqueue(node);
-			run();
-		},
-		disposeNode(node) {
-			if (node.disposed) return;
-			assertIdle();
-			if (node.consumers.size) throw new Error("Cannot dispose a projection node with downstream consumers.");
-			node.disposed = true;
-			node.sources.forEach((source) => source.consumers.delete(node));
-			nodes.delete(node);
-			node.release();
-			for (const [handle, record] of records) if (record === node) records.delete(handle);
-		},
-		batch(callback) {
-			assertIdle();
-			depth++;
-			let failed = false;
-			try {
-				const value = callback();
-				assertSynchronous(value);
-				return value;
-			} catch (error) {
-				failed = true;
-				throw error;
-			} finally {
-				depth--;
-				if (!depth) if (failed) try {
-					run();
-				} catch {}
-				else run();
-			}
-		},
-		dispose() {
-			if (disposed) return;
-			assertIdle();
-			disposed = true;
-			const failures = [];
-			cleanups.forEach((cleanup) => {
-				try {
-					cleanup();
-				} catch (error) {
-					failures.push(error);
-				}
-			});
-			cleanups.clear();
-			nodes.forEach((node) => {
-				node.disposed = true;
-				node.release();
-				node.consumers.clear();
-			});
-			records.forEach((source) => {
-				source.disposed = true;
-				source.consumers.clear();
-				source.clear();
-			});
-			nodes.clear();
-			records.clear();
-			pending.clear();
-			heap.length = 0;
-			completed.length = 0;
-			queued.clear();
-			emissions.clear();
-			guards.clear();
-			errors.length = 0;
-			reportingFailures = [];
-			if (failures.length) throw new AggregateError(failures, "Projection cleanup failed.");
-		},
-		debug: () => ({
-			nodes: nodes.size,
-			sources: records.size - nodes.size,
-			subscriptions: cleanups.size,
-			pending: pending.size + heap.length
-		})
-	};
-};
-const assertSynchronous = (value) => {
-	if (value != null && (typeof value === "object" || typeof value === "function") && "then" in value && typeof value.then === "function") throw new TypeError("Projection callbacks must be synchronous.");
-};
-const assertScope = (active) => {
-	if (!active()) throw new Error("Projection reader or writer is no longer active.");
-};
-//#endregion
-//#region core/src/projection/node.ts
-const createNode = (scheduler, spec, behavior) => {
-	scheduler.assertIdle();
-	const entries = Object.entries(spec.sources).map(([key, handle]) => [key, scheduler.source(handle)]);
-	const order = scheduler.order();
-	const node = {
-		...behavior,
-		publish: () => {
-			if (node.fault) behavior.clear();
-			else behavior.publish();
-		},
-		order,
-		name: spec.name ? `${spec.name} (${order})` : `projection-${order}`,
-		sources: entries.map(([, source]) => source),
-		consumers: /* @__PURE__ */ new Set(),
-		disposed: false,
-		fault: void 0,
-		forced: false,
-		statusChanged: false,
-		evaluate: (build) => {
-			let active = true;
-			try {
-				const inputs = Object.fromEntries(entries.map(([key, source]) => [key, source.context(() => active)]));
-				return behavior.evaluate(inputs, build, () => active);
-			} finally {
-				active = false;
-			}
-		}
-	};
-	scheduler.initialize(() => {
-		const invalid = node.sources.find((source) => source.fault || source.disposed);
-		if (invalid) throw invalid.fault ?? new ProjectionDisposedError();
-		node.evaluate(true);
-		node.publish();
-		node.clear();
-	});
-	const check = () => {
-		if (node.disposed || !scheduler.active) throw new ProjectionDisposedError();
-		if (node.fault) throw node.fault;
-	};
-	return {
-		node,
-		check,
-		install(handle) {
-			scheduler.register(handle, node);
-			scheduler.addNode(node);
-		},
-		rebuild: () => scheduler.rebuild(node),
-		dispose: () => scheduler.disposeNode(node)
-	};
-};
-//#endregion
-//#region core/src/projection/collection.ts
-const collectionHandles = /* @__PURE__ */ new WeakSet();
-const readonlySet = (values) => {
-	const set = new Set(values);
-	const view = Object.freeze({
-		get size() {
-			return set.size;
-		},
-		has: (value) => set.has(value),
-		entries: () => set.entries(),
-		keys: () => set.keys(),
-		values: () => set.values(),
-		[Symbol.iterator]: () => set.values(),
-		forEach: (callback, thisArg) => set.forEach((value) => callback.call(thisArg, value, value, view))
-	});
-	return view;
-};
-const createCollection = (scheduler, spec) => {
-	const values = /* @__PURE__ */ new Map();
-	let ids = Object.freeze([]);
-	let staged = /* @__PURE__ */ new Map();
-	let nextIds = ids;
-	let change;
-	let instance;
-	let initialized = false;
-	let reset = false;
-	let revision = 0;
-	let idsRevision = 0;
-	let all;
-	const itemVersions = /* @__PURE__ */ new Map();
-	const items = /* @__PURE__ */ new Map();
-	const itemListeners = /* @__PURE__ */ new Map();
-	const idsListeners = /* @__PURE__ */ new Set();
-	const allListeners = /* @__PURE__ */ new Set();
-	const listeners = /* @__PURE__ */ new Set();
-	const changedKeys = /* @__PURE__ */ new Set();
-	let orderChanged = false;
-	const hasNext = (key) => staged.has(key) ? staged.get(key).present : values.has(key);
-	const getNext = (key) => {
-		const entry = staged.get(key);
-		return entry ? entry.present ? entry.value : void 0 : values.get(key);
-	};
-	const owner = createNode(scheduler, spec, {
-		evaluate: (sources, build, active) => {
-			staged = /* @__PURE__ */ new Map();
-			nextIds = ids;
-			change = void 0;
-			changedKeys.clear();
-			let explicitOrder;
-			let cleared = false;
-			const nextHas = (key) => staged.has(key) ? staged.get(key).present : !cleared && values.has(key);
-			const nextGet = (key) => {
-				const entry = staged.get(key);
-				return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : values.get(key);
-			};
-			const deriveIds = () => {
-				const result = cleared ? [] : ids.filter(nextHas);
-				for (const [key, entry] of staged) if (entry.present && (cleared || !values.has(key))) result.push(key);
-				return result;
-			};
-			const read = (next) => ({
-				get: (key) => {
-					assertScope(active);
-					return next ? nextGet(key) : values.get(key);
-				},
-				has: (key) => {
-					assertScope(active);
-					return next ? nextHas(key) : values.has(key);
-				},
-				ids: () => {
-					assertScope(active);
-					return next ? Object.freeze(explicitOrder ? explicitOrder.slice() : deriveIds()) : ids;
-				}
-			});
-			const writer = {
-				set: (key, value) => {
-					assertScope(active);
-					if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-					staged.set(key, {
-						present: true,
-						value
-					});
-				},
-				remove: (key) => {
-					assertScope(active);
-					staged.set(key, { present: false });
-				},
-				order: (order) => {
-					assertScope(active);
-					explicitOrder = order.slice();
-				},
-				replace: (entries) => {
-					assertScope(active);
-					staged.clear();
-					cleared = true;
-					const order = [];
-					for (const [key, value] of entries) {
-						if (staged.has(key)) throw new TypeError("Duplicate projection key.");
-						writer.set(key, value);
-						order.push(key);
-					}
-					explicitOrder = order;
-				}
-			};
-			const input = {
-				sources,
-				previous: read(false),
-				next: read(true),
-				writer
-			};
-			if (build || !instance) {
-				profile.materialized.rebuilt();
-				instance = void 0;
-				cleared = true;
-				const built = spec.build(input);
-				assertSynchronous(built);
-				instance = built;
-			} else {
-				profile.materialized.updated();
-				const result = instance.update(input);
-				assertSynchronous(result);
-				if (result?.kind === "rebuild") {
-					staged.clear();
-					cleared = true;
-					explicitOrder = void 0;
-					instance = void 0;
-					const built = spec.build(input);
-					assertSynchronous(built);
-					instance = built;
-					build = true;
-				}
-			}
-			if (cleared) {
-				for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
-			}
-			const added = /* @__PURE__ */ new Set();
-			const removed = /* @__PURE__ */ new Set();
-			const updated = /* @__PURE__ */ new Set();
-			profile.projection("touchedKeys", staged.size);
-			for (const [key, entry] of staged) {
-				const existed = values.has(key);
-				if (entry.present) if (!existed) added.add(key);
-				else if (!(spec.isEqual ?? Object.is)(values.get(key), entry.value)) updated.add(key);
-				else staged.delete(key);
-				else if (existed) removed.add(key);
-				else staged.delete(key);
-			}
-			if (explicitOrder || added.size || removed.size) {
-				const order = explicitOrder ?? [...ids.filter((key) => !removed.has(key)), ...added];
-				if (new Set(order).size !== order.length || order.length !== values.size + added.size - removed.size || order.some((key) => !hasNext(key))) throw new TypeError("Projection order must contain every key exactly once.");
-				nextIds = ids.length === order.length && ids.every((key, i) => key === order[i]) ? ids : Object.freeze(order.slice());
-			}
-			orderChanged = nextIds !== ids;
-			if (added.size || removed.size || updated.size || orderChanged) {
-				let commonOrderChanged = false;
-				if (orderChanged) {
-					const before = ids.filter((key) => !removed.has(key));
-					const after = nextIds.filter((key) => !added.has(key));
-					commonOrderChanged = before.some((key, i) => after[i] !== key);
-				}
-				change = Object.freeze({
-					kind: "incremental",
-					added: readonlySet(added),
-					removed: readonlySet(removed),
-					updated: readonlySet(updated),
-					orderChanged: commonOrderChanged
-				});
-				[
-					...added,
-					...removed,
-					...updated
-				].forEach((key) => changedKeys.add(key));
-				profile.projection("changedKeys", changedKeys.size);
-			}
-			reset = build;
-			return change !== void 0;
-		},
-		context: (active) => {
-			const input = {
-				get: (key) => {
-					assertScope(active);
-					return getNext(key);
-				},
-				has: (key) => {
-					assertScope(active);
-					return hasNext(key);
-				},
-				ids: () => {
-					assertScope(active);
-					return nextIds;
-				},
-				change,
-				revision: revision + (change ? 1 : 0),
-				reset
-			};
-			return Object.freeze(input);
-		},
-		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
-			else values.delete(key);
-			if (change) {
-				if (initialized) revision++;
-				if (orderChanged && initialized) idsRevision++;
-				all = void 0;
-				changedKeys.forEach((key) => {
-					if (items.has(key)) itemVersions.set(key, (itemVersions.get(key) ?? 0) + (initialized ? 1 : 0));
-				});
-			}
-			ids = nextIds;
-			initialized = true;
-		},
-		emit: (call) => {
-			profile.materialized.notification();
-			const fault = owner.node.fault !== void 0;
-			const resetEvent = Object.freeze({ kind: "reset" });
-			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
-			if (orderChanged || !change || fault || owner.node.statusChanged) Array.from(idsListeners).forEach((listener) => call(listener));
-			Array.from(allListeners).forEach((listener) => call(listener));
-			const keys = !change || fault || owner.node.statusChanged ? itemListeners.keys() : changedKeys;
-			for (const key of keys) Array.from(itemListeners.get(key) ?? []).forEach((listener) => call(listener));
-		},
-		clear: () => {
-			staged.clear();
-			nextIds = ids;
-			change = void 0;
-			reset = false;
-			changedKeys.clear();
-			orderChanged = false;
-		},
-		release: () => {
-			values.clear();
-			staged.clear();
-			items.clear();
-			itemVersions.clear();
-			itemListeners.clear();
-			idsListeners.clear();
-			allListeners.clear();
-			listeners.clear();
-			ids = nextIds = Object.freeze([]);
-			all = void 0;
-			instance = void 0;
-		}
-	});
-	const handle = {
-		ids: {
-			current: () => {
-				owner.check();
-				return ids;
-			},
-			revision: () => {
-				owner.check();
-				return idsRevision;
-			},
-			subscribe: (listener) => {
-				owner.check();
-				idsListeners.add(listener);
-				return () => {
-					idsListeners.delete(listener);
-				};
-			}
-		},
-		all: {
-			current: () => {
-				owner.check();
-				if (!all) {
-					profile.collectionView.arrayCopied();
-					all = Object.freeze(ids.map((key) => values.get(key)));
-				}
-				return all;
-			},
-			revision: () => {
-				owner.check();
-				return revision;
-			},
-			subscribe: (listener) => {
-				owner.check();
-				allListeners.add(listener);
-				return () => {
-					allListeners.delete(listener);
-				};
-			}
-		},
-		item: (key) => {
-			owner.check();
-			const old = items.get(key);
-			if (old) return old;
-			itemVersions.set(key, 0);
-			const readable = Object.freeze({
-				current: () => {
-					owner.check();
-					return values.get(key);
-				},
-				revision: () => {
-					owner.check();
-					return itemVersions.get(key) ?? 0;
-				},
-				subscribe: (listener) => {
-					owner.check();
-					const set = itemListeners.get(key) ?? /* @__PURE__ */ new Set();
-					set.add(listener);
-					itemListeners.set(key, set);
-					return () => {
-						set.delete(listener);
-						if (!set.size) itemListeners.delete(key);
-					};
-				}
-			});
-			projectionHandles.add(readable);
-			items.set(key, readable);
-			return readable;
-		},
-		revision: () => {
-			owner.check();
-			return revision;
-		},
-		subscribe: (listener) => {
-			owner.check();
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		},
-		rebuild: owner.rebuild,
-		dispose: owner.dispose
-	};
-	projectionHandles.add(handle.ids);
-	projectionHandles.add(handle.all);
-	collectionHandles.add(handle);
-	owner.install(handle);
-	return Object.freeze(handle);
-};
-//#endregion
-//#region core/src/projection/source.ts
-const createSources = (scheduler) => {
-	const documents = /* @__PURE__ */ new Map();
-	const readables = /* @__PURE__ */ new Map();
-	const collections = /* @__PURE__ */ new WeakSet();
-	const document = (runtime) => {
-		scheduler.assertIdle();
-		const state = accessOf(runtime);
-		if (state.disposed) throw new Error("Document has been disposed.");
-		const existing = documents.get(state);
-		if (existing) return existing;
-		const bindings = [];
-		const make = (targets, collection) => {
-			if (state.disposed) throw new Error("Document has been disposed.");
-			targets.forEach((value) => {
-				if (!belongs(value, state.schema)) throw new Error("Projection target belongs to another schema.");
-			});
-			const old = bindings.find((entry) => Boolean(collection) === collections.has(entry.handle) && entry.targets.length === targets.length && entry.targets.every((value, i) => same(value, targets[i])));
-			if (old) return old.handle;
-			let commits = [];
-			let reset = false;
-			let orderDirty = false;
-			const keys = /* @__PURE__ */ new Set();
-			let candidates;
-			const record = {
-				consumers: /* @__PURE__ */ new Set(),
-				disposed: false,
-				fault: void 0,
-				revision: runtime.revision,
-				reset: () => reset,
-				clear: () => {
-					commits = [];
-					reset = orderDirty = false;
-					keys.clear();
-					candidates = void 0;
-				},
-				context: (active) => {
-					assertScope(active);
-					if (state.disposed) throw new Error("Document has been disposed.");
-					const read = collection ? readerFor(nodeAt(state.schema, collection.address, state.document) ?? collectionSchema(collection), {
-						root: () => state.document,
-						active
-					}, collection.address) : documentReader(state.schema, () => state.document, active);
-					return Object.freeze({
-						read,
-						target: collection,
-						revision: runtime.revision(),
-						commits: Object.freeze(commits.slice()),
-						reset: record.reset(),
-						...collection ? { candidates: candidates ??= Object.freeze({
-							keys: Object.freeze([...keys]),
-							orderDirty
-						}) } : {}
-					});
-				}
-			};
-			const handle = collection ? {} : {
-				collection: (pick) => {
-					scheduler.assertIdle();
-					const selector = state.schema.collection(pick);
-					return make([selector], selector);
-				},
-				targets: (...selected) => {
-					scheduler.assertIdle();
-					if (!selected.length) throw new TypeError("Expected at least one target.");
-					return make(selected);
-				}
-			};
-			Object.freeze(handle);
-			bindings.push({
-				handle,
-				targets,
-				record
-			});
-			if (collection) collections.add(handle);
-			scheduler.register(handle, record);
-			receivers.set(record, (commit) => {
-				commits.push(commit);
-				reset ||= commit.kind === "replace";
-				if (collection) {
-					const change = commit.impact.collection(collection);
-					if (change.kind === "reset") reset = true;
-					else {
-						change.added.forEach((key) => keys.add(key));
-						change.removed.forEach((key) => keys.add(key));
-						change.updated.forEach((key) => keys.add(key));
-						orderDirty ||= Boolean(change.added.size || change.removed.size || change.orderChanged);
-					}
-					candidates = void 0;
-				}
-			});
-			return handle;
-		};
-		const receivers = /* @__PURE__ */ new Map();
-		const handle = make([]);
-		const guard = (locked) => {
-			state.projectionLocks = (state.projectionLocks ?? 0) + (locked ? 1 : -1);
-		};
-		scheduler.guards.add(guard);
-		const unsubscribe = attachProjection(runtime, {
-			capture: (commit) => {
-				for (const binding of bindings) if (!binding.targets.length || binding.targets.some(commit.impact.affects)) {
-					receivers.get(binding.record)(commit);
-					scheduler.capture(binding.record);
-				}
-			},
-			settle: scheduler.settle,
-			flush: scheduler.flush,
-			dispose: () => {
-				bindings.forEach(({ record }) => {
-					record.fault = new ProjectionError("source", "document disposed", [runtime.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
-					scheduler.capture(record);
-				});
-				scheduler.run();
-			}
-		});
-		scheduler.cleanups.add(() => {
-			unsubscribe();
-			scheduler.guards.delete(guard);
-		});
-		documents.set(state, handle);
-		return handle;
-	};
-	const valueSource = (initial, equal) => {
-		let value = initial;
-		let previous = initial;
-		let revision = 0;
-		const handle = Object.freeze({});
-		const record = {
-			consumers: /* @__PURE__ */ new Set(),
-			disposed: false,
-			fault: void 0,
-			revision: () => revision,
-			reset: () => false,
-			clear: () => {
-				previous = value;
-			},
-			context: (active) => {
-				assertScope(active);
-				return Object.freeze({
-					value,
-					previous,
-					revision,
-					changed: !equal(previous, value),
-					reset: false
-				});
-			}
-		};
-		scheduler.register(handle, record);
-		const accept = (next) => {
-			scheduler.assertIdle();
-			const recovering = record.fault !== void 0;
-			if (equal(value, next) && !recovering) return;
-			record.fault = void 0;
-			value = next;
-			revision++;
-			scheduler.capture(record);
-		};
-		return {
-			source: handle,
-			accept,
-			set(next) {
-				accept(next);
-				scheduler.run();
-			}
-		};
-	};
-	return {
-		dispose: () => {
-			documents.clear();
-			readables.clear();
-		},
-		document,
-		input: (initial, options) => {
-			const { source, set } = valueSource(initial, options?.isEqual ?? Object.is);
-			return Object.freeze({
-				source,
-				set
-			});
-		},
-		fromReadable: (readable, options) => {
-			scheduler.assertIdle();
-			if (projectionHandles.has(readable)) throw new Error("Projection nodes must be declared directly as sources.");
-			const equal = options?.isEqual ?? Object.is;
-			let bindings = readables.get(readable);
-			const old = bindings?.get(equal);
-			if (old) return old.source;
-			const input = valueSource(readable.current(), equal);
-			if (bindings) {
-				bindings.set(equal, {
-					source: input.source,
-					accept: (value) => input.accept(value)
-				});
-				return input.source;
-			}
-			bindings = new Map([[equal, {
-				source: input.source,
-				accept: (value) => input.accept(value)
-			}]]);
-			const members = bindings;
-			const receive = (settle = true) => {
-				if (!scheduler.active) return;
-				let value;
-				try {
-					value = readable.current();
-				} catch (cause) {
-					for (const member of members.values()) {
-						const record = scheduler.source(member.source);
-						record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
-						scheduler.capture(record);
-					}
-					if (settle) scheduler.run();
-					return;
-				}
-				for (const member of members.values()) try {
-					member.accept(value);
-				} catch (cause) {
-					const record = scheduler.source(member.source);
-					record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
-					scheduler.capture(record);
-				}
-				if (settle) scheduler.run();
-			};
-			let unsubscribe;
-			let detach;
-			try {
-				const owner = documentReadableOwner(readable);
-				if (owner) {
-					document(owner);
-					detach = attachProjection(owner, {
-						capture: () => receive(false),
-						settle: scheduler.settle,
-						flush: scheduler.flush,
-						dispose: () => {
-							for (const member of members.values()) {
-								const record = scheduler.source(member.source);
-								record.fault = new ProjectionError("source", "document readable disposed", [record.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
-								scheduler.capture(record);
-							}
-							scheduler.run();
-						}
-					});
-				}
-				unsubscribe = readable.subscribe(() => receive());
-				input.accept(readable.current());
-			} catch (error) {
-				try {
-					unsubscribe?.();
-					detach?.();
-				} finally {
-					scheduler.unregisterSource(input.source);
-				}
-				throw error;
-			}
-			scheduler.cleanups.add(unsubscribe);
-			if (detach) scheduler.cleanups.add(detach);
-			readables.set(readable, bindings);
-			scheduler.run();
-			return input.source;
-		},
-		assertCollection: (handle) => {
-			scheduler.source(handle);
-			if (!collections.has(handle) && !collectionHandles.has(handle)) throw new Error("map requires a collection source.");
-		}
-	};
-};
-//#endregion
-//#region core/src/projection/value.ts
-const createValue = (scheduler, spec, options) => {
-	let instance;
-	let value;
-	let next;
-	let previous;
-	let initialized = false;
-	let revision = 0;
-	let changed = false;
-	let reset = false;
-	const listeners = /* @__PURE__ */ new Set();
-	const owner = createNode(scheduler, spec, {
-		evaluate: (sources, build) => {
-			let candidate;
-			if (build || !instance) {
-				profile.materialized.rebuilt();
-				instance = void 0;
-				const built = spec.build(sources);
-				assertSynchronous(built);
-				instance = built;
-				candidate = built.value;
-			} else {
-				profile.materialized.updated();
-				const result = instance.update(sources);
-				assertSynchronous(result);
-				if (result.kind === "rebuild") {
-					instance = void 0;
-					const built = spec.build(sources);
-					assertSynchronous(built);
-					instance = built;
-					candidate = built.value;
-					build = true;
-				} else candidate = result.kind === "changed" ? result.value : value;
-			}
-			previous = value;
-			changed = !initialized || !(options?.isEqual ?? Object.is)(value, candidate);
-			next = changed ? candidate : value;
-			reset = build;
-			return changed;
-		},
-		context: (active) => {
-			assertScope(active);
-			return Object.freeze({
-				value: next,
-				previous,
-				changed,
-				revision: revision + (changed ? 1 : 0),
-				reset
-			});
-		},
-		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			if (changed && initialized) revision++;
-			value = next;
-			initialized = true;
-		},
-		emit: (call) => {
-			profile.materialized.notification();
-			Array.from(listeners).forEach((listener) => call(listener));
-		},
-		clear: () => {
-			next = value;
-			previous = value;
-			changed = false;
-			reset = false;
-		},
-		release: () => {
-			listeners.clear();
-			instance = void 0;
-			value = next = previous = void 0;
-		}
-	});
-	const handle = Object.freeze({
-		current: () => {
-			owner.check();
-			return value;
-		},
-		revision: () => {
-			owner.check();
-			return revision;
-		},
-		subscribe: (listener) => {
-			owner.check();
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		},
-		rebuild: owner.rebuild,
-		dispose: owner.dispose
-	});
-	owner.install(handle);
-	return handle;
-};
-//#endregion
-//#region core/src/projection/runtime.ts
-const debug = /* @__PURE__ */ new WeakMap();
-const projectionDebug = (runtime) => {
-	const read = debug.get(runtime);
-	if (!read) throw new Error("Unknown projection runtime.");
-	return Object.freeze(read());
-};
-const createProjectionRuntime = (options) => {
-	const scheduler = createScheduler(options.onError);
-	const sources = createSources(scheduler);
-	function value(input, computeOrOptions, options) {
-		if (typeof computeOrOptions !== "function") return createValue(scheduler, input, computeOrOptions);
-		const compute = (input) => {
-			const result = computeOrOptions(input);
-			assertSynchronous(result);
-			return result;
-		};
-		return createValue(scheduler, {
-			sources: input,
-			build: (input) => ({
-				value: compute(input),
-				update: (input) => ({
-					kind: "changed",
-					value: compute(input)
-				})
-			})
-		}, options);
-	}
-	const map = (source, mapper, options) => {
-		sources.assertCollection(source);
-		const calculate = (id, entry) => {
-			const value = mapper(id, entry);
-			assertSynchronous(value);
-			return value;
-		};
-		return createCollection(scheduler, {
-			sources: { source },
-			isEqual: options?.isEqual,
-			build: ({ sources, writer }) => {
-				const input = sources.source;
-				const read = "read" in input ? input.read : input;
-				const ids = read.ids();
-				profile.collectionView.idsScanned(ids.length);
-				for (const id of ids) {
-					profile.collectionView.mapped();
-					writer.set(id, calculate(id, read.get(id)));
-				}
-				writer.order(ids);
-				return { update: ({ sources, writer }) => {
-					const input = sources.source;
-					if (input.reset) return { kind: "rebuild" };
-					const read = "read" in input ? input.read : input;
-					let keys;
-					let structural;
-					if ("candidates" in input) {
-						keys = input.candidates.keys;
-						structural = input.candidates.orderDirty;
-					} else {
-						const change = input.change;
-						if (!change) return;
-						if (change.kind === "reset") return { kind: "rebuild" };
-						keys = new Set([
-							...change.added,
-							...change.removed,
-							...change.updated
-						]);
-						structural = Boolean(change.added.size || change.removed.size || change.orderChanged);
-					}
-					for (const key of keys) if (!read.has(key)) writer.remove(key);
-					else {
-						profile.collectionView.mapped();
-						writer.set(key, calculate(key, read.get(key)));
-					}
-					if (structural) {
-						const ids = read.ids();
-						profile.collectionView.idsScanned(ids.length);
-						writer.order(ids);
-					}
-				} };
-			}
-		});
-	};
-	const runtime = {
-		document: sources.document,
-		input: sources.input,
-		fromReadable: sources.fromReadable,
-		value,
-		collection: () => (spec) => createCollection(scheduler, spec),
-		map,
-		batch: scheduler.batch,
-		dispose: () => {
-			try {
-				scheduler.dispose();
-			} finally {
-				if (!scheduler.active) sources.dispose();
-			}
-		}
-	};
-	debug.set(runtime, scheduler.debug);
-	return Object.freeze(runtime);
-};
-//#endregion
-export { id as A, set as B, restore as C, DocumentReentrancyError as D, DocumentDisposedError as E, locate as F, object as G, field as H, overlaps as I, table as J, optional as K, read as L, same as M, contains as N, address$1 as O, debugKey as P, resolveAddress as R, keys as S, validPositions as T, list as U, dict as V, map as W, variant as X, tree as Y, footprintsOverlap as _, bindDocumentReadable as a, at as b, notify as c, subscribeTargets as d, accessOf as f, decodeCommandFootprint as g, commandFootprint as h, ProjectionError as i, impact_target_exports as j, belongs as k, shareNotification as l, readWith as m, projectionDebug as n, createNotification as o, bindRuntimeAccess as p, schema as q, ProjectionDisposedError as r, disposeNotification as s, createProjectionRuntime as t, subscribeRoot as u, documentReader as v, valid as w, index as x, afterRemove as y, resolveLocated as z };
-
-//# sourceMappingURL=runtime-DF1q9Gje.js.map