@peripheries/renderer 0.1.0

package/dist/core.js

@@ -0,0 +1,740 @@
+import { B as hasRef, D as numberingFor, E as normalizeStructure, F as resolveReferences, H as resolveCell, I as settled, L as CONTENT_FIELDS, M as usesStructureLayout, N as cellResolutionContext, O as referencesFor, P as passesConditions, R as HYDRATED_CELL_FIELDS, S as deriveSectionReferences, T as nodePrintStyle, U as rootCells, V as normalizeCell, _ as projectCellData, a as projectSelections, b as deriveElementReferences, c as pageScopeKey, d as nearestThemeProvider, f as resolveComponent, g as assembleCellProps, h as pageContainerStyle, i as projectLive, j as structureIssues, k as sectionAnchor, l as projectScopeKey, m as cellPlacementStyle, n as attachViewStateSetters, o as projectViewState, p as cellAttributes, r as collectScopeIds, s as shallowEqualBundle, t as attachSelectionSetters, u as resolveScopeId, v as PAGE_DOCUMENT, w as mergeSectionReferences, x as deriveSectionNumbering, y as SECTION_KINDS, z as STORE_FIELDS } from "./chunks/projection-Dsy9ruj8.js";
+import { a as projectModule, i as loadBundles, n as isComponentExport, o as runtimeReady, r as loadBundle, t as _clearBundleCache } from "./chunks/load-6zEgvJ6I.js";
+import { a as bundleScope, i as PUBLIC, n as pageBundles, o as normalizeRef, r as MAIN, s as refKey, t as pageBundleRefs } from "./chunks/page-bundles-C4VW3dsK.js";
+import { t as createStackStore } from "./chunks/create-store-CglsI7tw.js";
+import { DEFAULT_STATE, STATE_NAMES, WALK_DEFAULTS, isStateName } from "@peripheries/runtime";
+//#region packages/renderer/src/core/graph.ts
+function systemsFromProcess(row) {
+	const out = {};
+	for (const name of STATE_NAMES) {
+		const id = row?.[`${name}_system_id`];
+		if (typeof id === "string" && id) out[name] = id;
+	}
+	return out;
+}
+function stateNames(state) {
+	const raw = state === void 0 || state === null ? [DEFAULT_STATE] : Array.isArray(state) ? state : [state];
+	const names = [];
+	const unknown = [];
+	for (const s of raw) if (!isStateName(s)) unknown.push(String(s));
+	else if (!names.includes(s)) names.push(s);
+	return {
+		names,
+		unknown
+	};
+}
+function readField(state, field) {
+	if (!field) return state;
+	return field.split(".").reduce((o, k) => o === null || o === void 0 ? void 0 : o[k], state);
+}
+function mergeStates(values) {
+	let merged = void 0;
+	for (const v of values) {
+		if (v === void 0) continue;
+		merged = isPlainObject(merged) && isPlainObject(v) ? {
+			...merged,
+			...v
+		} : v;
+	}
+	return merged;
+}
+function stateValue(state, names, field) {
+	const merged = mergeStates(names.map((n) => state[n] ? state[n].data : void 0));
+	return merged === void 0 ? void 0 : readField(merged, field);
+}
+var isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+function resolveWalkStart(cell, pageGraphNodeId) {
+	const own = cell.graph_node_id ?? cell.metadata?.graph_node_id;
+	if (own) return {
+		graphNodeId: own,
+		kind: "cell"
+	};
+	if (pageGraphNodeId) return {
+		graphNodeId: pageGraphNodeId,
+		kind: "page"
+	};
+	return null;
+}
+var RESERVED = new Set([
+	"_traversal",
+	"params",
+	"baseProps"
+]);
+var STRICT_REF = /^@([A-Za-z0-9_$-]+)(\.[A-Za-z0-9_$[\]-]+)*$/;
+function referencedLabels(cell) {
+	const out = new Set();
+	const visit = (v) => {
+		if (typeof v === "string") {
+			const m = STRICT_REF.exec(v);
+			if (m) out.add(m[1]);
+		} else if (Array.isArray(v)) v.forEach(visit);
+		else if (v && typeof v === "object") Object.values(v).forEach(visit);
+	};
+	visit(cell.props);
+	visit(cell.conditions);
+	return out;
+}
+function needsWalk(cell, explicit) {
+	for (const label of referencedLabels(cell)) {
+		if (label === "_traversal") return true;
+		if (RESERVED.has(label) || explicit.has(label) || cell.data?.queries?.[label]) continue;
+		return true;
+	}
+	return false;
+}
+var sortedOrNull = (v) => Array.isArray(v) && v.length ? [...new Set(v.map(String))].sort() : null;
+function walkRequest(config, start, systems) {
+	const diagnostics = [];
+	const edgeTypes = sortedOrNull(config.edgeTypes);
+	if (!edgeTypes) return { diagnostics: [{
+		severity: "error",
+		code: "WALK_EDGE_TYPES_REQUIRED",
+		message: "traversal.edgeTypes is required: without it a walk follows every edge type"
+	}] };
+	const direction = config.direction ?? WALK_DEFAULTS.direction;
+	if (![
+		"incoming",
+		"outgoing",
+		"both"
+	].includes(direction)) return { diagnostics: [{
+		severity: "error",
+		code: "WALK_BAD_DIRECTION",
+		message: `traversal.direction "${direction}" isn't incoming, outgoing or both`
+	}] };
+	const requested = config.maxNodes ?? WALK_DEFAULTS.maxNodes;
+	if (requested > WALK_DEFAULTS.maxNodesCeiling) diagnostics.push({
+		severity: "warning",
+		code: "WALK_MAX_NODES_CLAMPED",
+		message: `traversal.maxNodes ${requested} is above ${WALK_DEFAULTS.maxNodesCeiling}; clamped`
+	});
+	const { names, unknown } = stateNames(config.include_state);
+	for (const u of unknown) diagnostics.push({
+		severity: "error",
+		code: "STATE_UNKNOWN_NAME",
+		message: `include_state "${u}" isn't a system name (${STATE_NAMES.join(", ")})`
+	});
+	const states = [];
+	for (const name of names) {
+		const systemId = systems[name];
+		if (systemId) states.push({
+			name,
+			systemId
+		});
+		else diagnostics.push({
+			severity: "error",
+			code: "STATE_UNKNOWN_SYSTEM",
+			message: `the page's process has no ${name} system`
+		});
+	}
+	return {
+		request: {
+			start,
+			direction,
+			edgeTypes,
+			nodeTypes: sortedOrNull(config.nodeTypes),
+			maxDepth: config.maxDepth ?? WALK_DEFAULTS.maxDepth,
+			maxNodes: Math.min(requested, WALK_DEFAULTS.maxNodesCeiling),
+			states,
+			excludeNodeTypes: sortedOrNull(config.excludeNodeTypes),
+			excludeEdgeTypes: sortedOrNull(config.excludeEdgeTypes)
+		},
+		diagnostics
+	};
+}
+var walkKey = (r) => JSON.stringify([
+	r.start.graphNodeId,
+	r.direction,
+	r.edgeTypes,
+	r.nodeTypes,
+	r.maxDepth,
+	r.maxNodes,
+	r.states.map((s) => s.systemId),
+	r.excludeNodeTypes,
+	r.excludeEdgeTypes
+]);
+function isNoise(node, start) {
+	if (node.graph_node_id === start.graphNodeId) return true;
+	if (node.node_type === "project_page_cell") return true;
+	return start.kind === "page" && node.content?.role === "page";
+}
+function readWalk(raw, request) {
+	const diagnostics = [];
+	if (raw.truncated) diagnostics.push({
+		severity: "warning",
+		code: "WALK_TRUNCATED",
+		message: `the walk stopped at maxNodes ${request.maxNodes}; nodes past it are missing`
+	});
+	const nodes = raw.nodes.filter((n) => !isNoise(n, request.start)).map((n) => {
+		const state = {};
+		for (const { name, systemId } of request.states) state[name] = n.state?.[systemId] ?? null;
+		return {
+			...n,
+			state
+		};
+	});
+	const kept = new Set(nodes.map((n) => n.id));
+	const edges = raw.edges.filter((e) => kept.has(e.source) && kept.has(e.target));
+	const byLabel = new Map();
+	for (const n of nodes) {
+		const label = n.content?.binding_key;
+		if (typeof label !== "string" || !label) continue;
+		const field = typeof n.content?.field === "string" ? n.content.field : void 0;
+		byLabel.set(label, [...byLabel.get(label) ?? [], {
+			label,
+			graph_node_id: n.graph_node_id,
+			field
+		}]);
+	}
+	const bindings = [];
+	for (const [label, found] of byLabel) if (found.length === 1) bindings.push(found[0]);
+	else diagnostics.push({
+		severity: "error",
+		code: "BINDING_DUPLICATE_KEY",
+		label,
+		message: `${found.length} nodes the walk reached share binding_key "${label}"; it binds nothing`
+	});
+	return {
+		traversal: {
+			nodes,
+			edges
+		},
+		bindings,
+		diagnostics
+	};
+}
+//#endregion
+//#region packages/renderer/src/core/data-context.ts
+function resolveDeclarations(queries, systems, diagnostics = [], cellId) {
+	const out = {};
+	for (const [label, raw] of Object.entries(queries ?? {})) {
+		const decl = raw;
+		if (!decl?.graph_node_id) continue;
+		let reads;
+		if (decl.system_id) reads = [{ systemId: decl.system_id }];
+		else {
+			const { names, unknown } = stateNames(decl.state);
+			for (const u of unknown) diagnostics.push({
+				severity: "error",
+				code: "STATE_UNKNOWN_NAME",
+				label,
+				cellId,
+				message: `"${label}" names state "${u}", which isn't a system name`
+			});
+			reads = [];
+			for (const name of names) if (systems[name]) reads.push({
+				name,
+				systemId: systems[name]
+			});
+			else diagnostics.push({
+				severity: "error",
+				code: "STATE_UNKNOWN_SYSTEM",
+				label,
+				cellId,
+				message: `"${label}" reads ${name}, and the page's process has no ${name} system`
+			});
+		}
+		if (reads.length) out[label] = {
+			...decl,
+			reads
+		};
+	}
+	return out;
+}
+var collectDeclarations = (page, systems, diagnostics = []) => resolveDeclarations(page.content?.data?.queries, systems, diagnostics);
+function collectStatic(page) {
+	return { ...page.content?.data?.static ?? {} };
+}
+function buildDataContext(input) {
+	const ctx = {};
+	for (const [k, v] of Object.entries(input.static)) ctx[k] = settled(v);
+	for (const [label, decl] of Object.entries(input.declared)) {
+		if (decl.as === "record") {
+			ctx[label] = settled(input.records?.[decl.graph_node_id] ?? null);
+			continue;
+		}
+		const merged = mergeStates(decl.reads.map((r) => input.states.get(`${r.systemId}/${decl.graph_node_id}`)));
+		ctx[label] = settled(merged === void 0 ? null : readField(merged, decl.field) ?? null);
+	}
+	return ctx;
+}
+//#endregion
+//#region packages/renderer/src/core/validate.ts
+var BUCKETS = [
+	"narrow",
+	"compact",
+	"wide"
+];
+var SCOPES = ["page", "project"];
+var DIRECTIONS = [
+	"incoming",
+	"outgoing",
+	"both"
+];
+function checkBindings(queries, path, push, cellId) {
+	if (queries === void 0) return;
+	if (!queries || typeof queries !== "object" || Array.isArray(queries)) {
+		push({
+			severity: "error",
+			code: "BINDING_INVALID",
+			cellId,
+			path,
+			message: "data.queries must be an object of label → binding"
+		});
+		return;
+	}
+	for (const [label, raw] of Object.entries(queries)) {
+		const at = `${path}.${label}`;
+		const b = raw;
+		if (!b || typeof b !== "object") {
+			push({
+				severity: "error",
+				code: "BINDING_INVALID",
+				cellId,
+				label,
+				path: at,
+				message: `"${label}" isn't a binding`
+			});
+			continue;
+		}
+		if (typeof b.registry === "string") {
+			push({
+				severity: "warning",
+				code: "UNSUPPORTED_REGISTRY_BINDING",
+				cellId,
+				label,
+				path: at,
+				message: `"${label}" names the registry query ${b.registry}, which the host no longer runs (R2 maps or retires it)`
+			});
+			continue;
+		}
+		if (typeof b.graph_node_id !== "string" || !b.graph_node_id) {
+			push({
+				severity: "error",
+				code: "BINDING_INVALID",
+				cellId,
+				label,
+				path: at,
+				message: `"${label}" names no graph_node_id`
+			});
+			continue;
+		}
+		if (b.as !== void 0 && b.as !== "value" && b.as !== "record") push({
+			severity: "error",
+			code: "BINDING_INVALID",
+			cellId,
+			label,
+			path: `${at}.as`,
+			message: `"${label}".as is "${String(b.as)}"; expected value or record`
+		});
+		for (const s of b.state === void 0 ? [] : Array.isArray(b.state) ? b.state : [b.state]) if (!isStateName(s)) push({
+			severity: "error",
+			code: "STATE_UNKNOWN_NAME",
+			cellId,
+			label,
+			path: `${at}.state`,
+			message: `"${label}" names state "${String(s)}"; expected one of ${STATE_NAMES.join(", ")}`
+		});
+	}
+}
+function checkTraversal(t, path, push, cellId) {
+	if (t === void 0) return;
+	const w = t;
+	if (!Array.isArray(w.edgeTypes) || w.edgeTypes.length === 0) push({
+		severity: "error",
+		code: "WALK_EDGE_TYPES_REQUIRED",
+		cellId,
+		path: `${path}.edgeTypes`,
+		message: "traversal.edgeTypes is required: without it a walk follows every edge type"
+	});
+	if (w.direction !== void 0 && !DIRECTIONS.includes(String(w.direction))) push({
+		severity: "error",
+		code: "WALK_BAD_DIRECTION",
+		cellId,
+		path: `${path}.direction`,
+		message: `traversal.direction "${String(w.direction)}" isn't incoming, outgoing or both`
+	});
+	if (typeof w.maxNodes === "number" && w.maxNodes > 500) push({
+		severity: "warning",
+		code: "WALK_MAX_NODES_CLAMPED",
+		cellId,
+		path: `${path}.maxNodes`,
+		message: `traversal.maxNodes ${w.maxNodes} is above 500; clamped`
+	});
+	for (const s of Array.isArray(w.include_state) ? w.include_state : []) if (!isStateName(s)) push({
+		severity: "error",
+		code: "STATE_UNKNOWN_NAME",
+		cellId,
+		path: `${path}.include_state`,
+		message: `include_state "${String(s)}" isn't a system name`
+	});
+}
+function checkStore(cell, path, push) {
+	for (const [kind, key] of [
+		["selections", "channel"],
+		["viewState", "key"],
+		["live", "channel"]
+	]) for (const [name, decl] of Object.entries(cell[kind] ?? {})) {
+		const at = `${path}.${kind}.${name}`;
+		if (typeof decl?.[key] !== "string" || !decl[key]) push({
+			severity: "error",
+			code: "STORE_INVALID",
+			cellId: cell.id,
+			path: at,
+			message: `${kind}.${name} names no ${key}`
+		});
+		if (kind !== "live" && !SCOPES.includes(String(decl?.scope))) push({
+			severity: "error",
+			code: "STORE_INVALID",
+			cellId: cell.id,
+			path: `${at}.scope`,
+			message: `${kind}.${name}.scope must be page or project`
+		});
+	}
+}
+function validateCell(cell, catalog, path = "cell", ids) {
+	const out = [];
+	const push = (d) => out.push(d);
+	if (typeof cell?.id !== "string" || !cell.id) {
+		push({
+			severity: "error",
+			code: "CELL_NO_ID",
+			path,
+			message: "a cell needs an id"
+		});
+		return out;
+	}
+	const cellId = cell.id;
+	const ref = cell.ref;
+	if (ref !== void 0 && (typeof ref?.graph_node_id !== "string" || !ref.graph_node_id)) push({
+		severity: "error",
+		code: "REF_INVALID",
+		cellId,
+		path: `${path}.ref`,
+		message: "ref names no graph_node_id"
+	});
+	const nodeManaged = Boolean(ref?.graph_node_id) || Boolean(cell.graph_node_id) && !cell.component;
+	if (!ref && cell.graph_node_id && !cell.component) push({
+		severity: "legacy",
+		code: "LEGACY_THIN_REF",
+		cellId,
+		path,
+		message: "a thin ref `{ id, graph_node_id }`: publish it as `{ id, ref: { graph_node_id } }`"
+	});
+	else if (!ref && cell.graph_node_id) push({
+		severity: "legacy",
+		code: "LEGACY_INLINE_NODE",
+		cellId,
+		path,
+		message: "an inline cell with a graph_node_id: its node only starts its walk. Give it a `ref` if the node should manage the cell"
+	});
+	if (!nodeManaged && !cell.component) push({
+		severity: "error",
+		code: "CELL_NO_COMPONENT",
+		cellId,
+		path,
+		message: "an inline cell needs a component"
+	});
+	if (cell.component && catalog && !cell.component.startsWith("@core/")) {
+		const entry = catalog.components[cell.component];
+		if (!entry) push({
+			severity: nodeManaged ? "warning" : "error",
+			code: "CELL_UNKNOWN_COMPONENT",
+			cellId,
+			path: `${path}.component`,
+			message: `no bundle in scope exports ${cell.component}`
+		});
+		else for (const prop of entry.props_schema?.required ?? []) if ((prop === "children" ? cell.props?.children ?? (cell.children?.length ? cell.children : void 0) : cell.props?.[prop]) === void 0) push({
+			severity: nodeManaged ? "warning" : "error",
+			code: "PROP_REQUIRED",
+			cellId,
+			path: `${path}.props.${prop}`,
+			message: `${cell.component} requires ${prop}`
+		});
+	}
+	for (const child of cell.children ?? []) if (child === cellId) push({
+		severity: "error",
+		code: "CELL_CHILD_CYCLE",
+		cellId,
+		path: `${path}.children`,
+		message: "a cell lists itself as a child"
+	});
+	else if (ids && !ids.has(child)) push({
+		severity: "error",
+		code: "CELL_UNKNOWN_CHILD",
+		cellId,
+		path: `${path}.children`,
+		message: `child cell "${child}" is not on the page`
+	});
+	checkBindings(cell.data?.queries, `${path}.data.queries`, push, cellId);
+	checkTraversal(cell.traversal, `${path}.traversal`, push, cellId);
+	checkStore(cell, path, push);
+	for (const key of [
+		"hideWhen",
+		"showWhen",
+		"stackWhen",
+		"truncateWhen"
+	]) {
+		const v = cell.layout?.[key];
+		if (v !== void 0 && !BUCKETS.includes(v)) push({
+			severity: "warning",
+			code: "LAYOUT_INVALID",
+			cellId,
+			path: `${path}.layout.${key}`,
+			message: `layout.${key} "${v}" isn't narrow, compact or wide`
+		});
+	}
+	return out;
+}
+function validatePage(page, catalog) {
+	const out = [];
+	const cells = page.content?.cells;
+	if (cells !== void 0 && !Array.isArray(cells)) return [{
+		severity: "error",
+		code: "PAGE_INVALID",
+		path: "content.cells",
+		message: "content.cells must be a list"
+	}];
+	const list = cells ?? [];
+	const ids = new Set();
+	list.forEach((cell, i) => {
+		if (typeof cell?.id === "string" && ids.has(cell.id)) out.push({
+			severity: "error",
+			code: "CELL_DUPLICATE_ID",
+			cellId: cell.id,
+			path: `content.cells[${i}].id`,
+			message: `two cells share the id "${cell.id}"`
+		});
+		if (typeof cell?.id === "string") ids.add(cell.id);
+	});
+	list.forEach((cell, i) => out.push(...validateCell(cell, catalog, `content.cells[${i}]`, ids)));
+	checkBindings(page.content?.data?.queries, "content.data.queries", (d) => out.push(d));
+	if (usesStructureLayout(page.layout)) for (const issue of structureIssues(page.layout?.structure, list)) out.push({
+		severity: "error",
+		code: "STRUCTURE_INVALID",
+		path: "layout.structure",
+		message: issue
+	});
+	return out;
+}
+//#endregion
+//#region packages/renderer/src/core/load-page.ts
+async function resolveSystems(source, page) {
+	const systems = page.process_id ? systemsFromProcess(await source.processSystems(page.process_id)) : {};
+	if (!systems.eng_data) {
+		const meta = page.metadata ?? {};
+		const fallback = meta.pageProcess?.eng_data_system_id ?? meta.systemGraph?.system_id;
+		if (fallback) systems.eng_data = fallback;
+	}
+	return systems;
+}
+async function resolveDataSystem(source, page) {
+	return (await resolveSystems(source, page)).eng_data ?? null;
+}
+async function loadPageData(page, source) {
+	const diagnostics = validatePage(page);
+	const systems = await resolveSystems(source, page);
+	const engDataSystemId = systems.eng_data ?? null;
+	const entries = (page.content?.cells ?? []).map((c) => normalizeCell(c).cell);
+	const refsBySystem = new Map();
+	for (const c of entries) {
+		if (!hasRef(c)) continue;
+		const system = c.ref.system_id ?? engDataSystemId;
+		if (system) refsBySystem.set(system, [...refsBySystem.get(system) ?? [], c.ref.graph_node_id]);
+	}
+	const configs = new Map();
+	await Promise.all([...refsBySystem].map(async ([system, ids]) => {
+		const found = await source.cellConfigs(system, ids);
+		for (const [id, config] of Object.entries(found)) configs.set(`${system}/${id}`, config);
+	}));
+	const cells = entries.map((c) => {
+		if (!hasRef(c)) return resolveCell(c, null);
+		const system = c.ref.system_id ?? engDataSystemId;
+		const resolved = resolveCell(c, system ? configs.get(`${system}/${c.ref.graph_node_id}`) : null);
+		if (resolved.source === "fallback") diagnostics.push({
+			severity: "warning",
+			code: "REF_FALLBACK",
+			cellId: c.id,
+			message: `the node ${c.ref.graph_node_id} has no page_cell_config the viewer can read; the cell renders its own copy`
+		});
+		return resolved;
+	});
+	const unresolved = cells.filter((c) => c.source === "pending").map((c) => c.id);
+	const declared = collectDeclarations(page, systems, diagnostics);
+	const explicit = new Set(Object.keys(declared));
+	const cellDecls = new Map(cells.filter((c) => c.component).map((c) => [c.id, resolveDeclarations(c.data?.queries, systems, diagnostics, c.id)]));
+	const walking = [];
+	for (const cell of cells) {
+		if (!cell.traversal || !cell.component) continue;
+		const start = resolveWalkStart(cell, page.graph_node_id);
+		if (!start) {
+			diagnostics.push({
+				severity: "warning",
+				code: "WALK_NO_START",
+				cellId: cell.id,
+				message: "the cell has a traversal but neither it nor the page has a graph node to start from"
+			});
+			continue;
+		}
+		if (!needsWalk(cell, explicit)) continue;
+		const { request, diagnostics: found } = walkRequest(cell.traversal, start, systems);
+		diagnostics.push(...found.map((d) => ({
+			...d,
+			cellId: cell.id
+		})));
+		if (request) walking.push({
+			cell,
+			request
+		});
+	}
+	const requests = new Map(walking.map(({ request }) => [walkKey(request), request]));
+	const bySystem = new Map();
+	const recordIds = new Set();
+	const recordSystems = new Set();
+	const allDecls = [declared, ...cellDecls.values()];
+	for (const decls of allDecls) for (const d of Object.values(decls)) {
+		if (d.as === "record") {
+			recordIds.add(d.graph_node_id);
+			for (const r of d.reads) recordSystems.add(r.systemId);
+			continue;
+		}
+		for (const r of d.reads) bySystem.set(r.systemId, (bySystem.get(r.systemId) ?? new Set()).add(d.graph_node_id));
+	}
+	const states = new Map();
+	const walks = new Map();
+	let records = {};
+	await Promise.all([
+		...[...bySystem].map(async ([systemId, ids]) => {
+			const found = await source.latestStates(systemId, [...ids]);
+			for (const [nodeId, state] of Object.entries(found)) states.set(`${systemId}/${nodeId}`, state);
+		}),
+		...[...requests].map(async ([key, request]) => {
+			try {
+				walks.set(key, await source.walk(request));
+			} catch (e) {
+				diagnostics.push({
+					severity: "error",
+					code: "WALK_FAILED",
+					message: `a walk from ${request.start.graphNodeId} failed: ${e.message}`
+				});
+			}
+		}),
+		recordIds.size ? (async () => {
+			records = recordsByName(await source.nodeRecords([...recordIds], [...recordSystems]), allDecls);
+		})() : null
+	]);
+	const cellData = {};
+	const entry = (id) => cellData[id] ??= {
+		static: {},
+		declared: {}
+	};
+	for (const cell of cells) {
+		const decls = cellDecls.get(cell.id);
+		if (decls && Object.keys(decls).length) entry(cell.id).declared = buildDataContext({
+			static: {},
+			declared: decls,
+			states,
+			records
+		});
+		if (cell.data?.static && Object.keys(cell.data.static).length) entry(cell.id).static = buildDataContext({
+			static: cell.data.static,
+			declared: {},
+			states
+		});
+	}
+	for (const { cell, request } of walking) {
+		const raw = walks.get(walkKey(request));
+		if (!raw) continue;
+		const { traversal, bindings, diagnostics: found } = readWalk(raw, request);
+		diagnostics.push(...found.map((d) => ({
+			...d,
+			cellId: cell.id
+		})));
+		const names = request.states.map((s) => s.name);
+		const labels = {};
+		for (const b of bindings) {
+			const node = traversal.nodes.find((n) => n.graph_node_id === b.graph_node_id);
+			labels[b.label] = settled((node && stateValue(node.state, names, b.field)) ?? null);
+		}
+		entry(cell.id).walk = {
+			traversal,
+			labels
+		};
+	}
+	return {
+		page,
+		cells,
+		unresolved,
+		data: buildDataContext({
+			static: collectStatic(page),
+			declared,
+			states,
+			records
+		}),
+		declared: [...explicit],
+		cellData,
+		systems,
+		engDataSystemId,
+		diagnostics: dedupe(diagnostics)
+	};
+}
+function dedupe(list) {
+	const seen = new Set();
+	return list.filter((d) => {
+		const key = `${d.code}|${d.cellId ?? ""}|${d.label ?? ""}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function recordsByName(found, declarations) {
+	const out = {};
+	for (const d of declarations.flatMap((decls) => Object.values(decls))) {
+		const row = found[d.graph_node_id];
+		if (d.as !== "record" || !row) continue;
+		const { stateBySystem, ...rest } = row;
+		const state = { ...out[d.graph_node_id]?.state };
+		for (const r of d.reads) if (r.name) state[r.name] = stateBySystem[r.systemId] ?? null;
+		out[d.graph_node_id] = {
+			...rest,
+			state
+		};
+	}
+	return out;
+}
+//#endregion
+//#region packages/renderer/src/core/store/persistence.ts
+var KEY_PREFIX = "stack.store.";
+function storageFor(mode) {
+	if (typeof window === "undefined" || mode === "none") return null;
+	try {
+		return mode === "session" ? window.sessionStorage : window.localStorage;
+	} catch {
+		return null;
+	}
+}
+function loadScope(scope, mode) {
+	const store = storageFor(mode);
+	if (!store) return null;
+	try {
+		const raw = store.getItem(KEY_PREFIX + scope);
+		return raw ? JSON.parse(raw) : null;
+	} catch {
+		return null;
+	}
+}
+function saveScope(scope, slice, mode) {
+	const store = storageFor(mode);
+	if (!store) return;
+	try {
+		store.setItem(KEY_PREFIX + scope, JSON.stringify(slice));
+	} catch {}
+}
+function clearScope(scope, mode) {
+	try {
+		storageFor(mode)?.removeItem(KEY_PREFIX + scope);
+	} catch {}
+}
+//#endregion
+export { CONTENT_FIELDS, HYDRATED_CELL_FIELDS, MAIN, PAGE_DOCUMENT, PUBLIC, SECTION_KINDS, STORE_FIELDS, _clearBundleCache, assembleCellProps, attachSelectionSetters, attachViewStateSetters, buildDataContext, bundleScope, cellAttributes, cellPlacementStyle, cellResolutionContext, clearScope, collectDeclarations, collectScopeIds, collectStatic, createStackStore, deriveElementReferences, deriveSectionNumbering, deriveSectionReferences, hasRef, isComponentExport, loadBundle, loadBundles, loadPageData, loadScope, mergeSectionReferences, mergeStates, nearestThemeProvider, needsWalk, nodePrintStyle, normalizeCell, normalizeRef, normalizeStructure, numberingFor, pageBundleRefs, pageBundles, pageContainerStyle, pageScopeKey, passesConditions, projectCellData, projectLive, projectModule, projectScopeKey, projectSelections, projectViewState, readField, readWalk, refKey, referencedLabels, referencesFor, resolveCell, resolveComponent, resolveDataSystem, resolveDeclarations, resolveReferences, resolveScopeId, resolveSystems, resolveWalkStart, rootCells, runtimeReady, saveScope, sectionAnchor, settled, shallowEqualBundle, stateNames, stateValue, structureIssues, systemsFromProcess, usesStructureLayout, validateCell, validatePage, walkKey, walkRequest };
+
+//# sourceMappingURL=core.js.map