doxum 0.1.22 → 0.1.23

package/dist/{advanced-BTStm2cW.js → advanced-CRNHfJBu.js}

@@ -1,5 +1,404 @@
-import { B as profile } from "./issue-9U6YLYz3.js";
-import { _ as checkKey, t as accessOf } from "./access-CZXv_DIF.js";
+import { c as validate, d as isRecord, n as contextOf, u as isPlainObject } from "./context-DFEaDUv5.js";
+const profile = {
+	projection: (key, amount = 1) => {},
+	recorder: (key, amount = 1) => {},
+	access: (key) => {},
+	copy: {
+		structure: () => {},
+		treeNode: () => {},
+		shallowRecord: (items) => {}
+	},
+	equality: {
+		call: () => {},
+		container: () => {}
+	},
+	address: {
+		listIndex: (items) => {},
+		schemaStep: () => {},
+		documentStep: () => {},
+		prefixComparison: () => {},
+		segmentCompared: () => {}
+	},
+	impact: {
+		index: () => {},
+		affects: () => {}
+	},
+	collectionIndex: {
+		node: () => {},
+		build: (items) => {}
+	},
+	collectionView: {
+		mapped: () => {},
+		idsScanned: (amount = 1) => {},
+		arrayCopied: () => {}
+	},
+	materialized: {
+		updated: () => {},
+		rebuilt: () => {},
+		notification: () => {}
+	}
+};
+//#endregion
+//#region core/src/order/sequence.ts
+const length = (keys) => keys.length;
+const keyAt = (keys, index) => Array.isArray(keys) ? keys[index] : keys.at(index);
+const equal = (left, right) => {
+	profile.equality.call();
+	if (left === right) return true;
+	profile.equality.container();
+	if (left.length !== right.length) return false;
+	for (let index = 0; index < left.length; index++) if (left[index] !== keyAt(right, index)) return false;
+	return true;
+};
+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 listIndexes = /* @__PURE__ */ new WeakMap();
+const knownKeys = (values) => {
+	let positions;
+	return {
+		length: values.length,
+		at: (index) => values[index],
+		index: (key) => {
+			if (!positions) {
+				positions = /* @__PURE__ */ new Map();
+				for (let index = 0; index < values.length; index++) positions.set(values[index], index);
+				profile.address.listIndex(values.length);
+			}
+			return positions.get(key) ?? -1;
+		}
+	};
+};
+const cacheKnownKeys = (values, keyOf, order) => {
+	listIndexes.set(values, {
+		keyOf,
+		order: knownKeys(order)
+	});
+};
+/** Canonical lists keep their key positions until a structural write invalidates them. */
+const indexedKeys = (values, keyOf) => {
+	const cached = listIndexes.get(values);
+	if (cached?.keyOf === keyOf) return cached.order;
+	let positions;
+	const order = {
+		length: values.length,
+		at: (index) => index >= 0 && index < values.length ? keyOf(values[index]) : void 0,
+		index: (key) => {
+			if (!positions) {
+				positions = /* @__PURE__ */ new Map();
+				for (let index = 0; index < values.length; index++) positions.set(keyOf(values[index]), index);
+				profile.address.listIndex(values.length);
+			}
+			return positions.get(key) ?? -1;
+		}
+	};
+	listIndexes.set(values, {
+		keyOf,
+		order
+	});
+	return order;
+};
+const toArray = (keys) => {
+	const result = new Array(length(keys));
+	for (let index = 0; index < result.length; index++) result[index] = keyAt(keys, index);
+	return result;
+};
+/** One operation-local list scan provides both stable keys and item association. */
+const listSequence = (values, keyOf) => {
+	const current = indexedKeys(values, keyOf);
+	const order = new Array(values.length);
+	const byKey = /* @__PURE__ */ new Map();
+	for (let index = 0; index < values.length; index++) {
+		const key = current.at(index);
+		order[index] = key;
+		byKey.set(key, values[index]);
+	}
+	cacheKnownKeys(values, keyOf, order);
+	return {
+		order,
+		values: byKey
+	};
+};
+/** Structural sequence writes own invalidation, including rollback writes. */
+const insert = (values, index, value) => {
+	values.splice(index, 0, value);
+	listIndexes.delete(values);
+};
+const remove = (values, index) => {
+	values.splice(index, 1);
+	listIndexes.delete(values);
+};
+/** Installs an exact string-key sequence such as table ids in one structural write. */
+const installKeys = (values, order) => {
+	values.length = order.length;
+	for (let index = 0; index < order.length; index++) values[index] = order[index];
+};
+/** Installs a pre-resolved list sequence without running keyOf again. */
+const installList = (values, keyOf, sequence, order) => {
+	values.length = order.length;
+	for (let index = 0; index < order.length; index++) values[index] = sequence.values.get(order[index]);
+	cacheKnownKeys(values, keyOf, order);
+};
+const install = (values, keyOf, order) => {
+	installList(values, keyOf, listSequence(values, keyOf), order);
+};
+const matches = (order, members) => {
+	if (order.length !== members.length) return false;
+	const ids = new Set(order);
+	return ids.size === order.length && members.every((id) => ids.has(id));
+};
+//#endregion
+//#region core/src/schema/layout.ts
+const compiledObjects = /* @__PURE__ */ new WeakMap();
+const compiledEntries = /* @__PURE__ */ new WeakMap();
+const objectBranch = (node, value) => {
+	if (node.kind === "object") return node;
+	if (node.kind !== "variant" || typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+	const record = value;
+	const tag = typeof record[node.tag] === "string" ? record[node.tag] : void 0;
+	return node.variants[String(tag ?? Object.keys(node.variants)[0] ?? "")];
+};
+const compiledShape = (node, value) => {
+	const branch = objectBranch(node, value);
+	if (!branch) return void 0;
+	const shape = branch.shape;
+	let layout = compiledObjects.get(shape);
+	if (!layout) {
+		const members = /* @__PURE__ */ new Map();
+		for (const key of Object.keys(shape).sort()) {
+			profile.address.schemaStep();
+			members.set(key, {
+				kind: "fixed",
+				key,
+				node: shape[key],
+				field: shape[key].kind === "field",
+				slot: members.size
+			});
+		}
+		layout = {
+			kind: "fixed",
+			members
+		};
+		compiledObjects.set(shape, layout);
+	}
+	return layout;
+};
+const compiledLayout = (node, value) => {
+	if (node.kind !== "map" && node.kind !== "table" && node.kind !== "list") return compiledShape(node, value);
+	let layout = compiledEntries.get(node);
+	if (!layout) {
+		layout = {
+			kind: "dynamic",
+			entry: {
+				kind: "entry",
+				node: node.value,
+				field: node.value.kind === "field"
+			}
+		};
+		compiledEntries.set(node, layout);
+	}
+	return layout;
+};
+//#endregion
+//#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");
+	for (const id of Object.keys(value.nodes)) {
+		const failure = checkTreePayload(node.value, value.nodes[id], [...address, id], strict);
+		if (failure) return failure;
+	}
+};
+const checkTreePayload = (node, value, address, strict = false) => {
+	if (!isRecord(value)) return issue(address, "Invalid tree node.", "invalid-tree");
+	const present = Object.prototype.hasOwnProperty.call(value, "value");
+	if (!present && !node.optional) return issue(address, "Tree node value is required.");
+	return present ? checkValue(node, value.value, address, strict) : void 0;
+};
+const copyTreeNode = (value) => {
+	profile.copy.treeNode();
+	return {
+		...value,
+		children: [...value.children]
+	};
+};
+const equalTreeNode = (left, right) => {
+	if (left === right) return true;
+	if (!left || !right) return false;
+	return left.parentId === right.parentId && equal(left.children, right.children) && Object.hasOwn(left, "value") === Object.hasOwn(right, "value") && Object.is(left.value, right.value);
+};
+/** 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, copyTreeNode(n)]))
+		};
+	}
+	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) && equalTreeNode(a[id], b[id]));
+	}
+	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
 //#region core/src/schema.ts
 const collectionEntryNode = (node) => node.kind === "map" || node.kind === "table" || node.kind === "list" ? node.value : void 0;
 const node = (value) => Object.freeze(value);
@@ -103,6 +502,45 @@ const compilePath = (owner, kind, pick) => {
 	});
 };
 //#endregion
+//#region core/src/projection/collection/view.ts
+const mapRead = (value) => ({
+	get: (key) => value.get(key),
+	has: (key) => value.has(key),
+	ids: () => Object.freeze([...value.keys()])
+});
+/** Immutable map-like view over a CollectionRead. */
+const collectionView = (read) => {
+	const ids = read.ids();
+	const entries = function* () {
+		for (const key of ids) yield [key, read.get(key)];
+	};
+	const values = function* () {
+		for (const key of ids) yield read.get(key);
+	};
+	const view = {
+		get: (key) => read.get(key),
+		has: (key) => read.has(key),
+		get size() {
+			return ids.length;
+		},
+		keys: () => ids[Symbol.iterator](),
+		values,
+		entries,
+		forEach: (callback, thisArg) => {
+			for (const key of ids) callback.call(thisArg, read.get(key), key, view);
+		},
+		[Symbol.iterator]: entries
+	};
+	return Object.freeze(view);
+};
+/** Eager durable view used when a processor result may retain its dependency value. */
+const snapshotCollectionView = (read) => {
+	const ids = read.ids();
+	const values = /* @__PURE__ */ new Map();
+	for (const key of ids) values.set(key, read.get(key));
+	return collectionView(mapRead(values));
+};
+//#endregion
 //#region core/src/projection/contract.ts
 var ProjectionError = class extends Error {
 	constructor(phase, identity, revisions, cause) {
@@ -120,7 +558,7 @@ var ProjectionDisposedError = class extends Error {
 	}
 };
 //#endregion
-//#region core/src/projection/scheduler.ts
+//#region core/src/projection/graph/scheduler.ts
 const createScheduler = (onError) => {
 	let disposed = false;
 	let depth = 0;
@@ -456,408 +894,6 @@ const assertScope = (active) => {
 	if (!active()) throw new Error("Projection reader or writer is no longer active.");
 };
 //#endregion
-//#region core/src/projection/collection-output.ts
-const height = (node) => node?.height ?? 0;
-const makeTreeNode = (key, value, left, right) => Object.freeze({
-	key,
-	value,
-	left,
-	right,
-	height: Math.max(height(left), height(right)) + 1
-});
-const rotateLeft = (node) => {
-	const right = node.right;
-	return makeTreeNode(right.key, right.value, makeTreeNode(node.key, node.value, node.left, right.left), right.right);
-};
-const rotateRight = (node) => {
-	const left = node.left;
-	return makeTreeNode(left.key, left.value, left.left, makeTreeNode(node.key, node.value, left.right, node.right));
-};
-const rebalance = (node) => {
-	const balance = height(node.left) - height(node.right);
-	if (balance > 1) {
-		if (height(node.left.left) < height(node.left.right)) return rotateRight(makeTreeNode(node.key, node.value, rotateLeft(node.left), node.right));
-		return rotateRight(node);
-	}
-	if (balance < -1) {
-		if (height(node.right.right) < height(node.right.left)) return rotateLeft(makeTreeNode(node.key, node.value, node.left, rotateRight(node.right)));
-		return rotateLeft(node);
-	}
-	return node;
-};
-const treeSet = (node, key, value) => {
-	if (!node) return makeTreeNode(key, value);
-	if (key === node.key) return makeTreeNode(key, value, node.left, node.right);
-	if (key < node.key) return rebalance(makeTreeNode(node.key, node.value, treeSet(node.left, key, value), node.right));
-	return rebalance(makeTreeNode(node.key, node.value, node.left, treeSet(node.right, key, value)));
-};
-const treeMin = (node) => node.left ? treeMin(node.left) : node;
-const treeRemove = (node, key) => {
-	if (!node) return void 0;
-	if (key < node.key) return rebalance(makeTreeNode(node.key, node.value, treeRemove(node.left, key), node.right));
-	if (key > node.key) return rebalance(makeTreeNode(node.key, node.value, node.left, treeRemove(node.right, key)));
-	if (!node.left) return node.right;
-	if (!node.right) return node.left;
-	const next = treeMin(node.right);
-	return rebalance(makeTreeNode(next.key, next.value, node.left, treeRemove(node.right, next.key)));
-};
-const treeGet = (node, key) => {
-	let current = node;
-	while (current) {
-		if (key === current.key) return current.value;
-		current = key < current.key ? current.left : current.right;
-	}
-};
-const treeHas = (node, key) => {
-	let current = node;
-	while (current) {
-		if (key === current.key) return true;
-		current = key < current.key ? current.left : current.right;
-	}
-	return false;
-};
-const treeFromSorted = (entries, start = 0, end = entries.length) => {
-	if (start >= end) return void 0;
-	const middle = start + end >> 1;
-	const [key, value] = entries[middle];
-	return makeTreeNode(key, value, treeFromSorted(entries, start, middle), treeFromSorted(entries, middle + 1, end));
-};
-/** Owns staged keyed intent, exact transitions and the persistent published lookup. */
-const createCollectionOutput = () => {
-	const values = /* @__PURE__ */ new Map();
-	let ids = Object.freeze([]);
-	let staged = /* @__PURE__ */ new Map();
-	let nextIds = ids;
-	let change;
-	let initialized = false;
-	let reset = false;
-	let revision = 0;
-	let publishedRoot;
-	let explicitOrder;
-	let cleared = false;
-	const listeners = /* @__PURE__ */ new Set();
-	const hasNext = (key) => staged.has(key) ? staged.get(key).present : !cleared && values.has(key);
-	const getNext = (key) => {
-		const entry = staged.get(key);
-		return entry ? entry.present ? entry.value : void 0 : cleared ? void 0 : values.get(key);
-	};
-	const deriveIds = () => {
-		const result = cleared ? [] : ids.filter(hasNext);
-		for (const [key, entry] of staged) if (entry.present && (cleared || !values.has(key))) result.push(key);
-		return result;
-	};
-	const begin = (active, initialize) => {
-		staged = /* @__PURE__ */ new Map();
-		nextIds = ids;
-		change = void 0;
-		explicitOrder = void 0;
-		cleared = initialize;
-		reset = initialize;
-		const read = (next) => ({
-			get: (key) => {
-				assertScope(active);
-				return next ? getNext(key) : values.get(key);
-			},
-			has: (key) => {
-				assertScope(active);
-				return next ? hasNext(key) : values.has(key);
-			},
-			ids: () => {
-				assertScope(active);
-				return next ? Object.freeze(explicitOrder ? [...explicitOrder] : [...deriveIds()]) : ids;
-			}
-		});
-		return {
-			previous: read(false),
-			next: read(true),
-			output: {
-				set: (key, value) => {
-					assertScope(active);
-					if (typeof key !== "string") throw new TypeError("Projection keys must be strings.");
-					staged.set(key, {
-						present: true,
-						value
-					});
-				},
-				remove: (key) => {
-					assertScope(active);
-					staged.set(key, { present: false });
-				},
-				order: (order) => {
-					assertScope(active);
-					explicitOrder = Object.freeze([...order]);
-				}
-			}
-		};
-	};
-	const seal = (nextReset, isEqual) => {
-		if (cleared) {
-			for (const key of values.keys()) if (!staged.has(key)) staged.set(key, { present: false });
-		}
-		profile.projection("touchedKeys", staged.size);
-		const added = /* @__PURE__ */ new Set();
-		const removed = /* @__PURE__ */ new Set();
-		const updated = /* @__PURE__ */ new Set();
-		for (const [key, entry] of staged) {
-			const existed = values.has(key);
-			if (entry.present) {
-				if (!existed) added.add(key);
-				else if (!isEqual(values.get(key), entry.value)) updated.add(key);
-				else if (!nextReset) staged.delete(key);
-			} else if (existed) removed.add(key);
-			else staged.delete(key);
-		}
-		if (explicitOrder || added.size || removed.size) {
-			const order = explicitOrder ?? [...ids.filter((key) => !removed.has(key)), ...added];
-			if (new Set(order).size !== order.length || order.length !== values.size + added.size - removed.size || order.some((key) => !hasNext(key))) throw new TypeError("Projection order must contain every key exactly once.");
-			nextIds = ids.length === order.length && ids.every((key, index) => key === order[index]) ? ids : Object.freeze([...order]);
-		} else nextIds = ids;
-		const changedKeys = new Set([
-			...added,
-			...removed,
-			...updated
-		]);
-		profile.projection("changedKeys", changedKeys.size);
-		const addedEntries = [];
-		const updatedEntries = [];
-		const removedEntries = [];
-		for (const key of changedKeys) {
-			const beforePresent = values.has(key);
-			const afterPresent = hasNext(key);
-			if (beforePresent === afterPresent) {
-				if (!beforePresent || isEqual(values.get(key), getNext(key))) continue;
-			}
-			if (!beforePresent) addedEntries.push({
-				key,
-				after: getNext(key)
-			});
-			else if (!afterPresent) removedEntries.push({
-				key,
-				before: values.get(key)
-			});
-			else updatedEntries.push({
-				key,
-				before: values.get(key),
-				after: getNext(key)
-			});
-		}
-		const orderChanged = nextIds !== ids;
-		if (nextReset) change = Object.freeze({ kind: "reset" });
-		else if (addedEntries.length || updatedEntries.length || removedEntries.length || orderChanged) {
-			let commonOrderChanged = false;
-			if (orderChanged) {
-				const before = ids.filter((key) => !removed.has(key));
-				const after = nextIds.filter((key) => !added.has(key));
-				commonOrderChanged = before.some((key, index) => after[index] !== key);
-			}
-			change = Object.freeze({
-				kind: "incremental",
-				added: Object.freeze(addedEntries),
-				updated: Object.freeze(updatedEntries),
-				removed: Object.freeze(removedEntries),
-				...commonOrderChanged ? { order: Object.freeze({
-					before: Object.freeze([...ids]),
-					after: Object.freeze([...nextIds])
-				}) } : {}
-			});
-		}
-		reset = nextReset;
-		return change !== void 0;
-	};
-	const context = (active, cause) => Object.freeze({
-		kind: "collection",
-		read: {
-			get: (key) => {
-				assertScope(active);
-				return getNext(key);
-			},
-			has: (key) => {
-				assertScope(active);
-				return hasNext(key);
-			},
-			ids: () => {
-				assertScope(active);
-				return nextIds;
-			}
-		},
-		change,
-		revision,
-		reset,
-		cause
-	});
-	const current = (check) => {
-		const root = publishedRoot;
-		const publishedIds = ids;
-		return Object.freeze({
-			get: (key) => {
-				check();
-				return treeGet(root, key);
-			},
-			has: (key) => {
-				check();
-				return treeHas(root, key);
-			},
-			ids: () => {
-				check();
-				return publishedIds;
-			}
-		});
-	};
-	return {
-		begin,
-		seal,
-		context,
-		current,
-		revision: () => revision,
-		reset: () => reset,
-		publish: () => {
-			if (change) if (change.kind === "reset") {
-				const entries = [];
-				for (const [key, entry] of staged) if (entry.present) entries.push([key, entry.value]);
-				entries.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
-				publishedRoot = treeFromSorted(entries);
-			} else for (const [key, entry] of staged) publishedRoot = entry.present ? treeSet(publishedRoot, key, entry.value) : treeRemove(publishedRoot, key);
-			for (const [key, entry] of staged) if (entry.present) values.set(key, entry.value);
-			else values.delete(key);
-			if (change && initialized) revision++;
-			ids = nextIds;
-			initialized = true;
-		},
-		emit: (call) => {
-			const resetEvent = Object.freeze({ kind: "reset" });
-			Array.from(listeners).forEach((listener) => call(() => listener(change ?? resetEvent)));
-		},
-		clear: () => {
-			staged.clear();
-			nextIds = ids;
-			change = void 0;
-			reset = false;
-			explicitOrder = void 0;
-			cleared = false;
-		},
-		release: () => {
-			values.clear();
-			staged.clear();
-			publishedRoot = void 0;
-			listeners.clear();
-			ids = nextIds = Object.freeze([]);
-			change = void 0;
-			initialized = false;
-			revision = 0;
-			reset = false;
-			explicitOrder = void 0;
-			cleared = false;
-		},
-		subscribe: (listener) => listeners.add(listener),
-		unsubscribe: (listener) => listeners.delete(listener)
-	};
-};
-const mapRead = (value) => ({
-	get: (key) => value.get(key),
-	has: (key) => value.has(key),
-	ids: () => Object.freeze([...value.keys()])
-});
-/** Immutable map-like view over a CollectionRead. */
-const collectionView = (read) => {
-	const ids = read.ids();
-	const entries = function* () {
-		for (const key of ids) yield [key, read.get(key)];
-	};
-	const values = function* () {
-		for (const key of ids) yield read.get(key);
-	};
-	const view = {
-		get: (key) => read.get(key),
-		has: (key) => read.has(key),
-		get size() {
-			return ids.length;
-		},
-		keys: () => ids[Symbol.iterator](),
-		values,
-		entries,
-		forEach: (callback, thisArg) => {
-			for (const key of ids) callback.call(thisArg, read.get(key), key, view);
-		},
-		[Symbol.iterator]: entries
-	};
-	return Object.freeze(view);
-};
-/** Eager durable view used when a processor result may retain its dependency value. */
-const snapshotCollectionView = (read) => {
-	const ids = read.ids();
-	const values = /* @__PURE__ */ new Map();
-	for (const key of ids) values.set(key, read.get(key));
-	return collectionView(mapRead(values));
-};
-/**
-* The one source-to-CollectionChange kernel. Candidate keys only narrow value work;
-* exact membership/value/order semantics remain owned here.
-*/
-const stageCollectionRead = (state, read, active, options) => {
-	const evaluation = state.begin(active, options.reset);
-	if (options.reset) {
-		const ids = read.ids();
-		profile.collectionView.idsScanned(ids.length);
-		for (const key of ids) {
-			profile.collectionView.mapped();
-			evaluation.output.set(key, read.get(key));
-		}
-		evaluation.output.order(ids);
-	} else {
-		const previous = state.current(() => void 0);
-		const keys = options.candidates ? [...new Set(options.candidates)] : [...new Set([...previous.ids(), ...read.ids()])];
-		if (!options.candidates) profile.collectionView.idsScanned(keys.length);
-		for (const key of keys) if (read.has(key)) {
-			profile.collectionView.mapped();
-			evaluation.output.set(key, read.get(key));
-		} else evaluation.output.remove(key);
-		if (options.orderMayChange || !options.candidates) {
-			const ids = read.ids();
-			if (options.candidates) profile.collectionView.idsScanned(ids.length);
-			evaluation.output.order(ids);
-		}
-	}
-	return state.seal(options.reset, options.isEqual ?? Object.is);
-};
-/** Exact net transition between two published map-like snapshots. */
-const collectionChangeBetween = (previous, current, isEqual = Object.is) => {
-	const added = [];
-	const removed = [];
-	const updated = [];
-	for (const [key, before] of previous) if (!current.has(key)) removed.push({
-		key,
-		before
-	});
-	else {
-		const after = current.get(key);
-		if (!isEqual(before, after)) updated.push({
-			key,
-			before,
-			after
-		});
-	}
-	for (const [key, after] of current) if (!previous.has(key)) added.push({
-		key,
-		after
-	});
-	const beforeKeys = new Set(previous.keys());
-	const afterKeys = new Set(current.keys());
-	const beforeCommon = [...previous.keys()].filter((key) => afterKeys.has(key));
-	const afterCommon = [...current.keys()].filter((key) => beforeKeys.has(key));
-	const orderChanged = beforeCommon.some((key, index) => afterCommon[index] !== key);
-	if (!added.length && !removed.length && !updated.length && !orderChanged) return void 0;
-	return Object.freeze({
-		kind: "incremental",
-		added: Object.freeze(added),
-		updated: Object.freeze(updated),
-		removed: Object.freeze(removed),
-		...orderChanged ? { order: Object.freeze({
-			before: Object.freeze([...previous.keys()]),
-			after: Object.freeze([...current.keys()])
-		}) } : {}
-	});
-};
-//#endregion
 //#region core/src/projection/definition.ts
 const projections = /* @__PURE__ */ new WeakMap();
 const defineRef = (producer, output) => {
@@ -958,7 +994,7 @@ function observe(source, selector) {
 		equality: Object.is
 	});
 	const document = source;
-	const state = accessOf(document);
+	const state = contextOf(document).state;
 	const selected = selector ? compilePath(state.schema, "auto", selector) : Object.freeze({
 		kind: "value",
 		schema: state.schema,
@@ -1069,25 +1105,23 @@ function createIncrementalCollection(dependencies, processor) {
 	});
 	return projection;
 }
-const groupOutputMetadata = /* @__PURE__ */ new WeakMap();
-const isPlainGroupNamespace = (value) => value !== null && typeof value === "object" && !groupOutputMetadata.has(value) && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
-const compileGroupShape = (value, path, declaredOutputs, used, outputs) => {
+const isPlainGroupNamespace = (value, metadata) => isPlainObject(value) && !metadata.has(value);
+const compileGroupShape = (value, path, metadata, used, outputs) => {
 	if (value !== null && typeof value === "object") {
-		const metadata = groupOutputMetadata.get(value);
-		if (metadata) {
-			if (!declaredOutputs.has(value)) throw new TypeError("Incremental group outputs must be declared by this group.");
+		const output = metadata.get(value);
+		if (output) {
 			if (used.has(value)) throw new TypeError("An incremental group output cannot be reused.");
 			used.add(value);
 			const index = outputs.length;
 			outputs.push({
-				kind: metadata.kind,
-				equality: metadata.equality,
+				kind: output.kind,
+				equality: output.equality,
 				path: Object.freeze([...path])
 			});
 			return index;
 		}
 	}
-	if (!isPlainGroupNamespace(value)) throw new TypeError("Incremental group outputs must be a static object tree.");
+	if (!isPlainGroupNamespace(value, metadata)) throw new TypeError("Incremental group outputs must be a static object tree.");
 	for (const key of Reflect.ownKeys(value)) {
 		if (typeof key !== "string") throw new TypeError("Incremental group output names must be strings.");
 		if (!Object.prototype.propertyIsEnumerable.call(value, key)) throw new TypeError("Incremental group namespaces must contain enumerable properties.");
@@ -1099,7 +1133,7 @@ const compileGroupShape = (value, path, declaredOutputs, used, outputs) => {
 		if (key === "__proto__" || key === "prototype" || key === "constructor") throw new TypeError(`Invalid incremental group output name: ${key}`);
 		const descriptor = Object.getOwnPropertyDescriptor(value, key);
 		if (!descriptor || !("value" in descriptor)) throw new TypeError("Incremental group namespaces cannot contain accessors.");
-		result[key] = compileGroupShape(descriptor.value, [...path, key], declaredOutputs, used, outputs);
+		result[key] = compileGroupShape(descriptor.value, [...path, key], metadata, used, outputs);
 	}
 	return Object.freeze(result);
 };
@@ -1128,26 +1162,24 @@ function createIncrementalGroup(dependencies, defineOutputs, processor) {
 	if (typeof defineOutputs !== "function") throw new TypeError("Incremental group outputs must be declared by a callback.");
 	if (typeof processor !== "function") throw new TypeError("Incremental group processor must be a function.");
 	let active = true;
-	const declaredOutputs = /* @__PURE__ */ new Set();
+	const metadata = /* @__PURE__ */ new Map();
 	const declared = defineOutputs({
 		collection: (equality = Object.is) => {
 			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
 			const descriptor = Object.freeze({});
-			groupOutputMetadata.set(descriptor, {
+			metadata.set(descriptor, {
 				kind: "collection",
 				equality
 			});
-			declaredOutputs.add(descriptor);
 			return descriptor;
 		},
 		value: (equality = Object.is) => {
 			if (!active) throw new TypeError("Incremental group output declarations are synchronous.");
 			const descriptor = Object.freeze({});
-			groupOutputMetadata.set(descriptor, {
+			metadata.set(descriptor, {
 				kind: "value",
 				equality
 			});
-			declaredOutputs.add(descriptor);
 			return descriptor;
 		}
 	});
@@ -1155,9 +1187,9 @@ function createIncrementalGroup(dependencies, defineOutputs, processor) {
 	active = false;
 	const outputs = [];
 	const used = /* @__PURE__ */ new Set();
-	const shape = compileGroupShape(declared, [], declaredOutputs, used, outputs);
+	const shape = compileGroupShape(declared, [], metadata, used, outputs);
 	if (typeof shape === "number") throw new TypeError("Incremental group declarations must return an output namespace.");
-	if (used.size === 0 || used.size !== declaredOutputs.size) throw new TypeError("Every incremental group output must be returned by the declaration.");
+	if (used.size === 0 || used.size !== metadata.size) throw new TypeError("Every incremental group output must be returned by the declaration.");
 	return hydrateGroupShape(shape, defineProcessor({
 		dependencies,
 		outputs,
@@ -1187,6 +1219,6 @@ const incremental = Object.assign(createIncrementalValue, {
 	group: createIncrementalGroup
 });
 //#endregion
-export { list as C, table as D, optional as E, tree as O, field as S, object as T, createScheduler as _, observe as a, collectionEntryNode as b, projectionRef as c, createCollectionOutput as d, mapRead as f, assertSynchronous as g, assertScope as h, isProjection as i, variant as k, collectionChangeBetween as l, stageCollectionRead as m, derive as n, ownProjection as o, snapshotCollectionView as p, input as r, producerOf as s, incremental as t, collectionView as u, ProjectionDisposedError as v, map as w, compilePath as x, ProjectionError as y };
+export { checkValue as A, insert as B, optional as C, ParseError as D, variant as E, parse as F, listSequence as G, installKeys as H, compiledLayout as I, toArray as J, matches as K, compiledShape as L, copyValue as M, equalTreeNode as N, checkKey as O, equalValue as P, equal as R, object as S, tree as T, installList as U, install as V, keys as W, profile as Y, collectionEntryNode as _, observe as a, list as b, projectionRef as c, createScheduler as d, ProjectionDisposedError as f, snapshotCollectionView as g, mapRead as h, isProjection as i, copyTreeNode as j, checkTreePayload as k, assertScope as l, collectionView as m, derive as n, ownProjection as o, ProjectionError as p, remove as q, input as r, producerOf as s, incremental as t, assertSynchronous as u, compilePath as v, table as w, map as x, field as y, indexedKeys as z };
 
-//# sourceMappingURL=advanced-BTStm2cW.js.map
+//# sourceMappingURL=advanced-CRNHfJBu.js.map