doxum 0.1.6 → 0.1.7

package/dist/{runtime-CRijXjYp.cjs → runtime-0mOFbe_H.cjs}

@@ -14,10 +14,19 @@ 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) => node({
-	...value,
-	optional: true
-});
+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
@@ -27,10 +36,6 @@ const variant = (tag, variants) => node({
 	tag,
 	variants
 });
-const single = (value) => node({
-	kind: "single",
-	value
-});
 const table = (value) => node({
 	kind: "table",
 	value
@@ -39,26 +44,55 @@ const map = (value) => node({
 	kind: "map",
 	value
 });
-const record = () => node({ kind: "record" });
 const dict = () => node({ kind: "dict" });
 const list = (config) => ({
 	kind: "list",
 	keyOf: config.keyOf
 });
 const tree = () => node({ kind: "tree" });
-const pathProxy = (address) => new Proxy({ address }, { get: (_target, property) => {
-	if (property === "address") return address;
-	if (property === "item") return (id) => pathProxy([...address, id]);
-	if (typeof property === "symbol") return void 0;
-	return pathProxy([...address, property]);
-} });
+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 selected = pick(pathProxy([]));
-	return Object.freeze({
+	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 ?? []])
+		address: Object.freeze([...selected.address])
 	});
+	if (kind === "collection") collectionSchemas.set(result, selected.nodes[0]);
+	return result;
 };
 const schema = (shape) => {
 	const result = {
@@ -90,11 +124,6 @@ const hashText = (value, seed) => {
 };
 const appendAddressHash = (hash, segment) => hashText(segment, hashText("/", hash));
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const unwrap = (node) => {
-	let current = node;
-	while (current?.kind === "single") current = current.value;
-	return current;
-};
 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] ?? "")];
@@ -104,12 +133,12 @@ const schemaRoot$1 = (schema) => ({
 	shape: schema.shape
 });
 const step = (nodeInput, value, segment) => {
-	let node = unwrap(nodeInput);
+	let node = nodeInput;
 	if (!node) return {
 		node: void 0,
 		dynamic: false
 	};
-	if (node.kind === "variant") node = unwrap(variantNode(node, value));
+	if (node.kind === "variant") node = variantNode(node, value);
 	if (!node) return {
 		node: void 0,
 		dynamic: false
@@ -122,7 +151,7 @@ const step = (nodeInput, value, segment) => {
 		node: node.value,
 		dynamic: true
 	};
-	if (node.kind === "record" || node.kind === "dict" || node.kind === "list" || node.kind === "tree") return {
+	if (node.kind === "dict" || node.kind === "list" || node.kind === "tree") return {
 		node,
 		dynamic: true
 	};
@@ -173,7 +202,7 @@ const nodeAt = (schema, address, document) => {
 		value = readSegment(value, segment);
 		if (!node) return void 0;
 	}
-	return unwrap(node);
+	return node;
 };
 const readSegment = (value, segment) => {
 	if (!isRecord(value) && !Array.isArray(value)) return void 0;
@@ -287,25 +316,93 @@ const debugKey = (address) => {
 //#endregion
 //#region core/src/impact-target.ts
 var impact_target_exports = /* @__PURE__ */ __exportAll({
-	address: () => address,
+	address: () => address$1,
 	belongs: () => belongs,
 	bucket: () => bucket,
 	id: () => id,
 	same: () => same
 });
-const address = (target) => "at" in target ? target.at : target.address;
+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(left);
-	const rightAddress = address(right);
+	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(target)[0];
+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);
@@ -336,12 +433,40 @@ const readerFor = (node, context, address = []) => {
 		collectValue(context, address);
 		return readAt(context, address);
 	} };
-	if (node.kind === "dict" || node.kind === "record") return { get: () => {
-		collectValue(context, address);
-		require_ownership.profile.reader.structuralSnapshot();
-		return require_ownership.cloneValue(readAt(context, address), "reader");
-	} };
+	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);
@@ -419,14 +544,10 @@ const readerFor = (node, context, address = []) => {
 			}
 		};
 	}
-	if (node.kind === "single") return readerFor(node.value, context, address);
-	if (node.kind === "variant") return new Proxy({}, { get: (_target, property) => {
-		if (typeof property === "symbol") return void 0;
-		const value = readAt(context, address);
-		const tag = require_ownership.isRecord(value) && typeof value[node.tag] === "string" ? String(value[node.tag]) : void 0;
-		const child = (tag ? node.variants[tag] : void 0)?.shape[property];
-		return child ? readerFor(child, context, [...address, property]) : void 0;
-	} });
+	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;
@@ -448,19 +569,191 @@ const documentReader = (schema, root, active, dependencies) => {
 	});
 };
 //#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";
+//#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()));
 };
-var DocumentDisposedError = class extends Error {
-	constructor() {
-		super("Doxum runtime has been disposed.");
-		this.name = "DocumentDisposedError";
+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();
@@ -487,6 +780,11 @@ const readWith = (runtime, run, dependencies) => {
 //#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 = {
@@ -561,7 +859,7 @@ const subscribeTargets = (notification, targets, listener) => {
 		});
 	};
 };
-const notify = (notification, commit) => {
+const notify = (notification, commit, afterSettle) => {
 	notification.notifying = true;
 	const errors = [];
 	const call = (listener) => {
@@ -612,6 +910,7 @@ const notify = (notification, commit) => {
 				}));
 			}
 		}
+		if (afterSettle) errors.push(...afterSettle());
 		const candidates = notification.candidates;
 		candidates.clear();
 		if (commit.impact.kind === "reset") notification.filtered.forEach((entry) => candidates.add(entry));
@@ -985,239 +1284,34 @@ const assertScope = (active) => {
 	if (!active()) throw new Error("Projection reader or writer is no longer active.");
 };
 //#endregion
-//#region core/src/projection/source.ts
-const createSources = (scheduler) => {
-	const documents = /* @__PURE__ */ new Map();
-	const readables = /* @__PURE__ */ new Map();
-	const collections = /* @__PURE__ */ new WeakMap();
-	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 = [];
-			const record = {
-				consumers: /* @__PURE__ */ new Set(),
-				disposed: false,
-				fault: void 0,
-				revision: runtime.revision,
-				reset: () => commits.some((commit) => commit.kind === "replace"),
-				clear: () => {
-					commits = [];
-				},
-				context: (active) => {
-					assertScope(active);
-					if (state.disposed) throw new Error("Document has been disposed.");
-					const read = collection ? readerFor(nodeAt(state.schema, collection.address), {
-						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()
-					});
-				}
-			};
-			const handle = collection ? {} : {
-				collection: (pick) => {
-					scheduler.assertIdle();
-					const selector = state.schema.collection(pick);
-					const node = nodeAt(state.schema, selector.address);
-					if (node?.kind !== "table" && node?.kind !== "map") throw new TypeError("Expected a table or map collection path.");
-					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.set(handle, {
-				source: handle,
-				target: collection
-			});
-			scheduler.register(handle, record);
-			receivers.set(record, (commit) => {
-				commits.push(commit);
-			});
-			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();
+//#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.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 old = readables.get(readable);
-			if (old) return old;
-			const input = valueSource(readable.current(), options?.isEqual ?? Object.is);
-			const receive = () => {
-				if (!scheduler.active) return;
-				try {
-					input.accept(readable.current());
-				} catch (cause) {
-					const record = scheduler.source(input.source);
-					record.fault = new ProjectionError("source", "external readable", [readable.revision()], cause);
-					scheduler.capture(record);
-				}
-				scheduler.run();
-			};
-			let unsubscribe;
-			try {
-				unsubscribe = readable.subscribe(receive);
-				input.accept(readable.current());
-			} catch (error) {
-				try {
-					unsubscribe?.();
-				} finally {
-					scheduler.unregisterSource(input.source);
-				}
-				throw error;
-			}
-			scheduler.cleanups.add(unsubscribe);
-			readables.set(readable, input.source);
-			scheduler.run();
-			return input.source;
-		},
-		collectionTarget: (handle) => {
-			scheduler.source(handle);
-			const value = collections.get(handle);
-			if (!value) throw new Error("map requires a document collection source.");
-			return value.target;
-		}
-	};
-};
-//#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);
@@ -1242,103 +1336,8 @@ const createNode = (scheduler, spec, behavior) => {
 	};
 };
 //#endregion
-//#region core/src/projection/value.ts
-const createValue = (scheduler, spec) => {
-	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 || !(spec.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/collection.ts
+const collectionHandles = /* @__PURE__ */ new WeakSet();
 const readonlySet = (values) => {
 	const set = new Set(values);
 	const view = Object.freeze({
@@ -1666,68 +1665,463 @@ const createCollection = (scheduler, spec) => {
 	};
 	projectionHandles.add(handle.ids);
 	projectionHandles.add(handle.all);
+	collectionHandles.add(handle);
 	owner.install(handle);
 	return Object.freeze(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);
-	const runtime = {
-		document: sources.document,
-		input: sources.input,
-		fromReadable: sources.fromReadable,
-		value: (spec) => createValue(scheduler, spec),
-		collection: (spec) => createCollection(scheduler, spec),
-		map: (source, mapper, options) => {
-			sources.collectionTarget(source);
-			return createCollection(scheduler, {
-				sources: { source },
-				isEqual: options?.isEqual,
-				build: ({ sources, writer }) => {
-					const ids = sources.source.read.ids();
-					require_ownership.profile.collectionView.idsScanned(ids.length);
-					for (const id of ids) {
-						require_ownership.profile.collectionView.mapped();
-						writer.set(id, mapper(id, sources.source.read.get(id)));
+//#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);
 					}
-					writer.order(ids);
-					return { update: ({ sources, writer }) => {
-						const input = sources.source;
-						const keys = /* @__PURE__ */ new Set();
-						let structural = false;
-						for (const commit of input.commits) {
-							const impact = commit.impact.collection(input.target);
-							if (impact.kind === "reset") return { kind: "rebuild" };
-							impact.added.forEach((key) => keys.add(key));
-							impact.removed.forEach((key) => keys.add(key));
-							impact.updated.forEach((key) => keys.add(key));
-							structural ||= Boolean(impact.added.size || impact.removed.size || impact.orderChanged);
-						}
-						for (const key of keys) {
-							const entry = input.read.get(key);
-							if (!entry) writer.remove(key);
-							else {
-								require_ownership.profile.collectionView.mapped();
-								writer.set(key, mapper(key, entry));
-							}
-						}
-						if (structural) {
-							const ids = input.read.ids();
-							require_ownership.profile.collectionView.idsScanned(ids.length);
-							writer.order(ids);
-						}
-					} };
+					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 {
@@ -1774,7 +2168,19 @@ Object.defineProperty(exports, "accessOf", {
 Object.defineProperty(exports, "address", {
 	enumerable: true,
 	get: function() {
-		return address;
+		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", {
@@ -1783,12 +2189,24 @@ Object.defineProperty(exports, "belongs", {
 		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() {
@@ -1813,6 +2231,12 @@ Object.defineProperty(exports, "debugKey", {
 		return debugKey;
 	}
 });
+Object.defineProperty(exports, "decodeCommandFootprint", {
+	enumerable: true,
+	get: function() {
+		return decodeCommandFootprint;
+	}
+});
 Object.defineProperty(exports, "dict", {
 	enumerable: true,
 	get: function() {
@@ -1837,6 +2261,12 @@ Object.defineProperty(exports, "field", {
 		return field;
 	}
 });
+Object.defineProperty(exports, "footprintsOverlap", {
+	enumerable: true,
+	get: function() {
+		return footprintsOverlap;
+	}
+});
 Object.defineProperty(exports, "id", {
 	enumerable: true,
 	get: function() {
@@ -1849,6 +2279,18 @@ Object.defineProperty(exports, "impact_target_exports", {
 		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() {
@@ -1909,12 +2351,6 @@ Object.defineProperty(exports, "readWith", {
 		return readWith;
 	}
 });
-Object.defineProperty(exports, "record", {
-	enumerable: true,
-	get: function() {
-		return record;
-	}
-});
 Object.defineProperty(exports, "resolveAddress", {
 	enumerable: true,
 	get: function() {
@@ -1927,6 +2363,12 @@ Object.defineProperty(exports, "resolveLocated", {
 		return resolveLocated;
 	}
 });
+Object.defineProperty(exports, "restore", {
+	enumerable: true,
+	get: function() {
+		return restore;
+	}
+});
 Object.defineProperty(exports, "same", {
 	enumerable: true,
 	get: function() {
@@ -1951,12 +2393,6 @@ Object.defineProperty(exports, "shareNotification", {
 		return shareNotification;
 	}
 });
-Object.defineProperty(exports, "single", {
-	enumerable: true,
-	get: function() {
-		return single;
-	}
-});
 Object.defineProperty(exports, "subscribeRoot", {
 	enumerable: true,
 	get: function() {
@@ -1981,6 +2417,18 @@ Object.defineProperty(exports, "tree", {
 		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() {
@@ -1988,4 +2436,4 @@ Object.defineProperty(exports, "variant", {
 	}
 });
 
-//# sourceMappingURL=runtime-CRijXjYp.cjs.map
+//# sourceMappingURL=runtime-0mOFbe_H.cjs.map