doxum 0.1.8 → 0.1.9

package/dist/runtime-0mOFbe_H.cjs

@@ -1,2439 +0,0 @@
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-const require_ownership = require("./ownership-CY0nPXGF.cjs");
-//#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) {
-		require_ownership.profile.address.schemaStep();
-		require_ownership.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;
-	require_ownership.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) {
-		require_ownership.profile.address.schemaStep();
-		require_ownership.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;
-	}
-	require_ownership.profile.address.schemaStep();
-	require_ownership.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) => {
-	require_ownership.profile.address.prefixComparison();
-	if (parent.length > child.length) return false;
-	for (let index = 0; index < parent.length; index += 1) {
-		require_ownership.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);
-	require_ownership.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 require_ownership.cloneValue(require_ownership.isRecord(value) && Object.prototype.hasOwnProperty.call(value, key) ? value[key] : void 0, "reader");
-		},
-		has: (key) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return require_ownership.isRecord(value) && Object.prototype.hasOwnProperty.call(value, key);
-		},
-		keys: () => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return require_ownership.isRecord(value) ? Object.keys(value) : [];
-		},
-		values: () => {
-			collectValue(context, address);
-			require_ownership.profile.reader.structuralSnapshot();
-			return require_ownership.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 require_ownership.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);
-			require_ownership.profile.reader.structuralSnapshot();
-			return require_ownership.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);
-			require_ownership.profile.reader.structuralSnapshot();
-			return require_ownership.cloneValue(Array.isArray(value) ? value[index] : void 0, "reader");
-		}
-	};
-	if (node.kind === "tree") return {
-		rootId: () => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return require_ownership.isRecord(value) && typeof value.rootId === "string" ? value.rootId : void 0;
-		},
-		has: (id) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			return require_ownership.isRecord(value) && require_ownership.isRecord(value.nodes) && Object.prototype.hasOwnProperty.call(value.nodes, id);
-		},
-		value: (id) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			require_ownership.profile.reader.structuralSnapshot();
-			return require_ownership.cloneValue(require_ownership.isRecord(value) && require_ownership.isRecord(value.nodes) && require_ownership.isRecord(value.nodes[id]) ? value.nodes[id].value : void 0, "reader");
-		},
-		parent: (id) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			const entry = require_ownership.isRecord(value) && require_ownership.isRecord(value.nodes) ? value.nodes[id] : void 0;
-			return require_ownership.isRecord(entry) && typeof entry.parentId === "string" ? entry.parentId : void 0;
-		},
-		children: (id) => {
-			collectValue(context, address);
-			const value = readAt(context, address);
-			const entry = require_ownership.isRecord(value) && require_ownership.isRecord(value.nodes) ? value.nodes[id] : void 0;
-			return require_ownership.isRecord(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" && require_ownership.isRecord(value) && Array.isArray(value.ids) ? [...value.ids] : require_ownership.isRecord(value) ? Object.keys(value) : [];
-				require_ownership.profile.reader.collectionIds(ids.length);
-				return ids;
-			},
-			has: (id) => {
-				collectCollection(context, address, id);
-				const value = readAt(context, address);
-				const byId = node.kind === "table" && require_ownership.isRecord(value) && require_ownership.isRecord(value.byId) ? value.byId : value;
-				return require_ownership.isRecord(byId) && Object.prototype.hasOwnProperty.call(byId, id);
-			},
-			get: (id) => {
-				collectCollection(context, address, id);
-				const value = readAt(context, address);
-				const byId = node.kind === "table" && require_ownership.isRecord(value) && require_ownership.isRecord(value.byId) ? value.byId : value;
-				if (!require_ownership.isRecord(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 require_ownership.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) => {
-	require_ownership.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);
-		require_ownership.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);
-		require_ownership.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;
-				require_ownership.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) {
-					require_ownership.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) require_ownership.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) {
-				require_ownership.profile.materialized.rebuilt();
-				instance = void 0;
-				cleared = true;
-				const built = spec.build(input);
-				assertSynchronous(built);
-				instance = built;
-			} else {
-				require_ownership.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();
-			require_ownership.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));
-				require_ownership.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) => {
-			require_ownership.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) {
-					require_ownership.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) {
-				require_ownership.profile.materialized.rebuilt();
-				instance = void 0;
-				const built = spec.build(sources);
-				assertSynchronous(built);
-				instance = built;
-				candidate = built.value;
-			} else {
-				require_ownership.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) => {
-			require_ownership.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();
-				require_ownership.profile.collectionView.idsScanned(ids.length);
-				for (const id of ids) {
-					require_ownership.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 {
-						require_ownership.profile.collectionView.mapped();
-						writer.set(key, calculate(key, read.get(key)));
-					}
-					if (structural) {
-						const ids = read.ids();
-						require_ownership.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
-Object.defineProperty(exports, "DocumentDisposedError", {
-	enumerable: true,
-	get: function() {
-		return DocumentDisposedError;
-	}
-});
-Object.defineProperty(exports, "DocumentReentrancyError", {
-	enumerable: true,
-	get: function() {
-		return DocumentReentrancyError;
-	}
-});
-Object.defineProperty(exports, "ProjectionDisposedError", {
-	enumerable: true,
-	get: function() {
-		return ProjectionDisposedError;
-	}
-});
-Object.defineProperty(exports, "ProjectionError", {
-	enumerable: true,
-	get: function() {
-		return ProjectionError;
-	}
-});
-Object.defineProperty(exports, "accessOf", {
-	enumerable: true,
-	get: function() {
-		return accessOf;
-	}
-});
-Object.defineProperty(exports, "address", {
-	enumerable: true,
-	get: function() {
-		return address$1;
-	}
-});
-Object.defineProperty(exports, "afterRemove", {
-	enumerable: true,
-	get: function() {
-		return afterRemove;
-	}
-});
-Object.defineProperty(exports, "at", {
-	enumerable: true,
-	get: function() {
-		return at;
-	}
-});
-Object.defineProperty(exports, "belongs", {
-	enumerable: true,
-	get: function() {
-		return belongs;
-	}
-});
-Object.defineProperty(exports, "bindDocumentReadable", {
-	enumerable: true,
-	get: function() {
-		return bindDocumentReadable;
-	}
-});
-Object.defineProperty(exports, "bindRuntimeAccess", {
-	enumerable: true,
-	get: function() {
-		return bindRuntimeAccess;
-	}
-});
-Object.defineProperty(exports, "commandFootprint", {
-	enumerable: true,
-	get: function() {
-		return commandFootprint;
-	}
-});
-Object.defineProperty(exports, "contains", {
-	enumerable: true,
-	get: function() {
-		return contains;
-	}
-});
-Object.defineProperty(exports, "createNotification", {
-	enumerable: true,
-	get: function() {
-		return createNotification;
-	}
-});
-Object.defineProperty(exports, "createProjectionRuntime", {
-	enumerable: true,
-	get: function() {
-		return createProjectionRuntime;
-	}
-});
-Object.defineProperty(exports, "debugKey", {
-	enumerable: true,
-	get: function() {
-		return debugKey;
-	}
-});
-Object.defineProperty(exports, "decodeCommandFootprint", {
-	enumerable: true,
-	get: function() {
-		return decodeCommandFootprint;
-	}
-});
-Object.defineProperty(exports, "dict", {
-	enumerable: true,
-	get: function() {
-		return dict;
-	}
-});
-Object.defineProperty(exports, "disposeNotification", {
-	enumerable: true,
-	get: function() {
-		return disposeNotification;
-	}
-});
-Object.defineProperty(exports, "documentReader", {
-	enumerable: true,
-	get: function() {
-		return documentReader;
-	}
-});
-Object.defineProperty(exports, "field", {
-	enumerable: true,
-	get: function() {
-		return field;
-	}
-});
-Object.defineProperty(exports, "footprintsOverlap", {
-	enumerable: true,
-	get: function() {
-		return footprintsOverlap;
-	}
-});
-Object.defineProperty(exports, "id", {
-	enumerable: true,
-	get: function() {
-		return id;
-	}
-});
-Object.defineProperty(exports, "impact_target_exports", {
-	enumerable: true,
-	get: function() {
-		return impact_target_exports;
-	}
-});
-Object.defineProperty(exports, "index", {
-	enumerable: true,
-	get: function() {
-		return index;
-	}
-});
-Object.defineProperty(exports, "keys", {
-	enumerable: true,
-	get: function() {
-		return keys;
-	}
-});
-Object.defineProperty(exports, "list", {
-	enumerable: true,
-	get: function() {
-		return list;
-	}
-});
-Object.defineProperty(exports, "locate", {
-	enumerable: true,
-	get: function() {
-		return locate;
-	}
-});
-Object.defineProperty(exports, "map", {
-	enumerable: true,
-	get: function() {
-		return map;
-	}
-});
-Object.defineProperty(exports, "notify", {
-	enumerable: true,
-	get: function() {
-		return notify;
-	}
-});
-Object.defineProperty(exports, "object", {
-	enumerable: true,
-	get: function() {
-		return object;
-	}
-});
-Object.defineProperty(exports, "optional", {
-	enumerable: true,
-	get: function() {
-		return optional;
-	}
-});
-Object.defineProperty(exports, "overlaps", {
-	enumerable: true,
-	get: function() {
-		return overlaps;
-	}
-});
-Object.defineProperty(exports, "projectionDebug", {
-	enumerable: true,
-	get: function() {
-		return projectionDebug;
-	}
-});
-Object.defineProperty(exports, "read", {
-	enumerable: true,
-	get: function() {
-		return read;
-	}
-});
-Object.defineProperty(exports, "readWith", {
-	enumerable: true,
-	get: function() {
-		return readWith;
-	}
-});
-Object.defineProperty(exports, "resolveAddress", {
-	enumerable: true,
-	get: function() {
-		return resolveAddress;
-	}
-});
-Object.defineProperty(exports, "resolveLocated", {
-	enumerable: true,
-	get: function() {
-		return resolveLocated;
-	}
-});
-Object.defineProperty(exports, "restore", {
-	enumerable: true,
-	get: function() {
-		return restore;
-	}
-});
-Object.defineProperty(exports, "same", {
-	enumerable: true,
-	get: function() {
-		return same;
-	}
-});
-Object.defineProperty(exports, "schema", {
-	enumerable: true,
-	get: function() {
-		return schema;
-	}
-});
-Object.defineProperty(exports, "set", {
-	enumerable: true,
-	get: function() {
-		return set;
-	}
-});
-Object.defineProperty(exports, "shareNotification", {
-	enumerable: true,
-	get: function() {
-		return shareNotification;
-	}
-});
-Object.defineProperty(exports, "subscribeRoot", {
-	enumerable: true,
-	get: function() {
-		return subscribeRoot;
-	}
-});
-Object.defineProperty(exports, "subscribeTargets", {
-	enumerable: true,
-	get: function() {
-		return subscribeTargets;
-	}
-});
-Object.defineProperty(exports, "table", {
-	enumerable: true,
-	get: function() {
-		return table;
-	}
-});
-Object.defineProperty(exports, "tree", {
-	enumerable: true,
-	get: function() {
-		return tree;
-	}
-});
-Object.defineProperty(exports, "valid", {
-	enumerable: true,
-	get: function() {
-		return valid;
-	}
-});
-Object.defineProperty(exports, "validPositions", {
-	enumerable: true,
-	get: function() {
-		return validPositions;
-	}
-});
-Object.defineProperty(exports, "variant", {
-	enumerable: true,
-	get: function() {
-		return variant;
-	}
-});
-
-//# sourceMappingURL=runtime-0mOFbe_H.cjs.map