doxum 0.1.6 → 0.1.7

package/dist/{runtime-BJRXF0gq.js → runtime-DF1q9Gje.js}

@@ -3,10 +3,19 @@ import { i as isRecord$1, t as cloneValue, u as profile } from "./ownership-CduR
 //#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
@@ -16,10 +25,6 @@ const variant = (tag, variants) => node({
 	tag,
 	variants
 });
-const single = (value) => node({
-	kind: "single",
-	value
-});
 const table = (value) => node({
 	kind: "table",
 	value
@@ -28,26 +33,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 = {
@@ -79,11 +113,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] ?? "")];
@@ -93,12 +122,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
@@ -111,7 +140,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
 	};
@@ -162,7 +191,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;
@@ -276,25 +305,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);
@@ -325,12 +422,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);
-		profile.reader.structuralSnapshot();
-		return cloneValue(readAt(context, address), "reader");
-	} };
+	if (node.kind === "dict") return {
+		get: (key) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return cloneValue(isRecord$1(value) && Object.prototype.hasOwnProperty.call(value, key) ? value[key] : void 0, "reader");
+		},
+		has: (key) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return isRecord$1(value) && Object.prototype.hasOwnProperty.call(value, key);
+		},
+		keys: () => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return isRecord$1(value) ? Object.keys(value) : [];
+		},
+		values: () => {
+			collectValue(context, address);
+			profile.reader.structuralSnapshot();
+			return cloneValue(readAt(context, address) ?? {}, "reader");
+		}
+	};
 	if (node.kind === "list") return {
+		get: (key) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			if (!Array.isArray(value)) return void 0;
+			return cloneValue(value[keys(value, node.keyOf).index(key)], "reader");
+		},
+		has: (key) => {
+			collectValue(context, address);
+			const value = readAt(context, address);
+			return Array.isArray(value) && keys(value, node.keyOf).index(key) >= 0;
+		},
 		values: () => {
 			collectValue(context, address);
 			const value = readAt(context, address);
@@ -408,14 +533,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 = isRecord$1(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 cloneValue(readAt(context, address), "reader");
+	} };
 	let children;
 	return new Proxy({}, { get: (_target, property) => {
 		if (typeof property === "symbol") return void 0;
@@ -437,19 +558,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();
@@ -476,6 +769,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 = {
@@ -550,7 +848,7 @@ const subscribeTargets = (notification, targets, listener) => {
 		});
 	};
 };
-const notify = (notification, commit) => {
+const notify = (notification, commit, afterSettle) => {
 	notification.notifying = true;
 	const errors = [];
 	const call = (listener) => {
@@ -601,6 +899,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));
@@ -974,239 +1273,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);
@@ -1231,103 +1325,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) {
-				profile.materialized.rebuilt();
-				instance = void 0;
-				const built = spec.build(sources);
-				assertSynchronous(built);
-				instance = built;
-				candidate = built.value;
-			} else {
-				profile.materialized.updated();
-				const result = instance.update(sources);
-				assertSynchronous(result);
-				if (result.kind === "rebuild") {
-					instance = void 0;
-					const built = spec.build(sources);
-					assertSynchronous(built);
-					instance = built;
-					candidate = built.value;
-					build = true;
-				} else candidate = result.kind === "changed" ? result.value : value;
-			}
-			previous = value;
-			changed = !initialized || !(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) => {
-			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({
@@ -1655,10 +1654,374 @@ 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/source.ts
+const createSources = (scheduler) => {
+	const documents = /* @__PURE__ */ new Map();
+	const readables = /* @__PURE__ */ new Map();
+	const collections = /* @__PURE__ */ new WeakSet();
+	const document = (runtime) => {
+		scheduler.assertIdle();
+		const state = accessOf(runtime);
+		if (state.disposed) throw new Error("Document has been disposed.");
+		const existing = documents.get(state);
+		if (existing) return existing;
+		const bindings = [];
+		const make = (targets, collection) => {
+			if (state.disposed) throw new Error("Document has been disposed.");
+			targets.forEach((value) => {
+				if (!belongs(value, state.schema)) throw new Error("Projection target belongs to another schema.");
+			});
+			const old = bindings.find((entry) => Boolean(collection) === collections.has(entry.handle) && entry.targets.length === targets.length && entry.targets.every((value, i) => same(value, targets[i])));
+			if (old) return old.handle;
+			let commits = [];
+			let reset = false;
+			let orderDirty = false;
+			const keys = /* @__PURE__ */ new Set();
+			let candidates;
+			const record = {
+				consumers: /* @__PURE__ */ new Set(),
+				disposed: false,
+				fault: void 0,
+				revision: runtime.revision,
+				reset: () => reset,
+				clear: () => {
+					commits = [];
+					reset = orderDirty = false;
+					keys.clear();
+					candidates = void 0;
+				},
+				context: (active) => {
+					assertScope(active);
+					if (state.disposed) throw new Error("Document has been disposed.");
+					const read = collection ? readerFor(nodeAt(state.schema, collection.address, state.document) ?? collectionSchema(collection), {
+						root: () => state.document,
+						active
+					}, collection.address) : documentReader(state.schema, () => state.document, active);
+					return Object.freeze({
+						read,
+						target: collection,
+						revision: runtime.revision(),
+						commits: Object.freeze(commits.slice()),
+						reset: record.reset(),
+						...collection ? { candidates: candidates ??= Object.freeze({
+							keys: Object.freeze([...keys]),
+							orderDirty
+						}) } : {}
+					});
+				}
+			};
+			const handle = collection ? {} : {
+				collection: (pick) => {
+					scheduler.assertIdle();
+					const selector = state.schema.collection(pick);
+					return make([selector], selector);
+				},
+				targets: (...selected) => {
+					scheduler.assertIdle();
+					if (!selected.length) throw new TypeError("Expected at least one target.");
+					return make(selected);
+				}
+			};
+			Object.freeze(handle);
+			bindings.push({
+				handle,
+				targets,
+				record
+			});
+			if (collection) collections.add(handle);
+			scheduler.register(handle, record);
+			receivers.set(record, (commit) => {
+				commits.push(commit);
+				reset ||= commit.kind === "replace";
+				if (collection) {
+					const change = commit.impact.collection(collection);
+					if (change.kind === "reset") reset = true;
+					else {
+						change.added.forEach((key) => keys.add(key));
+						change.removed.forEach((key) => keys.add(key));
+						change.updated.forEach((key) => keys.add(key));
+						orderDirty ||= Boolean(change.added.size || change.removed.size || change.orderChanged);
+					}
+					candidates = void 0;
+				}
+			});
+			return handle;
+		};
+		const receivers = /* @__PURE__ */ new Map();
+		const handle = make([]);
+		const guard = (locked) => {
+			state.projectionLocks = (state.projectionLocks ?? 0) + (locked ? 1 : -1);
+		};
+		scheduler.guards.add(guard);
+		const unsubscribe = attachProjection(runtime, {
+			capture: (commit) => {
+				for (const binding of bindings) if (!binding.targets.length || binding.targets.some(commit.impact.affects)) {
+					receivers.get(binding.record)(commit);
+					scheduler.capture(binding.record);
+				}
+			},
+			settle: scheduler.settle,
+			flush: scheduler.flush,
+			dispose: () => {
+				bindings.forEach(({ record }) => {
+					record.fault = new ProjectionError("source", "document disposed", [runtime.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
+					scheduler.capture(record);
+				});
+				scheduler.run();
+			}
+		});
+		scheduler.cleanups.add(() => {
+			unsubscribe();
+			scheduler.guards.delete(guard);
+		});
+		documents.set(state, handle);
+		return handle;
+	};
+	const valueSource = (initial, equal) => {
+		let value = initial;
+		let previous = initial;
+		let revision = 0;
+		const handle = Object.freeze({});
+		const record = {
+			consumers: /* @__PURE__ */ new Set(),
+			disposed: false,
+			fault: void 0,
+			revision: () => revision,
+			reset: () => false,
+			clear: () => {
+				previous = value;
+			},
+			context: (active) => {
+				assertScope(active);
+				return Object.freeze({
+					value,
+					previous,
+					revision,
+					changed: !equal(previous, value),
+					reset: false
+				});
+			}
+		};
+		scheduler.register(handle, record);
+		const accept = (next) => {
+			scheduler.assertIdle();
+			const recovering = record.fault !== void 0;
+			if (equal(value, next) && !recovering) return;
+			record.fault = void 0;
+			value = next;
+			revision++;
+			scheduler.capture(record);
+		};
+		return {
+			source: handle,
+			accept,
+			set(next) {
+				accept(next);
+				scheduler.run();
+			}
+		};
+	};
+	return {
+		dispose: () => {
+			documents.clear();
+			readables.clear();
+		},
+		document,
+		input: (initial, options) => {
+			const { source, set } = valueSource(initial, options?.isEqual ?? Object.is);
+			return Object.freeze({
+				source,
+				set
+			});
+		},
+		fromReadable: (readable, options) => {
+			scheduler.assertIdle();
+			if (projectionHandles.has(readable)) throw new Error("Projection nodes must be declared directly as sources.");
+			const equal = options?.isEqual ?? Object.is;
+			let bindings = readables.get(readable);
+			const old = bindings?.get(equal);
+			if (old) return old.source;
+			const input = valueSource(readable.current(), equal);
+			if (bindings) {
+				bindings.set(equal, {
+					source: input.source,
+					accept: (value) => input.accept(value)
+				});
+				return input.source;
+			}
+			bindings = new Map([[equal, {
+				source: input.source,
+				accept: (value) => input.accept(value)
+			}]]);
+			const members = bindings;
+			const receive = (settle = true) => {
+				if (!scheduler.active) return;
+				let value;
+				try {
+					value = readable.current();
+				} catch (cause) {
+					for (const member of members.values()) {
+						const record = scheduler.source(member.source);
+						record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
+						scheduler.capture(record);
+					}
+					if (settle) scheduler.run();
+					return;
+				}
+				for (const member of members.values()) try {
+					member.accept(value);
+				} catch (cause) {
+					const record = scheduler.source(member.source);
+					record.fault = new ProjectionError("source", "external readable", [record.revision()], cause);
+					scheduler.capture(record);
+				}
+				if (settle) scheduler.run();
+			};
+			let unsubscribe;
+			let detach;
+			try {
+				const owner = documentReadableOwner(readable);
+				if (owner) {
+					document(owner);
+					detach = attachProjection(owner, {
+						capture: () => receive(false),
+						settle: scheduler.settle,
+						flush: scheduler.flush,
+						dispose: () => {
+							for (const member of members.values()) {
+								const record = scheduler.source(member.source);
+								record.fault = new ProjectionError("source", "document readable disposed", [record.revision()], /* @__PURE__ */ new Error("Document has been disposed."));
+								scheduler.capture(record);
+							}
+							scheduler.run();
+						}
+					});
+				}
+				unsubscribe = readable.subscribe(() => receive());
+				input.accept(readable.current());
+			} catch (error) {
+				try {
+					unsubscribe?.();
+					detach?.();
+				} finally {
+					scheduler.unregisterSource(input.source);
+				}
+				throw error;
+			}
+			scheduler.cleanups.add(unsubscribe);
+			if (detach) scheduler.cleanups.add(detach);
+			readables.set(readable, bindings);
+			scheduler.run();
+			return input.source;
+		},
+		assertCollection: (handle) => {
+			scheduler.source(handle);
+			if (!collections.has(handle) && !collectionHandles.has(handle)) throw new Error("map requires a collection source.");
+		}
+	};
+};
+//#endregion
+//#region core/src/projection/value.ts
+const createValue = (scheduler, spec, options) => {
+	let instance;
+	let value;
+	let next;
+	let previous;
+	let initialized = false;
+	let revision = 0;
+	let changed = false;
+	let reset = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const owner = createNode(scheduler, spec, {
+		evaluate: (sources, build) => {
+			let candidate;
+			if (build || !instance) {
+				profile.materialized.rebuilt();
+				instance = void 0;
+				const built = spec.build(sources);
+				assertSynchronous(built);
+				instance = built;
+				candidate = built.value;
+			} else {
+				profile.materialized.updated();
+				const result = instance.update(sources);
+				assertSynchronous(result);
+				if (result.kind === "rebuild") {
+					instance = void 0;
+					const built = spec.build(sources);
+					assertSynchronous(built);
+					instance = built;
+					candidate = built.value;
+					build = true;
+				} else candidate = result.kind === "changed" ? result.value : value;
+			}
+			previous = value;
+			changed = !initialized || !(options?.isEqual ?? Object.is)(value, candidate);
+			next = changed ? candidate : value;
+			reset = build;
+			return changed;
+		},
+		context: (active) => {
+			assertScope(active);
+			return Object.freeze({
+				value: next,
+				previous,
+				changed,
+				revision: revision + (changed ? 1 : 0),
+				reset
+			});
+		},
+		revision: () => revision,
+		reset: () => reset,
+		publish: () => {
+			if (changed && initialized) revision++;
+			value = next;
+			initialized = true;
+		},
+		emit: (call) => {
+			profile.materialized.notification();
+			Array.from(listeners).forEach((listener) => call(listener));
+		},
+		clear: () => {
+			next = value;
+			previous = value;
+			changed = false;
+			reset = false;
+		},
+		release: () => {
+			listeners.clear();
+			instance = void 0;
+			value = next = previous = void 0;
+		}
+	});
+	const handle = Object.freeze({
+		current: () => {
+			owner.check();
+			return value;
+		},
+		revision: () => {
+			owner.check();
+			return revision;
+		},
+		subscribe: (listener) => {
+			owner.check();
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		rebuild: owner.rebuild,
+		dispose: owner.dispose
+	});
+	owner.install(handle);
+	return handle;
+};
+//#endregion
 //#region core/src/projection/runtime.ts
 const debug = /* @__PURE__ */ new WeakMap();
 const projectionDebug = (runtime) => {
@@ -1669,54 +2032,85 @@ const projectionDebug = (runtime) => {
 const createProjectionRuntime = (options) => {
 	const scheduler = createScheduler(options.onError);
 	const sources = createSources(scheduler);
+	function value(input, computeOrOptions, options) {
+		if (typeof computeOrOptions !== "function") return createValue(scheduler, input, computeOrOptions);
+		const compute = (input) => {
+			const result = computeOrOptions(input);
+			assertSynchronous(result);
+			return result;
+		};
+		return createValue(scheduler, {
+			sources: input,
+			build: (input) => ({
+				value: compute(input),
+				update: (input) => ({
+					kind: "changed",
+					value: compute(input)
+				})
+			})
+		}, options);
+	}
+	const map = (source, mapper, options) => {
+		sources.assertCollection(source);
+		const calculate = (id, entry) => {
+			const value = mapper(id, entry);
+			assertSynchronous(value);
+			return value;
+		};
+		return createCollection(scheduler, {
+			sources: { source },
+			isEqual: options?.isEqual,
+			build: ({ sources, writer }) => {
+				const input = sources.source;
+				const read = "read" in input ? input.read : input;
+				const ids = read.ids();
+				profile.collectionView.idsScanned(ids.length);
+				for (const id of ids) {
+					profile.collectionView.mapped();
+					writer.set(id, calculate(id, read.get(id)));
+				}
+				writer.order(ids);
+				return { update: ({ sources, writer }) => {
+					const input = sources.source;
+					if (input.reset) return { kind: "rebuild" };
+					const read = "read" in input ? input.read : input;
+					let keys;
+					let structural;
+					if ("candidates" in input) {
+						keys = input.candidates.keys;
+						structural = input.candidates.orderDirty;
+					} else {
+						const change = input.change;
+						if (!change) return;
+						if (change.kind === "reset") return { kind: "rebuild" };
+						keys = new Set([
+							...change.added,
+							...change.removed,
+							...change.updated
+						]);
+						structural = Boolean(change.added.size || change.removed.size || change.orderChanged);
+					}
+					for (const key of keys) if (!read.has(key)) writer.remove(key);
+					else {
+						profile.collectionView.mapped();
+						writer.set(key, calculate(key, read.get(key)));
+					}
+					if (structural) {
+						const ids = read.ids();
+						profile.collectionView.idsScanned(ids.length);
+						writer.order(ids);
+					}
+				} };
+			}
+		});
+	};
 	const runtime = {
 		document: sources.document,
 		input: sources.input,
 		fromReadable: sources.fromReadable,
-		value: (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();
-					profile.collectionView.idsScanned(ids.length);
-					for (const id of ids) {
-						profile.collectionView.mapped();
-						writer.set(id, mapper(id, sources.source.read.get(id)));
-					}
-					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 {
-								profile.collectionView.mapped();
-								writer.set(key, mapper(key, entry));
-							}
-						}
-						if (structural) {
-							const ids = input.read.ids();
-							profile.collectionView.idsScanned(ids.length);
-							writer.order(ids);
-						}
-					} };
-				}
-			});
-		},
+		value,
+		collection: () => (spec) => createCollection(scheduler, spec),
+		map,
 		batch: scheduler.batch,
 		dispose: () => {
 			try {
@@ -1730,6 +2124,6 @@ const createProjectionRuntime = (options) => {
 	return Object.freeze(runtime);
 };
 //#endregion
-export { dict as A, tree as B, debugKey as C, resolveAddress as D, read as E, optional as F, record as I, schema as L, list as M, map as N, resolveLocated as O, object as P, single as R, contains as S, overlaps as T, variant as V, address as _, createNotification as a, impact_target_exports as b, shareNotification as c, accessOf as d, bindRuntimeAccess as f, documentReader as g, DocumentReentrancyError as h, ProjectionError as i, field as j, set as k, subscribeRoot as l, DocumentDisposedError as m, projectionDebug as n, disposeNotification as o, readWith as p, ProjectionDisposedError as r, notify as s, createProjectionRuntime as t, subscribeTargets as u, belongs as v, locate as w, same as x, id as y, table as z };
+export { id as A, set as B, restore as C, DocumentReentrancyError as D, DocumentDisposedError as E, locate as F, object as G, field as H, overlaps as I, table as J, optional as K, read as L, same as M, contains as N, address$1 as O, debugKey as P, resolveAddress as R, keys as S, validPositions as T, list as U, dict as V, map as W, variant as X, tree as Y, footprintsOverlap as _, bindDocumentReadable as a, at as b, notify as c, subscribeTargets as d, accessOf as f, decodeCommandFootprint as g, commandFootprint as h, ProjectionError as i, impact_target_exports as j, belongs as k, shareNotification as l, readWith as m, projectionDebug as n, createNotification as o, bindRuntimeAccess as p, schema as q, ProjectionDisposedError as r, disposeNotification as s, createProjectionRuntime as t, subscribeRoot as u, documentReader as v, valid as w, index as x, afterRemove as y, resolveLocated as z };
 
-//# sourceMappingURL=runtime-BJRXF0gq.js.map
+//# sourceMappingURL=runtime-DF1q9Gje.js.map