doxum 0.1.11 → 0.1.13

package/dist/{store-DHFXfWSz.js → store-CtgvCVFg.js}

@@ -1,189 +1,8 @@
-import { A as insert$2, C as validate, D as equal, E as afterRemove, I as valid, L as profile, M as keys, O as index, P as move$2, T as isRecord, a as compiledShape, b as contains, g as resolveLocated, i as AddressIndex, k as indexedKeys, m as resolveChild, n as fail, o as contains$1, u as nodeAt, w as isPlainObject, x as parent, y as children } from "./issue-DVaGQGeP.js";
-//#region core/src/schema-value.ts
-var ParseError = class extends TypeError {
-	issues;
-	constructor(issue) {
-		super(`${issue.message} at ${JSON.stringify(issue.address)}`);
-		this.name = "ParseError";
-		this.issues = Object.freeze([Object.freeze({
-			...issue,
-			address: Object.freeze([...issue.address])
-		})]);
-	}
-};
-const issue = (address, message, code = "invalid-value") => ({
-	address,
-	message,
-	code
-});
-const checkScalar = (validator, value, address, strict) => {
-	if (!validator) return strict ? issue(address, "A validator is required to parse an opaque value.", "missing-validator") : void 0;
-	try {
-		const result = typeof validator === "function" ? validator(value) : validator["~standard"].validate(value);
-		if (result && (typeof result === "object" || typeof result === "function") && "then" in result && typeof result.then === "function") return issue(address, "Validators must be synchronous.");
-		if (typeof validator !== "function") {
-			if (!isRecord(result)) return issue(address, "Malformed validator result.");
-			if (Array.isArray(result.issues)) {
-				const first = result.issues[0];
-				return issue([...address, ...(first?.path ?? []).map((part) => String(typeof part === "object" ? part.key : part))], first?.message ?? "Value validation failed.");
-			}
-			if (!Object.hasOwn(result, "value")) return issue(address, "Malformed validator result.");
-		}
-		return;
-	} catch (error) {
-		return issue(address, error instanceof Error ? error.message : "Value validation failed.");
-	}
-};
-const checkKey = (validator, value, address) => {
-	if (typeof value !== "string") return issue(address, "Collection keys must be strings.", "invalid-key");
-	const failure = checkScalar(validator, value, address, false);
-	return failure ? {
-		...failure,
-		code: "invalid-key"
-	} : void 0;
-};
-const checkValue = (node, value, address = [], strict = false) => {
-	if (node.optional && value === void 0) return void 0;
-	if (node.kind === "field") return checkScalar(node.validator, value, address, strict);
-	if (node.kind === "object" || node.kind === "variant") {
-		if (!isPlainObject(value)) return issue(address, "Expected an object.");
-		if (node.kind === "variant") {
-			const tag = value[node.tag];
-			if (!Object.hasOwn(value, node.tag) || typeof tag !== "string" || !Object.hasOwn(node.variants, tag)) return issue([...address, node.tag], "Unknown variant tag.");
-		}
-		const { members } = compiledShape(node, value);
-		for (const key of Reflect.ownKeys(value)) {
-			if (node.kind === "variant" && key === node.tag) continue;
-			if (typeof key !== "string" || !members.has(key)) return issue([...address, String(key)], "Property is not declared in the object schema.");
-		}
-		for (const [key, member] of members) {
-			const child = member.node;
-			if (!Object.prototype.hasOwnProperty.call(value, key) && !child.optional) return issue([...address, key], "Required property is missing.");
-			const failure = checkValue(child, value[key], [...address, key], strict);
-			if (failure) return failure;
-		}
-		return;
-	}
-	if (node.kind === "table" || node.kind === "map") {
-		if (!isPlainObject(value)) return issue(address, "Expected a collection object.");
-		const entries = node.kind === "table" ? value.byId : value;
-		if (!isPlainObject(entries)) return issue(address, "Expected a byId object.");
-		if (node.kind === "table") {
-			if (!Array.isArray(value.ids) || value.ids.length !== Object.keys(entries).length) return issue(address, "Table ids and entries must agree.");
-			const seen = /* @__PURE__ */ new Set();
-			for (const id of value.ids) {
-				const failure = checkKey(node.key, id, address);
-				if (failure) return failure;
-				if (seen.has(id) || !Object.prototype.hasOwnProperty.call(entries, id)) return issue(address, "Table ids must be unique and reference existing entries.");
-				seen.add(id);
-			}
-		}
-		for (const id of Object.keys(entries)) {
-			const failure = checkKey(node.key, id, [...address, id]) ?? checkValue(node.value, entries[id], [...address, id], strict);
-			if (failure) return failure;
-		}
-		return;
-	}
-	if (node.kind === "list") {
-		if (!Array.isArray(value)) return issue(address, "Expected a list.");
-		const seen = /* @__PURE__ */ new Set();
-		const order = keys(value, node.keyOf);
-		for (let i = 0; i < value.length; i++) {
-			const failure = checkValue(node.value, value[i], [...address, String(i)], strict);
-			if (failure) return failure;
-			let key;
-			try {
-				key = order.at(i);
-			} catch {
-				return issue(address, "List keyOf failed.");
-			}
-			if (typeof key !== "string" || seen.has(key)) return issue(address, "List keys must be unique strings.", "invalid-key");
-			seen.add(key);
-		}
-		return;
-	}
-	if (!validate(value)) return issue(address, "Invalid tree structure.", "invalid-tree");
-	if (isRecord(value) && isRecord(value.nodes)) for (const id of Object.keys(value.nodes)) {
-		const entry = value.nodes[id];
-		if (isRecord(entry) && Object.prototype.hasOwnProperty.call(entry, "value")) {
-			const failure = checkValue(node.value, entry.value, [...address, id], strict);
-			if (failure) return failure;
-		}
-	}
-};
-/** Copy editable structure; atomic payloads retain their immutable ownership contract. */
-const copyValue = (node, value) => {
-	if (value === void 0 || node.kind === "field") return value;
-	profile.copy.structure();
-	if ((node.kind === "object" || node.kind === "variant") && isRecord(value)) {
-		const result = Object.create(Object.getPrototypeOf(value));
-		const { members } = compiledShape(node, value);
-		for (const key of Object.getOwnPropertyNames(value)) Object.defineProperty(result, key, {
-			value: node.kind === "variant" && key === node.tag ? value[key] : copyValue(members.get(key).node, value[key]),
-			writable: true,
-			enumerable: Object.getOwnPropertyDescriptor(value, key)?.enumerable,
-			configurable: true
-		});
-		return result;
-	}
-	if ((node.kind === "table" || node.kind === "map") && isRecord(value)) {
-		const entries = node.kind === "table" ? value.byId : value;
-		const result = Object.fromEntries(Object.keys(entries).map((id) => [id, copyValue(node.value, entries[id])]));
-		return node.kind === "table" ? {
-			ids: [...value.ids],
-			byId: result
-		} : result;
-	}
-	if (node.kind === "list") return [...value];
-	if (node.kind === "tree" && isRecord(value)) {
-		const entries = value.nodes;
-		return {
-			...value,
-			nodes: Object.fromEntries(Object.entries(entries).map(([id, n]) => [id, {
-				...n,
-				children: [...n.children]
-			}]))
-		};
-	}
-	return value;
-};
-const equalValue = (node, left, right) => {
-	if (Object.is(left, right)) return true;
-	if (node.kind === "field" || left === void 0 || right === void 0) return false;
-	if ((node.kind === "object" || node.kind === "variant") && isRecord(left) && isRecord(right)) {
-		if (node.kind === "variant" && left[node.tag] !== right[node.tag]) return false;
-		for (const [key, member] of compiledShape(node, left).members) {
-			if (Object.hasOwn(left, key) !== Object.hasOwn(right, key)) return false;
-			if (!equalValue(member.node, left[key], right[key])) return false;
-		}
-		return true;
-	}
-	if (node.kind === "list" && Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((v, i) => equalValue(node.value, v, right[i]));
-	if (node.kind === "table" && isRecord(left) && isRecord(right)) return equal(left.ids, right.ids) && equalValue({
-		kind: "map",
-		value: node.value
-	}, left.byId, right.byId);
-	if (node.kind === "tree" && isRecord(left) && isRecord(right)) {
-		if (left.rootId !== right.rootId) return false;
-		const a = left.nodes, b = right.nodes;
-		return Object.keys(a).length === Object.keys(b).length && Object.keys(a).every((id) => Object.hasOwn(b, id) && a[id].parentId === b[id].parentId && equal(a[id].children, b[id].children) && Object.hasOwn(a[id], "value") === Object.hasOwn(b[id], "value") && equalValue(node.value, a[id].value, b[id].value));
-	}
-	if (node.kind === "map" && isRecord(left) && isRecord(right)) {
-		const keys = Object.keys(left);
-		return keys.length === Object.keys(right).length && keys.every((key) => Object.hasOwn(right, key) && equalValue(node.value, left[key], right[key]));
-	}
-	return false;
-};
-const parse = (node, input) => {
-	const valueNode = node;
-	const failure = checkValue(valueNode, input, [], true);
-	if (failure) throw new ParseError(failure);
-	return copyValue(valueNode, input);
-};
-//#endregion
+import { L as profile, f as read, i as AddressIndex, o as contains } from "./issue-DVaGQGeP.js";
+import { d as createAccess, h as checkKey, o as definitionOf, p as snapshot, u as collectionAccess } from "./definition-DXrKMVs7.js";
 //#region core/src/schema.ts
-const node$1 = (value) => Object.freeze(value);
-const field = (validator) => node$1({
+const node = (value) => Object.freeze(value);
+const field = (validator) => node({
 	kind: "field",
 	...validator ? { validator } : {}
 });
@@ -195,36 +14,36 @@ const optional = (value) => {
 		"list",
 		"tree"
 	].includes(value.kind)) throw new TypeError("Only field, variant, map, list and tree nodes support optional presence.");
-	return node$1({
+	return node({
 		...value,
 		optional: true
 	});
 };
-const object = (shape) => node$1({
+const object = (shape) => node({
 	kind: "object",
 	shape: Object.freeze({ ...shape })
 });
-const variant = (tag, variants) => node$1({
+const variant = (tag, variants) => node({
 	kind: "variant",
 	tag,
 	variants: Object.freeze({ ...variants })
 });
-const table = (value, options) => node$1({
+const table = (value, options) => node({
 	kind: "table",
 	value,
 	...options
 });
-const map = (value, options) => node$1({
+const map = (value, options) => node({
 	kind: "map",
 	value,
 	...options
 });
-const list = (value, config) => node$1({
+const list = (value, config) => node({
 	kind: "list",
 	keyOf: config.keyOf,
 	value
 });
-const tree = (value) => node$1({
+const tree = (value) => node({
 	kind: "tree",
 	value
 });
@@ -269,542 +88,6 @@ const compilePath = (owner, kind, pick) => {
 	});
 };
 //#endregion
-//#region core/src/mutation/operations/map.ts
-function put(session, container, id, value) {
-	if (container.node.kind !== "map") return fail(container.at, "invalid-collection", "Expected a map.");
-	session.writeMember(container, id, value, "set");
-}
-function remove$3(session, container, id) {
-	if (container.node.kind !== "map") return fail(container.at, "invalid-collection", "Expected a map.");
-	session.writeMember(container, id, void 0, "remove");
-}
-//#endregion
-//#region core/src/mutation/operations/table.ts
-function create(session, container, entries, position) {
-	const { at, node, value } = container;
-	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
-	const table = value;
-	if (!valid(table.ids, position)) return fail(at, "invalid-anchor", "Unknown table anchor.");
-	const ids = /* @__PURE__ */ new Set();
-	for (const entry of entries) {
-		if (Object.hasOwn(table.byId, entry.id) || ids.has(entry.id)) return fail(at, "duplicate-entity", "Table key already exists.");
-		ids.add(entry.id);
-	}
-	if (!entries.length) return;
-	const index$1 = index(table.ids, position);
-	for (const entry of entries) session.writeMember(container, entry.id, entry.value, "set");
-	const length = table.ids.length;
-	table.ids.length += entries.length;
-	table.ids.copyWithin(index$1 + entries.length, index$1, length);
-	for (let i = 0; i < entries.length; i++) table.ids[index$1 + i] = entries[i].id;
-}
-function remove$2(session, container, ids) {
-	const { at, node, value } = container;
-	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
-	const table = value;
-	for (const id of ids) if (!Object.hasOwn(table.byId, id)) return fail(at, "missing-entity", "Table key does not exist.");
-	if (!ids.length) return;
-	const removed = new Set(ids);
-	for (const id of removed) session.writeMember(container, id, void 0, "remove");
-	table.ids = table.ids.filter((id) => !removed.has(id));
-}
-function replace$3(session, container, id, value) {
-	const { at, node, value: tableValue } = container;
-	if (node.kind !== "table") return fail(at, "invalid-collection", "Expected a table.");
-	const table = tableValue;
-	if (!Object.hasOwn(table.byId, id)) return fail(at.concat(id), "missing-entity", "Table key does not exist.");
-	session.writeMember(container, id, value, "set");
-}
-//#endregion
-//#region core/src/mutation/operations/list.ts
-function insert$1(session, container, value, position) {
-	const { at, node, value: current } = container;
-	if (node.kind !== "list") return fail(at, "invalid-list-key", "Expected a list.");
-	session.validate(node.value, value, at);
-	const id = node.keyOf(value);
-	if (typeof id !== "string") return fail(at, "invalid-list-key", "List key must be a string.");
-	const items = current, keys$2 = keys(items, node.keyOf);
-	if (keys$2.index(id) >= 0) return fail(at, "duplicate-list-item", "List key already exists.");
-	if (!valid(keys$2, position)) return fail(at, "invalid-anchor", "Unknown list anchor.");
-	session.recorder.order(container);
-	session.recorder.member(container, id, session.definition(container, id), -1);
-	insert$2(items, index(keys$2, position), value);
-	session.invalidate();
-}
-function replace$2(session, container, id, value) {
-	const { at, node, value: items } = container;
-	if (node.kind !== "list") return fail(at, "invalid-list-key", "Expected a list.");
-	const index = indexedKeys(items, node.keyOf).index(id);
-	if (index < 0) return fail(at, "missing-list-item", "List key does not exist.");
-	session.writeMember(container, id, value, "set", index);
-}
-function remove$1(session, container, id) {
-	const { at, node, value } = container;
-	if (node.kind !== "list") return fail(at, "missing-list-item", "List key does not exist.");
-	const index = keys(value, node.keyOf).index(id);
-	if (index < 0) return fail(at, "missing-list-item", "List key does not exist.");
-	session.writeMember(container, id, void 0, "remove", index);
-}
-//#endregion
-//#region core/src/mutation/operations/tree.ts
-const node = (tree, id) => Object.hasOwn(tree.nodes, id) ? tree.nodes[id] : void 0;
-const positionIndex = (index, length, at) => {
-	if (index !== void 0 && (!Number.isInteger(index) || index < 0)) return fail(at, "invalid-tree-index", "Tree index must be nonnegative.");
-	return Math.min(index ?? length, length);
-};
-const insert = (session, container, id, value, position) => {
-	const { at, node: schema, value: tree } = container;
-	if (typeof id !== "string") return fail(at, "invalid-key", "Tree keys must be strings.");
-	if (contains(tree, id)) return fail(at, "duplicate-tree-node", "Tree node already exists.");
-	const parentId = position?.parentId;
-	const parent = parentId === void 0 ? void 0 : node(tree, parentId);
-	if (tree.rootId !== void 0 && !parent || tree.rootId === void 0 && parentId !== void 0) return fail(at, "missing-tree-parent", "A nonempty tree requires an existing parent.");
-	const index = positionIndex(position?.index, parent?.children.length ?? 0, at);
-	session.validate(schema.value, value, at.concat(id));
-	session.recorder.tree(container, id);
-	if (parentId !== void 0) session.recorder.tree(container, parentId);
-	Object.defineProperty(tree.nodes, id, {
-		value: {
-			...parentId === void 0 ? {} : { parentId },
-			children: [],
-			value
-		},
-		writable: true,
-		configurable: true,
-		enumerable: true
-	});
-	if (parent) parent.children.splice(index, 0, id);
-	else tree.rootId = id;
-	session.invalidate();
-};
-const replace$1 = (session, container, id, value) => {
-	const { at, node: schema, value: tree } = container;
-	const entry = node(tree, id);
-	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
-	if (Object.is(entry.value, value) && Object.hasOwn(entry, "value")) return;
-	session.validate(schema.value, value, at.concat(id));
-	session.recorder.tree(container, id);
-	entry.value = value;
-};
-const remove = (session, container, id) => {
-	const { at, value: tree } = container;
-	const entry = node(tree, id);
-	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
-	const ids = [], stack = [id];
-	while (stack.length) {
-		const current = stack.pop();
-		ids.push(current);
-		for (const child of tree.nodes[current].children) stack.push(child);
-	}
-	for (const key of ids) session.recorder.tree(container, key);
-	if (entry.parentId !== void 0) session.recorder.tree(container, entry.parentId);
-	if (entry.parentId === void 0) delete tree.rootId;
-	else {
-		const children = tree.nodes[entry.parentId].children;
-		children.splice(children.indexOf(id), 1);
-	}
-	for (const key of ids) delete tree.nodes[key];
-	session.invalidate();
-};
-const move$1 = (session, container, id, position) => {
-	const { at, value: tree } = container;
-	const entry = node(tree, id), parentId = position?.parentId;
-	if (!entry) return fail(at, "missing-tree-node", "Tree node does not exist.");
-	if (entry.parentId === void 0 || parentId === void 0 || !contains(tree, parentId)) return fail(at, "missing-tree-parent", "Moving requires a non-root node and an existing parent.");
-	for (let ancestor = parentId; ancestor !== void 0; ancestor = tree.nodes[ancestor].parentId) if (ancestor === id) return fail(at, "tree-cycle", "Cannot move a node under its descendant.");
-	const old = tree.nodes[entry.parentId], next = tree.nodes[parentId];
-	const index = positionIndex(position?.index, next.children.length - (old === next ? 1 : 0), at);
-	const previous = old.children.indexOf(id);
-	if (old === next && previous === index) return;
-	session.recorder.tree(container, id);
-	session.recorder.tree(container, entry.parentId);
-	session.recorder.tree(container, parentId);
-	old.children.splice(previous, 1);
-	next.children.splice(index, 0, id);
-	entry.parentId = parentId;
-	session.invalidate();
-};
-//#endregion
-//#region core/src/mutation/operations/order.ts
-function move(session, container, id, position) {
-	const { at, node, value } = container;
-	if (node.kind !== "table" && node.kind !== "list") return fail(at, "invalid-collection", "Expected an ordered container.");
-	const items = node.kind === "table" ? value.ids : value;
-	const keys$1 = node.kind === "table" ? items : keys(items, node.keyOf);
-	const index = node.kind === "table" ? items.indexOf(id) : keys$1.index(id);
-	if (index < 0) return fail(at, "missing-entity", "Ordered key does not exist.");
-	if (!valid(keys$1, position)) return fail(at, "invalid-anchor", "Unknown order anchor.");
-	const next = afterRemove(keys$1, index, position);
-	if (next === index) return;
-	session.recorder.order(container);
-	move$2(items, index, next);
-	session.invalidate();
-}
-//#endregion
-//#region core/src/access/scope.ts
-const locations = /* @__PURE__ */ new WeakMap();
-const locationOf = (value) => locations.get(value);
-const addressOf = (target) => {
-	if (target.at) return target.at;
-	profile.access("addresses");
-	return target.at = addressOf(target.parent).concat(target.key);
-};
-const assertActive = (context) => {
-	if (context.active && !context.active()) throw new Error("Document access scope has expired.");
-};
-const collect = (context, at, kind = "value", id) => {
-	context.dependencies?.record(kind === "value" ? {
-		kind,
-		at
-	} : {
-		kind,
-		at,
-		...id === void 0 ? {} : { id }
-	});
-};
-const snapshot = (value) => {
-	const location = value && typeof value === "object" ? locationOf(value) : void 0;
-	if (!location) return value;
-	const { context } = location;
-	const at = addressOf(location.target);
-	profile.access("snapshots");
-	collect(context, at);
-	const resolved = resolve(context, location.target);
-	if (!resolved.node) throw new Error("The selected schema address no longer exists.");
-	return copyValue(resolved.node, resolved.value);
-};
-const replace = (container, key, value) => {
-	if (!locationOf(container)) throw new TypeError("replace requires scoped document access.");
-	if (typeof key !== "string") throw new TypeError("Document keys must be strings.");
-	Reflect.set(container, key, value);
-};
-const resolve = (context, target) => {
-	assertActive(context);
-	const generation = context.session?.generation ?? 0;
-	if (target.generation !== generation) {
-		profile.access("resolutions");
-		if (!target.parent && !target.at.length) {
-			target.node = context.state.schema;
-			target.value = context.state.document;
-		} else {
-			const parent = target.parent && resolve(context, target.parent);
-			const location = parent ? resolveChild(parent.node, parent.value, target.key) : resolveLocated(context.state.schema, context.state.document, target.at);
-			target.node = location?.node ?? nodeAt(context.state.schema, addressOf(target), context.state.document);
-			target.value = location && Object.hasOwn(location.parent, location.key) ? location.parent[location.key] : void 0;
-		}
-		target.generation = generation;
-	}
-	return target;
-};
-const createAccess = (context, initial = []) => {
-	profile.access("scopes");
-	const mutable = () => {
-		assertActive(context);
-		if (!context.session) throw new TypeError("Cannot modify read-only document access.");
-		return context.session;
-	};
-	const writableContainer = (target, session) => {
-		if (target.container?.generation === session.generation && "layout" in target.container) return target.container;
-		return target.container = session.bind(addressOf(target), target.node, target.value);
-	};
-	const childAt = (target, key) => {
-		profile.access("addresses");
-		return addressOf(target).concat(key);
-	};
-	const access = (target) => {
-		if (target.proxy) return target.proxy;
-		const proxy = new Proxy(target, handler);
-		profile.access("proxies");
-		locations.set(proxy, {
-			context,
-			target
-		});
-		target.proxy = proxy;
-		return proxy;
-	};
-	const createTarget = (at, parent, key) => ({
-		at,
-		parent,
-		key,
-		node: void 0,
-		value: void 0,
-		generation: -1,
-		children: void 0,
-		proxy: void 0
-	});
-	const childAccess = (target, member, node, value) => {
-		const key = typeof member === "string" ? member : member.key;
-		if (node.kind === "field" || value === void 0) {
-			if (context.dependencies) collect(context, childAt(target, key));
-			return value;
-		}
-		let children = target.children;
-		let child;
-		if (typeof member !== "string") {
-			if (children?.kind !== "fixed" || children.schema !== target.node) children = {
-				kind: "fixed",
-				schema: target.node,
-				slots: new Array(compiledShape(target.node, target.value).members.size)
-			};
-			child = children.slots[member.slot] ??= createTarget(void 0, target, key);
-		} else {
-			if (children?.kind !== "dynamic") children = {
-				kind: "dynamic",
-				keys: /* @__PURE__ */ new Map()
-			};
-			const retained = children.keys.get(key);
-			child = retained ?? createTarget(void 0, target, key);
-			if (!retained) children.keys.set(key, child);
-		}
-		target.children = children;
-		if (child.generation === target.generation) return child.proxy;
-		child.node = node;
-		child.value = value;
-		child.generation = target.generation;
-		return access(child);
-	};
-	const collectionValue = (target, node) => {
-		const current = resolve(context, target);
-		if (current.node !== node || current.value === void 0) throw new TypeError("The collection method belongs to a replaced schema branch.");
-		return current.value;
-	};
-	const writableCollection = (target, node) => {
-		const session = mutable();
-		collectionValue(target, node);
-		return writableContainer(target, session);
-	};
-	const writableTree = (target, node) => {
-		const session = mutable();
-		collectionValue(target, node);
-		if (target.container?.generation === session.generation && !("layout" in target.container)) return target.container;
-		return target.container = session.bindTree(addressOf(target), target.node, target.value);
-	};
-	const replaceCollection = (target, node, value) => {
-		const session = mutable();
-		collectionValue(target, node);
-		session.replace(addressOf(target), value);
-	};
-	const mapMethod = (target, property, node) => {
-		if (property === "ids") return () => {
-			const current = collectionValue(target, node);
-			if (context.dependencies) collect(context, addressOf(target), "collection");
-			return Object.keys(current);
-		};
-		if (property === "has") return (id) => {
-			const current = collectionValue(target, node);
-			if (context.dependencies) collect(context, addressOf(target), "collection", id);
-			return Object.hasOwn(current, id);
-		};
-		if (property === "get") return (id) => {
-			const current = collectionValue(target, node);
-			if (context.dependencies) collect(context, addressOf(target), "collection", id);
-			if (!Object.hasOwn(current, id)) return void 0;
-			if (node.value.kind === "field") {
-				if (context.dependencies) collect(context, childAt(target, id));
-				return current[id];
-			}
-			return childAccess(target, id, node.value, current[id]);
-		};
-		if (property === "put") return (id, value) => {
-			const writable = writableCollection(target, node);
-			put(context.session, writable, id, value);
-		};
-		if (property === "remove") return (id) => {
-			const writable = writableCollection(target, node);
-			remove$3(context.session, writable, id);
-		};
-		if (property === "replace") return (value) => replaceCollection(target, node, value);
-	};
-	const orderedMethod = (target, property, node) => {
-		const at = addressOf(target);
-		if (property === "ids") return () => {
-			const current = collectionValue(target, node);
-			collect(context, at, "collection");
-			return node.kind === "table" ? [...current.ids] : current.map(node.keyOf);
-		};
-		if (property === "has") return (id) => {
-			const current = collectionValue(target, node);
-			collect(context, at, "collection", id);
-			return node.kind === "table" ? Object.hasOwn(current.byId, id) : indexedKeys(current, node.keyOf).index(id) >= 0;
-		};
-		if (property === "get") return (id) => {
-			const current = collectionValue(target, node);
-			collect(context, at, "collection", id);
-			const location = resolveChild(node, current, id);
-			if (!location || !Object.hasOwn(location.parent, location.key)) return void 0;
-			return childAccess(target, id, location.node, location.parent[location.key]);
-		};
-		if (property === "move") return (id, position) => {
-			const writable = writableCollection(target, node);
-			move(context.session, writable, id, position);
-		};
-	};
-	const tableMethod = (target, property, node) => {
-		if (property === "create") return (input, valueOrPosition, position) => {
-			const writable = writableCollection(target, node);
-			create(context.session, writable, Array.isArray(input) ? input : [{
-				id: input,
-				value: valueOrPosition
-			}], Array.isArray(input) ? valueOrPosition : position);
-		};
-		if (property === "remove") return (ids) => {
-			const writable = writableCollection(target, node);
-			remove$2(context.session, writable, typeof ids === "string" ? [ids] : ids);
-		};
-		if (property === "replace") return (...args) => {
-			const [valueOrId, value] = args;
-			if (args.length === 1) return replaceCollection(target, node, valueOrId);
-			const writable = writableCollection(target, node);
-			replace$3(context.session, writable, valueOrId, value);
-		};
-		return orderedMethod(target, property, node);
-	};
-	const listMethod = (target, property, node) => {
-		if (property === "insert") return (value, position) => {
-			const writable = writableCollection(target, node);
-			insert$1(context.session, writable, value, position);
-		};
-		if (property === "remove") return (id) => {
-			const writable = writableCollection(target, node);
-			remove$1(context.session, writable, id);
-		};
-		if (property === "replace") return (...args) => {
-			const [valueOrId, value] = args;
-			if (args.length === 1) return replaceCollection(target, node, valueOrId);
-			const writable = writableCollection(target, node);
-			replace$2(context.session, writable, valueOrId, value);
-		};
-		return orderedMethod(target, property, node);
-	};
-	const treeMethod = (target, property, node) => {
-		const at = addressOf(target);
-		if (property === "insert") return (id, value, position) => {
-			const writable = writableTree(target, node);
-			insert(context.session, writable, id, value, position);
-		};
-		if (property === "remove") return (id) => {
-			const writable = writableTree(target, node);
-			remove(context.session, writable, id);
-		};
-		if (property === "move") return (id, position) => {
-			const writable = writableTree(target, node);
-			move$1(context.session, writable, id, position);
-		};
-		if (property === "replace") return (...args) => {
-			const [valueOrId, value] = args;
-			if (args.length === 1) return replaceCollection(target, node, valueOrId);
-			const writable = writableTree(target, node);
-			replace$1(context.session, writable, valueOrId, value);
-		};
-		const current = () => {
-			collect(context, at);
-			return collectionValue(target, node);
-		};
-		if (property === "rootId") return () => current().rootId;
-		if (property === "get") return (id) => {
-			const value = current();
-			return contains(value, id) ? value.nodes[id].value : void 0;
-		};
-		if (property === "has") return (id) => contains(current(), id);
-		if (property === "parent") return (id) => parent(current(), id);
-		if (property === "children") return (id) => {
-			const children$1 = children(current(), id);
-			return children$1 ? [...children$1] : void 0;
-		};
-	};
-	const handler = {
-		get: (target, property) => {
-			const { node, value } = resolve(context, target);
-			if (!node || value === void 0) return void 0;
-			if (typeof property !== "string") return void 0;
-			if (node.kind === "map") return mapMethod(target, property, node);
-			if (node.kind === "table") return tableMethod(target, property, node);
-			if (node.kind === "list") return listMethod(target, property, node);
-			if (node.kind === "tree") return treeMethod(target, property, node);
-			if (node.kind === "variant" && property === node.tag) {
-				collect(context, childAt(target, property));
-				return value[property];
-			}
-			const member = compiledShape(node, value)?.members.get(property);
-			if (!member) return void 0;
-			if (member.field) {
-				if (context.dependencies) collect(context, childAt(target, property));
-				return value[property];
-			}
-			return childAccess(target, node.kind === "object" ? member : property, member.node, value[property]);
-		},
-		set: (target, property, value) => {
-			const session = mutable(), { node } = resolve(context, target);
-			if (typeof property !== "string" || !node || node.kind !== "object" && node.kind !== "variant") throw new TypeError("Invalid structural assignment.");
-			if (node.kind === "variant" && node.tag === property) throw new TypeError("Variant discriminants are read-only.");
-			session.assignMember(writableContainer(target, session), property, value);
-			return true;
-		},
-		deleteProperty: (target, property) => {
-			const session = mutable(), { node } = resolve(context, target);
-			if (typeof property !== "string" || node?.kind === "map" || node?.kind === "variant" && node.tag === property) throw new TypeError("Invalid structural deletion.");
-			session.removeMember(writableContainer(target, session), property);
-			return true;
-		},
-		has: (target, property) => {
-			const { node, value } = resolve(context, target);
-			if (typeof property !== "string") return false;
-			if (node?.kind === "map") return false;
-			collect(context, addressOf(target));
-			return value !== void 0 && Object.hasOwn(value, property);
-		},
-		ownKeys: (target) => {
-			const { node, value } = resolve(context, target);
-			if (node?.kind === "map") return [];
-			if (context.dependencies) collect(context, addressOf(target));
-			return value && typeof value === "object" ? Object.keys(value) : [];
-		},
-		getOwnPropertyDescriptor: (target, property) => {
-			const { node, value } = resolve(context, target);
-			if (node?.kind === "map") return void 0;
-			return value && Object.hasOwn(value, property) ? {
-				enumerable: true,
-				configurable: true
-			} : void 0;
-		},
-		defineProperty: () => {
-			assertActive(context);
-			throw new TypeError("Use schema assignments.");
-		},
-		setPrototypeOf: () => {
-			assertActive(context);
-			throw new TypeError("Document prototypes are immutable.");
-		},
-		preventExtensions: () => {
-			assertActive(context);
-			throw new TypeError("Document access cannot be frozen.");
-		}
-	};
-	const root = resolve(context, createTarget(initial, void 0, ""));
-	if (!root.node || root.node.kind === "field" || root.value === void 0) {
-		if (context.dependencies) collect(context, initial);
-		return root.value;
-	}
-	return access(root);
-};
-const collectionAccess = (context, at) => {
-	const value = createAccess(context, at);
-	if (value === void 0) return {
-		get: () => {
-			assertActive(context);
-		},
-		has: () => {
-			assertActive(context);
-			return false;
-		},
-		ids: () => {
-			assertActive(context);
-			return [];
-		}
-	};
-	return value;
-};
-//#endregion
 //#region core/src/impact-target.ts
 const address = (target) => "at" in target ? target.at : target.address;
 const id = (target) => target.kind === "collection" && "id" in target ? target.id : void 0;
@@ -904,13 +187,13 @@ const createImpact = (schema, changes) => {
 			for (const change of changes.changes) {
 				if (change.kind === "reset") continue;
 				if (change.kind === "members") {
-					if (change.at.length < at.length && contains$1(change.at, at)) {
+					if (change.at.length < at.length && contains(change.at, at)) {
 						if (change.members.some((member) => member.key === at[change.at.length])) {
 							const result = { kind: "reset" };
 							cache.set(key, result);
 							return result;
 						}
-					} else if (contains$1(at, change.at)) if (change.at.length === at.length) {
+					} else if (contains(at, change.at)) if (change.at.length === at.length) {
 						if (change.order) {
 							const positions = new Map(change.order.after.map((id, i) => [id, i]));
 							let previous = -1;
@@ -927,12 +210,12 @@ const createImpact = (schema, changes) => {
 					} else updated.add(change.at[at.length]);
 					continue;
 				}
-				if (change.kind === "tree" && contains$1(change.at, at)) {
+				if (change.kind === "tree" && contains(change.at, at)) {
 					const result = { kind: "reset" };
 					cache.set(key, result);
 					return result;
 				}
-				if (!contains$1(at, change.at)) continue;
+				if (!contains(at, change.at)) continue;
 				if (change.at.length === at.length) continue;
 				const id = change.at[at.length];
 				updated.add(id);
@@ -1183,84 +466,6 @@ const disposeNotification = (notification) => {
 	if (errors.length) throw new AggregateError(errors, "Projection disposal notification failed.");
 };
 //#endregion
-//#region core/src/projection/definition.ts
-const definitions = /* @__PURE__ */ new WeakMap();
-const freezeSources = (sources) => Object.freeze({ ...sources });
-const define = (definition) => {
-	const handle = Object.freeze({});
-	definitions.set(handle, definition);
-	return handle;
-};
-const definitionOf = (projection) => {
-	const definition = definitions.get(projection);
-	if (!definition) throw new TypeError("Unknown projection definition.");
-	return definition;
-};
-const input = (initial, options) => define({
-	kind: "input",
-	initial,
-	isEqual: options?.isEqual
-});
-function project(first, second, third, fourth) {
-	if (first && typeof first === "object" && "kind" in first && (first.kind === "value" || first.kind === "collection")) {
-		const spec = first;
-		return define({
-			kind: spec.kind === "value" ? "advanced-value" : "advanced-collection",
-			sources: freezeSources(spec.sources),
-			build: spec.build,
-			isEqual: spec.isEqual,
-			name: spec.name
-		});
-	}
-	if (first && typeof first === "object" && "revision" in first && "subscribe" in first) {
-		if ("address" in first) {
-			const document = first;
-			if (!second) return define({
-				kind: "document",
-				document
-			});
-			if (Array.isArray(second)) return define({
-				kind: "document",
-				document,
-				targets: Object.freeze([...second])
-			});
-			if (typeof second !== "function") throw new TypeError("Invalid document projection.");
-			const source = define({
-				kind: "document-collection",
-				document,
-				pick: second
-			});
-			if (!third || typeof third !== "function") return source;
-			return define({
-				kind: "map",
-				source,
-				mapper: third,
-				isEqual: fourth?.isEqual
-			});
-		}
-		return define({
-			kind: "readable",
-			readable: first
-		});
-	}
-	if (second) {
-		if (typeof second !== "function") throw new TypeError("Invalid project declaration.");
-		if (definitions.has(first)) return define({
-			kind: "map",
-			source: first,
-			mapper: second,
-			isEqual: third?.isEqual
-		});
-		return define({
-			kind: "value",
-			sources: freezeSources(first),
-			compute: second,
-			isEqual: third?.isEqual
-		});
-	}
-	throw new TypeError("Invalid project declaration.");
-}
-//#endregion
 //#region core/src/projection/contract.ts
 var ProjectionError = class extends Error {
 	constructor(phase, identity, revisions, cause) {
@@ -1283,6 +488,8 @@ const projectionHandles = /* @__PURE__ */ new WeakSet();
 const createScheduler = (onError) => {
 	let disposed = false;
 	let depth = 0;
+	let batchSequence = 0;
+	let activeBatch;
 	let phase = "idle";
 	let sequence = 0;
 	const records = /* @__PURE__ */ new Map();
@@ -1444,6 +651,36 @@ const createScheduler = (onError) => {
 		if (failures.length) throw new AggregateError(failures, "Projection error reporter failed.");
 		return result;
 	};
+	const batch = (optionsOrCallback, maybeCallback) => {
+		assertIdle();
+		const options = typeof optionsOrCallback === "function" ? void 0 : optionsOrCallback;
+		const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : maybeCallback;
+		if (!callback) throw new TypeError("Projection batch requires a callback.");
+		if (depth === 0) activeBatch = Object.freeze({
+			id: ++batchSequence,
+			...options?.cause === void 0 ? {} : { cause: options.cause }
+		});
+		depth++;
+		let failed = false;
+		try {
+			const value = callback();
+			assertSynchronous(value);
+			return value;
+		} catch (error) {
+			failed = true;
+			throw error;
+		} finally {
+			depth--;
+			if (!depth) try {
+				if (failed) try {
+					run();
+				} catch {}
+				else run();
+			} finally {
+				activeBatch = void 0;
+			}
+		}
+	};
 	return {
 		assertActive,
 		assertIdle,
@@ -1510,25 +747,8 @@ const createScheduler = (onError) => {
 			node.release();
 			for (const [handle, record] of records) if (record === node) records.delete(handle);
 		},
-		batch(callback) {
-			assertIdle();
-			depth++;
-			let failed = false;
-			try {
-				const value = callback();
-				assertSynchronous(value);
-				return value;
-			} catch (error) {
-				failed = true;
-				throw error;
-			} finally {
-				depth--;
-				if (!depth) if (failed) try {
-					run();
-				} catch {}
-				else run();
-			}
-		},
+		batch,
+		batchContext: () => activeBatch,
 		dispose() {
 			if (disposed) return;
 			assertIdle();
@@ -1660,6 +880,9 @@ const createCollection = (scheduler, spec) => {
 	let reset = false;
 	let revision = 0;
 	let idsRevision = 0;
+	let batch;
+	let cause;
+	let publishedTransitions = Object.freeze([]);
 	let all;
 	const items = /* @__PURE__ */ new Map();
 	const subscribedItems = /* @__PURE__ */ new Set();
@@ -1689,6 +912,9 @@ const createCollection = (scheduler, spec) => {
 	};
 	const owner = createNode(scheduler, spec, {
 		evaluate: (sources, build, active) => {
+			const metadata = Object.values(sources).find((value) => value && typeof value === "object" && ("batch" in value && value.batch !== void 0 || "cause" in value && value.cause !== void 0));
+			batch = scheduler.batchContext() ?? metadata?.batch;
+			cause = metadata?.cause ?? batch?.cause;
 			staged = /* @__PURE__ */ new Map();
 			nextIds = ids;
 			change = void 0;
@@ -1819,10 +1045,29 @@ const createCollection = (scheduler, spec) => {
 				].forEach((key) => changedKeys.add(key));
 				profile.projection("changedKeys", changedKeys.size);
 			}
+			publishedTransitions = Object.freeze([...changedKeys].flatMap((key) => {
+				const beforePresent = values.has(key);
+				const afterPresent = hasNext(key);
+				if (beforePresent === afterPresent) {
+					if (!beforePresent) return [];
+					if ((spec.isEqual ?? Object.is)(values.get(key), getNext(key))) return [];
+				}
+				return [{
+					key,
+					kind: !beforePresent ? "added" : !afterPresent ? "removed" : "updated",
+					before: beforePresent ? values.get(key) : void 0,
+					after: afterPresent ? getNext(key) : void 0
+				}];
+			}));
 			reset = build;
 			return change !== void 0;
 		},
 		context: (active) => {
+			const transitions = (keys) => {
+				assertScope(active);
+				const selected = keys ? new Set(keys) : void 0;
+				return Object.freeze(publishedTransitions.filter((transition) => !selected || selected.has(transition.key)));
+			};
 			const input = {
 				get: (key) => {
 					assertScope(active);
@@ -1836,9 +1081,26 @@ const createCollection = (scheduler, spec) => {
 					assertScope(active);
 					return nextIds;
 				},
+				previous: Object.freeze({
+					get: (key) => {
+						assertScope(active);
+						return values.get(key);
+					},
+					has: (key) => {
+						assertScope(active);
+						return values.has(key);
+					},
+					ids: () => {
+						assertScope(active);
+						return ids;
+					}
+				}),
 				change,
 				revision: revision + (change ? 1 : 0),
-				reset
+				reset,
+				transitions,
+				batch,
+				cause
 			};
 			return Object.freeze(input);
 		},
@@ -1875,6 +1137,9 @@ const createCollection = (scheduler, spec) => {
 			change = void 0;
 			reset = false;
 			changedKeys.clear();
+			publishedTransitions = Object.freeze([]);
+			batch = void 0;
+			cause = void 0;
 			orderChanged = false;
 		},
 		release: () => {
@@ -1991,6 +1256,7 @@ const createSources = (scheduler) => {
 	const documents = /* @__PURE__ */ new Map();
 	const readables = /* @__PURE__ */ new Map();
 	const collections = /* @__PURE__ */ new WeakSet();
+	const externalSources = /* @__PURE__ */ new WeakMap();
 	const document = (runtime) => {
 		scheduler.assertIdle();
 		const state = accessOf(runtime);
@@ -1998,6 +1264,7 @@ const createSources = (scheduler) => {
 		const existing = documents.get(state);
 		if (existing) return existing;
 		const bindings = [];
+		let batch;
 		const make = (input) => {
 			const collection = "collection" in input ? input.collection : void 0;
 			const targets = "targets" in input ? input.targets : [input.collection];
@@ -2021,6 +1288,7 @@ const createSources = (scheduler) => {
 				clear: () => {
 					commits = [];
 					reset = orderDirty = false;
+					batch = void 0;
 					keys.clear();
 					candidates = void 0;
 				},
@@ -2037,6 +1305,8 @@ const createSources = (scheduler) => {
 						revision: runtime.revision(),
 						commits: Object.freeze(commits.slice()),
 						reset: record.reset(),
+						batch,
+						cause: batch?.cause,
 						...collection ? { candidates: candidates ??= Object.freeze({
 							keys: Object.freeze([...keys]),
 							orderDirty
@@ -2090,6 +1360,7 @@ const createSources = (scheduler) => {
 			capture: (commit) => {
 				for (const binding of bindings) if (!binding.targets.length || binding.targets.some((value) => affectsTarget(commit.impact, value))) {
 					binding.receive(commit);
+					batch = scheduler.batchContext();
 					scheduler.capture(binding.record);
 				}
 			},
@@ -2114,15 +1385,25 @@ const createSources = (scheduler) => {
 		let value = initial;
 		let previous = initial;
 		let revision = 0;
+		let detail;
+		let cause;
+		let batch;
+		let reset = false;
+		let pending = false;
 		const handle = Object.freeze({});
 		const record = {
 			consumers: /* @__PURE__ */ new Set(),
 			disposed: false,
 			fault: void 0,
 			revision: () => revision,
-			reset: () => false,
+			reset: () => reset,
 			clear: () => {
 				previous = value;
+				pending = false;
+				detail = void 0;
+				cause = void 0;
+				batch = void 0;
+				reset = false;
 			},
 			context: (active) => {
 				assertScope(active);
@@ -2131,19 +1412,29 @@ const createSources = (scheduler) => {
 					previous,
 					revision,
 					changed: !equal(previous, value),
-					reset: false
+					reset,
+					detail,
+					cause,
+					batch
 				});
 			}
 		};
 		scheduler.register(handle, record);
-		const accept = (next) => {
+		const accept = (next, metadata) => {
 			scheduler.assertIdle();
 			const recovering = record.fault !== void 0;
-			if (equal(value, next) && !recovering) return;
+			const eventful = metadata !== void 0 && (metadata.reset === true || metadata.revision !== void 0 && metadata.revision !== revision || metadata.detail !== void 0 || metadata.cause !== void 0 || metadata.batch !== void 0);
+			if (equal(value, next) && !recovering && !eventful) return;
 			record.fault = void 0;
+			if (!pending) previous = value;
 			value = next;
-			revision++;
+			revision = metadata?.revision ?? revision + 1;
+			detail = metadata?.detail;
+			cause = metadata?.cause ?? cause;
+			batch = scheduler.batchContext() ?? metadata?.batch ?? batch;
+			reset ||= metadata?.reset ?? false;
 			scheduler.capture(record);
+			pending = true;
 		};
 		return {
 			source: handle,
@@ -2154,12 +1445,217 @@ const createSources = (scheduler) => {
 			}
 		};
 	};
+	const externalValueSource = (port, equal) => {
+		scheduler.assertIdle();
+		const old = externalSources.get(port);
+		if (old) return old;
+		const input = valueSource(port.current(), equal);
+		const fail = (cause) => {
+			const record = scheduler.source(input.source);
+			record.fault = new ProjectionError("source", "external source", [record.revision()], cause);
+			scheduler.capture(record);
+		};
+		let unsubscribe;
+		try {
+			unsubscribe = port.subscribe((event) => {
+				try {
+					input.accept(event.value, {
+						revision: event.revision,
+						reset: event.reset,
+						detail: event.detail,
+						cause: event.cause,
+						batch: event.batch
+					});
+				} catch (cause) {
+					fail(cause);
+				}
+				scheduler.run();
+			});
+		} catch (cause) {
+			unsubscribe?.();
+			scheduler.unregisterSource(input.source);
+			throw cause;
+		}
+		scheduler.cleanups.add(() => unsubscribe?.());
+		externalSources.set(port, input.source);
+		return input.source;
+	};
+	const externalCollectionSource = (port) => {
+		scheduler.assertIdle();
+		const old = externalSources.get(port);
+		if (old) return old;
+		let read = port.current();
+		let previous = read;
+		let revision = port.revision();
+		let change;
+		let reset = false;
+		let detail;
+		let cause;
+		let batch;
+		let publishedTransitions = Object.freeze([]);
+		let transitionKeys = /* @__PURE__ */ new Set();
+		let pending = false;
+		const handle = Object.freeze({});
+		const record = {
+			consumers: /* @__PURE__ */ new Set(),
+			disposed: false,
+			fault: void 0,
+			revision: () => revision,
+			reset: () => reset,
+			clear: () => {
+				previous = read;
+				pending = false;
+				change = void 0;
+				reset = false;
+				detail = void 0;
+				cause = void 0;
+				batch = void 0;
+				publishedTransitions = Object.freeze([]);
+				transitionKeys.clear();
+			},
+			context: (active) => {
+				assertScope(active);
+				const currentRead = Object.freeze({
+					get: (key) => {
+						assertScope(active);
+						return read.get(key);
+					},
+					has: (key) => {
+						assertScope(active);
+						return read.has(key);
+					},
+					ids: () => {
+						assertScope(active);
+						return read.ids();
+					}
+				});
+				const previousRead = Object.freeze({
+					get: (key) => {
+						assertScope(active);
+						return previous.get(key);
+					},
+					has: (key) => {
+						assertScope(active);
+						return previous.has(key);
+					},
+					ids: () => {
+						assertScope(active);
+						return previous.ids();
+					}
+				});
+				return Object.freeze({
+					...currentRead,
+					previous: previousRead,
+					change,
+					revision,
+					reset,
+					transitions: (keys) => {
+						assertScope(active);
+						const selected = keys ? new Set(keys) : void 0;
+						return Object.freeze(publishedTransitions.filter((transition) => !selected || selected.has(transition.key)));
+					},
+					detail,
+					cause,
+					batch
+				});
+			}
+		};
+		scheduler.register(handle, record);
+		collections.add(handle);
+		const fail = (error) => {
+			record.fault = new ProjectionError("source", "external collection source", [revision], error);
+			scheduler.capture(record);
+		};
+		const addTransitionKeys = (event) => {
+			event.transitions().forEach((transition) => transitionKeys.add(transition.key));
+			const impact = event.change;
+			if (impact?.kind === "incremental") {
+				impact.added.forEach((key) => transitionKeys.add(key));
+				impact.removed.forEach((key) => transitionKeys.add(key));
+				impact.updated.forEach((key) => transitionKeys.add(key));
+			}
+		};
+		const recomputeTransitions = () => {
+			const transitions = [];
+			for (const key of transitionKeys) {
+				const beforePresent = previous.has(key);
+				const afterPresent = read.has(key);
+				const before = beforePresent ? previous.get(key) : void 0;
+				const after = afterPresent ? read.get(key) : void 0;
+				if (beforePresent === afterPresent && Object.is(before, after)) continue;
+				transitions.push({
+					key,
+					kind: !beforePresent ? "added" : !afterPresent ? "removed" : "updated",
+					before,
+					after
+				});
+			}
+			publishedTransitions = Object.freeze(transitions);
+		};
+		const deriveChange = () => {
+			if (reset) return Object.freeze({ kind: "reset" });
+			const added = /* @__PURE__ */ new Set();
+			const removed = /* @__PURE__ */ new Set();
+			const updated = /* @__PURE__ */ new Set();
+			publishedTransitions.forEach((transition) => {
+				if (transition.kind === "added") added.add(transition.key);
+				else if (transition.kind === "removed") removed.add(transition.key);
+				else updated.add(transition.key);
+			});
+			const beforeIds = previous.ids();
+			const afterIds = read.ids();
+			const beforeCommon = beforeIds.filter((key) => read.has(key));
+			const afterCommon = afterIds.filter((key) => previous.has(key));
+			const orderChanged = beforeCommon.length !== afterCommon.length || beforeCommon.some((key, index) => afterCommon[index] !== key);
+			if (!added.size && !removed.size && !updated.size && !orderChanged) return void 0;
+			return Object.freeze({
+				kind: "incremental",
+				added,
+				removed,
+				updated,
+				orderChanged
+			});
+		};
+		let unsubscribe;
+		try {
+			unsubscribe = port.subscribe((event) => {
+				try {
+					scheduler.assertIdle();
+					if (!pending) previous = event.previous;
+					read = port.current();
+					revision = event.revision;
+					addTransitionKeys(event);
+					reset ||= event.reset || event.change?.kind === "reset";
+					detail = event.detail;
+					cause = event.cause ?? cause;
+					batch = scheduler.batchContext() ?? event.batch;
+					recomputeTransitions();
+					change = deriveChange();
+					record.fault = void 0;
+					scheduler.capture(record);
+					pending = true;
+				} catch (error) {
+					fail(error);
+				}
+				scheduler.run();
+			});
+		} catch (error) {
+			unsubscribe?.();
+			scheduler.unregisterSource(handle);
+			throw error;
+		}
+		scheduler.cleanups.add(() => unsubscribe?.());
+		externalSources.set(port, handle);
+		return handle;
+	};
 	return {
 		dispose: () => {
 			documents.clear();
 			readables.clear();
 		},
 		document,
+		fromSource: (source, options) => externalValueSource(source, options?.isEqual ?? Object.is),
+		fromCollectionSource: (source) => externalCollectionSource(source),
 		input: (initial, options) => {
 			const { source, set } = valueSource(initial, options?.isEqual ?? Object.is);
 			return Object.freeze({
@@ -2264,9 +1760,14 @@ const createValue = (scheduler, spec, options) => {
 	let revision = 0;
 	let changed = false;
 	let reset = false;
+	let batch;
+	let cause;
 	const listeners = /* @__PURE__ */ new Set();
 	const owner = createNode(scheduler, spec, {
 		evaluate: (sources, build) => {
+			const metadata = Object.values(sources).find((value) => value && typeof value === "object" && ("batch" in value && value.batch !== void 0 || "cause" in value && value.cause !== void 0));
+			batch = scheduler.batchContext() ?? metadata?.batch;
+			cause = metadata?.cause ?? batch?.cause;
 			let candidate;
 			if (build || !instance) {
 				profile.materialized.rebuilt();
@@ -2301,7 +1802,9 @@ const createValue = (scheduler, spec, options) => {
 				previous,
 				changed,
 				revision: revision + (changed ? 1 : 0),
-				reset
+				reset,
+				cause,
+				batch
 			});
 		},
 		revision: () => revision,
@@ -2320,6 +1823,8 @@ const createValue = (scheduler, spec, options) => {
 			previous = value;
 			changed = false;
 			reset = false;
+			batch = void 0;
+			cause = void 0;
 		},
 		release: () => {
 			listeners.clear();
@@ -2351,13 +1856,7 @@ const createValue = (scheduler, spec, options) => {
 };
 //#endregion
 //#region core/src/projection/runtime.ts
-const debug = /* @__PURE__ */ new WeakMap();
-const projectionEngineDebug = (runtime) => {
-	const read = debug.get(runtime);
-	if (!read) throw new Error("Unknown projection engine.");
-	return Object.freeze(read());
-};
-const createProjectionEngine = (options) => {
+const createRuntimeExecutor = (options) => {
 	const scheduler = createScheduler(options.onError);
 	const sources = createSources(scheduler);
 	function value(input, computeOrOptions, options) {
@@ -2434,6 +1933,8 @@ const createProjectionEngine = (options) => {
 	};
 	const runtime = {
 		document: sources.document,
+		fromSource: (source, options) => sources.fromSource(source, options),
+		fromCollectionSource: (source) => sources.fromCollectionSource(source),
 		input: sources.input,
 		fromReadable: sources.fromReadable,
 		value,
@@ -2448,107 +1949,274 @@ const createProjectionEngine = (options) => {
 			}
 		}
 	};
-	debug.set(runtime, scheduler.debug);
 	return Object.freeze(runtime);
 };
 //#endregion
 //#region core/src/projection/store.ts
-const stores = /* @__PURE__ */ new WeakMap();
-const projectionStoreDebug = (store) => {
-	const runtime = stores.get(store);
-	if (!runtime) throw new Error("Unknown projection store.");
-	return projectionEngineDebug(runtime);
+const runtimeStates = /* @__PURE__ */ new WeakMap();
+let activeTracker;
+const trackKey = (key) => {
+	activeTracker?.keys.add(key);
+};
+const trackAll = (structure = false) => {
+	if (!activeTracker) return;
+	activeTracker.all = true;
+	activeTracker.structure ||= structure;
 };
-const createProjectionStore = (options) => {
-	const runtime = createProjectionEngine(options);
+const mapView = (read) => {
+	const keys = read.ids();
+	const source = /* @__PURE__ */ new Map();
+	for (const key of keys) source.set(key, read.get(key));
+	const view = {
+		get: (key) => {
+			trackKey(key);
+			return source.get(key);
+		},
+		has: (key) => {
+			trackKey(key);
+			return source.has(key);
+		},
+		get size() {
+			trackAll(true);
+			return source.size;
+		},
+		keys: () => {
+			trackAll(true);
+			return source.keys();
+		},
+		values: () => {
+			trackAll(true);
+			return source.values();
+		},
+		entries: () => {
+			trackAll(true);
+			return source.entries();
+		},
+		forEach: (callback, thisArg) => {
+			trackAll(true);
+			source.forEach((value, key) => callback.call(thisArg, value, key, view));
+		},
+		[Symbol.iterator]: () => {
+			trackAll(true);
+			return source[Symbol.iterator]();
+		}
+	};
+	return Object.freeze(view);
+};
+const isMapLike = (value) => value instanceof Map || value !== null && typeof value === "object" && typeof value.get === "function" && typeof value.keys === "function" && typeof value.entries === "function";
+const mapRead = (value) => ({
+	get: (key) => value.get(key),
+	has: (key) => value.has(key),
+	ids: () => Object.freeze([...value.keys()])
+});
+const mapChange = (previous, current) => {
+	const added = /* @__PURE__ */ new Set();
+	const removed = /* @__PURE__ */ new Set();
+	const updated = /* @__PURE__ */ new Set();
+	for (const key of previous.keys()) if (!current.has(key)) removed.add(key);
+	else if (!Object.is(previous.get(key), current.get(key))) updated.add(key);
+	for (const key of current.keys()) if (!previous.has(key)) added.add(key);
+	const before = [...previous.keys()].filter((key) => current.has(key));
+	const after = [...current.keys()].filter((key) => previous.has(key));
+	const orderChanged = before.length !== after.length || before.some((key, index) => key !== after[index]);
+	if (!added.size && !removed.size && !updated.size && !orderChanged) return void 0;
+	return {
+		kind: "incremental",
+		added,
+		removed,
+		updated,
+		orderChanged
+	};
+};
+const currentValue = (event) => {
+	if (!event || typeof event !== "object") return event;
+	if ("value" in event) return event.value;
+	if ("read" in event) return snapshot(event.read);
+	if ("ids" in event && typeof event.ids === "function") return mapView(event);
+	return event;
+};
+const sourceOf = (instance) => instance;
+const createProjectionRuntime = (options) => {
+	const runtime = createRuntimeExecutor({ onError: options?.onError ?? (() => void 0) });
 	const instances = /* @__PURE__ */ new WeakMap();
 	const inputs = /* @__PURE__ */ new WeakMap();
+	const collections = /* @__PURE__ */ new WeakMap();
 	const materialize = (projection) => {
 		const old = instances.get(projection);
 		if (old) return old;
 		const definition = definitionOf(projection);
 		let instance;
-		if (definition.kind === "input") {
-			const input = runtime.input(definition.initial, { isEqual: definition.isEqual });
-			inputs.set(projection, input);
-			instance = runtime.value({ input: input.source }, ({ input }) => input.value);
-		} else if (definition.kind === "readable") {
-			const source = runtime.fromReadable(definition.readable, { isEqual: definition.isEqual });
-			instance = runtime.value({ source }, ({ source }) => source.value);
-		} else if (definition.kind === "document") {
-			const document = runtime.document(definition.document);
-			instance = definition.targets?.length ? document.targets(...definition.targets) : document;
-		} else if (definition.kind === "document-collection") instance = runtime.document(definition.document).collection(definition.pick);
-		else if (definition.kind === "map") instance = runtime.map(materialize(definition.source), definition.mapper, { isEqual: definition.isEqual });
-		else {
-			const sources = Object.fromEntries(Object.entries(definition.sources).map(([key, source]) => [key, materialize(source)]));
-			if (definition.kind === "value") instance = runtime.value(sources, (events) => {
-				const values = Object.fromEntries(Object.entries(events).map(([key, event]) => [key, current(event)]));
-				return definition.compute(values);
-			}, { isEqual: definition.isEqual });
-			else if (definition.kind === "advanced-value") instance = runtime.value({
-				sources,
-				build: definition.build,
-				name: definition.name
-			}, { isEqual: definition.isEqual });
-			else instance = runtime.collection()({
-				sources,
-				build: definition.build,
-				isEqual: definition.isEqual,
-				name: definition.name
-			});
+		switch (definition.kind) {
+			case "input": {
+				const input = runtime.input(definition.initial, { isEqual: definition.isEqual });
+				inputs.set(projection, input);
+				instance = runtime.value({ input: input.source }, ({ input }) => input.value);
+				break;
+			}
+			case "readable": {
+				const source = runtime.fromReadable(definition.readable, { isEqual: definition.isEqual });
+				instance = runtime.value({ source }, ({ source }) => source.value);
+				break;
+			}
+			case "source-value":
+				{
+					const source = runtime.fromSource(definition.source);
+					instance = runtime.value({ source }, ({ source }) => source.value);
+				}
+				break;
+			case "source-collection": {
+				const source = runtime.fromCollectionSource(definition.source);
+				instance = runtime.map(source, (_key, value) => value);
+				break;
+			}
+			case "document": {
+				const document = runtime.document(definition.document);
+				if (!definition.selector) {
+					instance = runtime.value({ document }, ({ document }) => snapshot(document.read));
+					break;
+				}
+				const state = accessOf(definition.document);
+				try {
+					const collection = document.collection(definition.selector);
+					instance = runtime.map(collection, (_id, entry) => snapshot(entry));
+					break;
+				} catch {
+					const selected = document.targets(definition.selector);
+					const address = compilePath(state.schema, "value", definition.selector).address;
+					instance = runtime.value({ selected }, () => {
+						return read(snapshot(state.document), address, state.schema);
+					});
+				}
+				break;
+			}
+			case "derive": {
+				const sources = Object.fromEntries(definition.dependencies.map((dependency, index) => [`d${index}`, sourceOf(materialize(dependency))]));
+				instance = runtime.value(sources, (values) => definition.compute(...Object.values(values).map(currentValue)), { isEqual: definition.isEqual });
+				break;
+			}
+			case "incremental-value": {
+				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
+				instance = runtime.value({
+					sources,
+					build: definition.build
+				}, { isEqual: definition.isEqual });
+				break;
+			}
+			case "incremental-collection": {
+				const sources = Object.fromEntries(Object.entries(definition.dependencies).map(([key, dependency]) => [key, sourceOf(materialize(dependency))]));
+				instance = runtime.collection()({
+					sources,
+					build: definition.build,
+					isEqual: definition.isEqual,
+					name: definition.name
+				});
+				break;
+			}
 		}
 		instances.set(projection, instance);
 		return instance;
 	};
-	const current = (event) => {
-		if (event && typeof event === "object") {
-			if ("value" in event) return event.value;
-			if ("read" in event) return event.read;
+	const get = (projection) => {
+		const instance = materialize(projection);
+		const current = instance.current();
+		if (current && typeof current === "object" && "ids" in current && typeof current.ids === "function") {
+			const existing = collections.get(instance);
+			const revision = instance.revision();
+			if (existing?.revision === revision) return existing.value;
+			const value = mapView(current);
+			collections.set(instance, {
+				revision,
+				value
+			});
+			return value;
 		}
-		return event;
+		if (isMapLike(current)) {
+			const existing = collections.get(instance);
+			const revision = instance.revision();
+			if (existing?.revision === revision) return existing.value;
+			const value = mapView(mapRead(current));
+			collections.set(instance, {
+				revision,
+				value
+			});
+			return value;
+		}
+		return current;
 	};
 	const store = {
-		get: ((projection) => {
-			const instance = materialize(projection);
-			if ("current" in instance && typeof instance.current === "function") return instance.current();
-			throw new TypeError("Projection is a source and has no published value.");
+		get,
+		subscribe: ((projection, listener) => {
+			return materialize(projection).subscribe(listener);
 		}),
-		set: (projection, value) => {
-			materialize(projection);
-			const target = inputs.get(projection);
+		set: ((input, value) => {
+			materialize(input);
+			const target = inputs.get(input);
 			if (!target) throw new TypeError("Projection is not an input.");
 			target.set(value);
-		},
-		subscribe: ((projection, listener) => {
-			const instance = materialize(projection);
-			if (!("subscribe" in instance)) throw new TypeError("Projection is a source and cannot be subscribed.");
-			return instance.subscribe(listener);
 		}),
-		revision: (projection) => {
-			const instance = materialize(projection);
-			if (!("revision" in instance) || typeof instance.revision !== "function") throw new TypeError("Projection has no published revision.");
-			return instance.revision();
-		},
-		rebuild: (projection) => {
-			const instance = materialize(projection);
-			if (!("rebuild" in instance) || typeof instance.rebuild !== "function") throw new TypeError("Projection cannot be rebuilt.");
-			instance.rebuild();
-		},
-		release: (projection) => {
-			const instance = instances.get(projection);
-			if (!instance) return;
-			if ("dispose" in instance && typeof instance.dispose === "function") instance.dispose();
-			instances.delete(projection);
-			inputs.delete(projection);
-		},
 		batch: runtime.batch,
 		dispose: runtime.dispose
 	};
-	stores.set(store, runtime);
+	runtimeStates.set(store, {
+		materialize,
+		get
+	});
 	return Object.freeze(store);
 };
+const trackProjection = (owner, projection, selector) => {
+	const state = runtimeStates.get(owner);
+	if (!state) throw new TypeError("Unknown projection runtime.");
+	const tracker = {
+		keys: /* @__PURE__ */ new Set(),
+		all: false,
+		structure: false
+	};
+	const previous = activeTracker;
+	activeTracker = tracker;
+	try {
+		return {
+			value: selector(state.get(projection)),
+			selection: Object.freeze({
+				keys: new Set(tracker.keys),
+				all: tracker.all,
+				structure: tracker.structure
+			})
+		};
+	} finally {
+		activeTracker = previous;
+	}
+};
+const subscribeProjection = (owner, projection, selection, listener) => {
+	const state = runtimeStates.get(owner);
+	if (!state) throw new TypeError("Unknown projection runtime.");
+	const instance = state.materialize(projection);
+	let previousCollection;
+	const initialValue = state.get(projection);
+	if (isMapLike(initialValue)) previousCollection = initialValue;
+	return instance.subscribe(((change) => {
+		if (!change && previousCollection) {
+			const current = state.get(projection);
+			if (isMapLike(current)) {
+				change = mapChange(previousCollection, current);
+				previousCollection = current;
+				if (!change) return;
+			} else previousCollection = void 0;
+		}
+		if (!change || change.kind === "reset") {
+			listener();
+			return;
+		}
+		if (selection.all && (selection.structure || change.added.size || change.removed.size || change.updated.size)) {
+			listener();
+			return;
+		}
+		for (const key of selection.keys) if (change.added.has(key) || change.removed.has(key) || change.updated.has(key)) {
+			listener();
+			return;
+		}
+	}));
+};
 //#endregion
-export { object as A, parse as B, createAccess as C, field as D, compilePath as E, ParseError as F, checkKey as I, checkValue as L, table as M, tree as N, list as O, variant as P, copyValue as R, same as S, snapshot as T, readWith as _, input as a, TransactionRejected as b, createNotification as c, shareNotification as d, subscribeDependencies as f, bindRuntimeAccess as g, accessOf as h, ProjectionError as i, optional as j, map as k, disposeNotification as l, subscribeTargets as m, projectionStoreDebug as n, project as o, subscribeRoot as p, ProjectionDisposedError as r, bindDocumentReadable as s, createProjectionStore as t, notify as u, DocumentDisposedError as v, replace as w, createImpact as x, DocumentReentrancyError as y, equalValue as z };
+export { variant as A, field as C, optional as D, object as E, table as O, compilePath as S, map as T, DocumentDisposedError as _, ProjectionError as a, createImpact as b, disposeNotification as c, subscribeDependencies as d, subscribeRoot as f, readWith as g, bindRuntimeAccess as h, ProjectionDisposedError as i, tree as k, notify as l, accessOf as m, subscribeProjection as n, bindDocumentReadable as o, subscribeTargets as p, trackProjection as r, createNotification as s, createProjectionRuntime as t, shareNotification as u, DocumentReentrancyError as v, list as w, same as x, TransactionRejected as y };
 
-//# sourceMappingURL=store-DHFXfWSz.js.map
+//# sourceMappingURL=store-CtgvCVFg.js.map