doxum 0.1.22 → 0.1.23

package/dist/{advanced-GKZ-CZ6a.cjs → advanced-Cle5g3B4.cjs}

@@ -1,5 +1,404 @@
-const require_issue = require("./issue-Bo0FIO3b.cjs");
-const require_access = require("./access-D64MFRSm.cjs");
+const require_context = require("./context-BcLKGfq8.cjs");
+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 (!require_context.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 (!require_context.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 (!require_context.isPlainObject(value)) return issue(address, "Expected a collection object.");
+		const entries = node.kind === "table" ? value.byId : value;
+		if (!require_context.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 (!require_context.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 (!require_context.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") && require_context.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") && require_context.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" && require_context.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") && require_context.isRecord(left) && require_context.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" && require_context.isRecord(left) && require_context.isRecord(right)) return equal(left.ids, right.ids) && equalValue({
+		kind: "map",
+		value: node.value
+	}, left.byId, right.byId);
+	if (node.kind === "tree" && require_context.isRecord(left) && require_context.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" && require_context.isRecord(left) && require_context.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);
@@ -66,7 +465,7 @@ const pathProxy = (nodes, address, owner, treeSelection) => {
 		if (nodes.every((node) => collectionEntryNode(node) !== void 0) && property === "item") return (id) => {
 			if (typeof id !== "string") throw new TypeError("Collection keys must be strings.");
 			for (const node of nodes) if (node.kind === "table" || node.kind === "map") {
-				const invalid = require_access.checkKey(node.key, id, [...address, id]);
+				const invalid = checkKey(node.key, id, [...address, id]);
 				if (invalid) throw new TypeError(invalid.message);
 			}
 			return pathProxy(nodes.map((node) => collectionEntryNode(node)), [...address, id], owner);
@@ -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;
@@ -150,7 +588,7 @@ const createScheduler = (onError) => {
 	const enqueue = (processor) => {
 		if (processor.disposed || queued.has(processor)) return;
 		queued.add(processor);
-		require_issue.profile.projection("scheduledNodes");
+		profile.projection("scheduledNodes");
 		let index = heap.length;
 		heap.push(processor);
 		while (index > 0) {
@@ -187,7 +625,7 @@ const createScheduler = (onError) => {
 			throw source.fault;
 		}
 		pendingSources.add(source);
-		require_issue.profile.projection("sourceEvents");
+		profile.projection("sourceEvents");
 		if (source.fault) errors.push(source.fault);
 	};
 	const settleCause = () => {
@@ -229,7 +667,7 @@ const createScheduler = (onError) => {
 				const processor = pop();
 				if (processor.disposed) continue;
 				const wasFaulted = processor.fault !== void 0;
-				require_issue.profile.projection("processedNodes");
+				profile.projection("processedNodes");
 				let changedOutputs = Object.freeze([]);
 				const blocked = processor.dependencies.find((output) => output.owner.fault || output.owner.disposed);
 				if (blocked) processor.fault = errorFor(processor, blocked.owner.fault ?? new ProjectionDisposedError(), "blocked");
@@ -269,7 +707,7 @@ const createScheduler = (onError) => {
 					}
 					(recovered ? processor.outputs : changedOutputs).forEach((output) => output.consumers.forEach(enqueue));
 				}
-				if (processor.fault || changedOutputs.length) require_issue.profile.projection("publishedNodes");
+				if (processor.fault || changedOutputs.length) profile.projection("publishedNodes");
 			}
 		} finally {
 			lock(false);
@@ -278,7 +716,7 @@ const createScheduler = (onError) => {
 	};
 	const flush = () => {
 		if (disposed || depth) return [];
-		if (pendingSources.size || completed.size) require_issue.profile.projection("flushes");
+		if (pendingSources.size || completed.size) profile.projection("flushes");
 		phase = "notify";
 		lock(true);
 		const reportFailures = [];
@@ -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 });
-		}
-		require_issue.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
-		]);
-		require_issue.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();
-		require_issue.profile.collectionView.idsScanned(ids.length);
-		for (const key of ids) {
-			require_issue.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) require_issue.profile.collectionView.idsScanned(keys.length);
-		for (const key of keys) if (read.has(key)) {
-			require_issue.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) require_issue.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 = require_access.accessOf(document);
+	const state = require_context.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) => require_context.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,12 @@ const incremental = Object.assign(createIncrementalValue, {
 	group: createIncrementalGroup
 });
 //#endregion
+Object.defineProperty(exports, "ParseError", {
+	enumerable: true,
+	get: function() {
+		return ParseError;
+	}
+});
 Object.defineProperty(exports, "ProjectionDisposedError", {
 	enumerable: true,
 	get: function() {
@@ -1211,10 +1249,22 @@ Object.defineProperty(exports, "assertSynchronous", {
 		return assertSynchronous;
 	}
 });
-Object.defineProperty(exports, "collectionChangeBetween", {
+Object.defineProperty(exports, "checkKey", {
 	enumerable: true,
 	get: function() {
-		return collectionChangeBetween;
+		return checkKey;
+	}
+});
+Object.defineProperty(exports, "checkTreePayload", {
+	enumerable: true,
+	get: function() {
+		return checkTreePayload;
+	}
+});
+Object.defineProperty(exports, "checkValue", {
+	enumerable: true,
+	get: function() {
+		return checkValue;
 	}
 });
 Object.defineProperty(exports, "collectionEntryNode", {
@@ -1235,10 +1285,28 @@ Object.defineProperty(exports, "compilePath", {
 		return compilePath;
 	}
 });
-Object.defineProperty(exports, "createCollectionOutput", {
+Object.defineProperty(exports, "compiledLayout", {
+	enumerable: true,
+	get: function() {
+		return compiledLayout;
+	}
+});
+Object.defineProperty(exports, "compiledShape", {
+	enumerable: true,
+	get: function() {
+		return compiledShape;
+	}
+});
+Object.defineProperty(exports, "copyTreeNode", {
+	enumerable: true,
+	get: function() {
+		return copyTreeNode;
+	}
+});
+Object.defineProperty(exports, "copyValue", {
 	enumerable: true,
 	get: function() {
-		return createCollectionOutput;
+		return copyValue;
 	}
 });
 Object.defineProperty(exports, "createScheduler", {
@@ -1253,6 +1321,24 @@ Object.defineProperty(exports, "derive", {
 		return derive;
 	}
 });
+Object.defineProperty(exports, "equal", {
+	enumerable: true,
+	get: function() {
+		return equal;
+	}
+});
+Object.defineProperty(exports, "equalTreeNode", {
+	enumerable: true,
+	get: function() {
+		return equalTreeNode;
+	}
+});
+Object.defineProperty(exports, "equalValue", {
+	enumerable: true,
+	get: function() {
+		return equalValue;
+	}
+});
 Object.defineProperty(exports, "field", {
 	enumerable: true,
 	get: function() {
@@ -1265,24 +1351,66 @@ Object.defineProperty(exports, "incremental", {
 		return incremental;
 	}
 });
+Object.defineProperty(exports, "indexedKeys", {
+	enumerable: true,
+	get: function() {
+		return indexedKeys;
+	}
+});
 Object.defineProperty(exports, "input", {
 	enumerable: true,
 	get: function() {
 		return input;
 	}
 });
+Object.defineProperty(exports, "insert", {
+	enumerable: true,
+	get: function() {
+		return insert;
+	}
+});
+Object.defineProperty(exports, "install", {
+	enumerable: true,
+	get: function() {
+		return install;
+	}
+});
+Object.defineProperty(exports, "installKeys", {
+	enumerable: true,
+	get: function() {
+		return installKeys;
+	}
+});
+Object.defineProperty(exports, "installList", {
+	enumerable: true,
+	get: function() {
+		return installList;
+	}
+});
 Object.defineProperty(exports, "isProjection", {
 	enumerable: true,
 	get: function() {
 		return isProjection;
 	}
 });
+Object.defineProperty(exports, "keys", {
+	enumerable: true,
+	get: function() {
+		return keys;
+	}
+});
 Object.defineProperty(exports, "list", {
 	enumerable: true,
 	get: function() {
 		return list;
 	}
 });
+Object.defineProperty(exports, "listSequence", {
+	enumerable: true,
+	get: function() {
+		return listSequence;
+	}
+});
 Object.defineProperty(exports, "map", {
 	enumerable: true,
 	get: function() {
@@ -1295,6 +1423,12 @@ Object.defineProperty(exports, "mapRead", {
 		return mapRead;
 	}
 });
+Object.defineProperty(exports, "matches", {
+	enumerable: true,
+	get: function() {
+		return matches;
+	}
+});
 Object.defineProperty(exports, "object", {
 	enumerable: true,
 	get: function() {
@@ -1319,28 +1453,40 @@ Object.defineProperty(exports, "ownProjection", {
 		return ownProjection;
 	}
 });
+Object.defineProperty(exports, "parse", {
+	enumerable: true,
+	get: function() {
+		return parse;
+	}
+});
 Object.defineProperty(exports, "producerOf", {
 	enumerable: true,
 	get: function() {
 		return producerOf;
 	}
 });
+Object.defineProperty(exports, "profile", {
+	enumerable: true,
+	get: function() {
+		return profile;
+	}
+});
 Object.defineProperty(exports, "projectionRef", {
 	enumerable: true,
 	get: function() {
 		return projectionRef;
 	}
 });
-Object.defineProperty(exports, "snapshotCollectionView", {
+Object.defineProperty(exports, "remove", {
 	enumerable: true,
 	get: function() {
-		return snapshotCollectionView;
+		return remove;
 	}
 });
-Object.defineProperty(exports, "stageCollectionRead", {
+Object.defineProperty(exports, "snapshotCollectionView", {
 	enumerable: true,
 	get: function() {
-		return stageCollectionRead;
+		return snapshotCollectionView;
 	}
 });
 Object.defineProperty(exports, "table", {
@@ -1349,6 +1495,12 @@ Object.defineProperty(exports, "table", {
 		return table;
 	}
 });
+Object.defineProperty(exports, "toArray", {
+	enumerable: true,
+	get: function() {
+		return toArray;
+	}
+});
 Object.defineProperty(exports, "tree", {
 	enumerable: true,
 	get: function() {
@@ -1362,4 +1514,4 @@ Object.defineProperty(exports, "variant", {
 	}
 });
 
-//# sourceMappingURL=advanced-GKZ-CZ6a.cjs.map
+//# sourceMappingURL=advanced-Cle5g3B4.cjs.map