@peripheries/renderer 0.23.0 → 0.24.0

package/dist/types/core/bundles/refs.d.ts

@@ -10,60 +10,33 @@ export type LineageRef = {
 } | {
     kind: 'pinned';
     bundleId: string;
-}
-/** A shared lineage (design/core-and-tokens.md §4), imported by its specifier. */
- | {
+} | {
     kind: 'shared';
     specifier: string;
     orgSlug: string;
     bundle: string;
 };
-/** A row of `shared_lineage_live`, as the scope needs it. */
 export type SharedLineage = {
     specifier: string;
     org_slug: string;
     bundle_name: string;
 };
-/** The shared lineage `@core/Name` resolves from first. */
 export declare const CORE_SPECIFIER = "@stack/core";
 export declare const MAIN = "main";
 export declare const PUBLIC = "public";
-/**
- * Normalise a config ref. An org slug means that org's main lineage. A named
- * lineage without `org_slug` belongs to the page's org, so it needs `pageOrgId`;
- * without one it is dropped rather than guessed.
- */
 export declare function normalizeRef(ref: unknown, pageOrgId?: string | null): LineageRef | null;
 export declare const refKey: (r: LineageRef) => string;
-/** Where a page's bundles come from, nearest level first (cell refs are per cell). */
 export type BundleScopeInput = {
     pageOrgId?: string | null;
-    /** `project_page.metadata.bundle_refs` */
     pageRefs?: unknown[] | null;
-    /** `project_template.{org_id, bundle_name}` */
     projectTemplate?: {
         orgId: string;
         bundleName: string | null;
     } | null;
-    /** The section's route entry `bundle_ref` (R3). */
     sectionRef?: unknown;
-    /**
-     * The orgs whose main lineages are fallbacks: the page's own org first, then
-     * the org template's advisor org. Only the first comes before the shared
-     * lineages.
-     */
     orgs?: Array<{
         id: string;
     }>;
-    /** `shared_lineage_live`: the shared lineages, after the page's own lineages. */
     shared?: readonly SharedLineage[];
 };
-/**
- * The ordered, de-duplicated lineage list for a page: page → project →
- * section → the page org's main → shared lineages → the advisor org's main
- * (design/core-and-tokens.md §3). The page's own lineages replace a shared
- * component by exporting the same name; the advisor's main only fills names
- * that neither they nor the shared lineages export, so an advisor org's
- * legacy copy of a core component never shadows core on a client's page.
- */
 export declare function bundleScope(input: BundleScopeInput): LineageRef[];

package/dist/types/core/bundles/resolve.d.ts

@@ -3,18 +3,8 @@ import type { LoadedBundle } from './load.js';
 export type CoreRegistry = Record<string, ComponentType<Record<string, unknown>>>;
 export type ResolvedComponent = {
     Component: ComponentType<Record<string, unknown>>;
-    /** Which bundle supplied it, or 'core'. */
     source: string;
 };
-/**
- * One cascade (design/core.md §6, design/bundles.md §2, design/core-and-tokens.md §3):
- * - `@core/Name` comes from `stack/core`, then the host's registry;
- * - a cell with its own bundle_ref resolves from that bundle, then the host;
- * - otherwise the page's bundles, nearest level first (org lineages, then the
- *   shared ones), then the host.
- * The nearest wins on a name collision: that is how an org lineage replaces a
- * shared component. `host:Name` is retired (renderer.md §10): no cell used it.
- */
 export declare function resolveComponent(name: string, { cellBundle, scope, core }: {
     cellBundle?: LoadedBundle | null;
     scope: LoadedBundle[];

package/dist/types/core/cell-props.d.ts

@@ -4,22 +4,10 @@ export type CellStatus = {
     isError: boolean;
     errors?: Error[];
 };
-/**
- * A cell's own `data` prop (the PWA's projectDataBundle): its static values,
- * then each declared key read from the page context. Every declared key is
- * present, `undefined` while loading.
- */
 export declare function projectCellData(cell: PageCell, ctx: DataContext): {
     data: Record<string, unknown>;
     status: CellStatus;
 } | null;
-/**
- * The labels a cell reads whose query failed and left nothing (shell audit
- * S1): its declared data keys and the labels its props and conditions refer
- * to. A failed read must not render as an empty list. A query that never ran because a
- * reference resolved to nothing (a client-scoped read with no client in view, a page with no
- * data yet) hasn't failed: the cell renders without it, and the diagnostic says why.
- */
 export declare function failedLabels(cell: PageCell, data: DataContext): string[];
 export type AssembledInputs = {
     resolvedProps: Record<string, unknown>;
@@ -27,7 +15,6 @@ export type AssembledInputs = {
     baseProps: unknown;
     cellData: ReturnType<typeof projectCellData>;
     actions: Record<string, unknown> | undefined;
-    /** Paged labels the cell reads (apps.md §6), each with hasMore and loadMore. */
     paging?: Record<string, {
         hasMore: boolean;
         isLoadingMore: boolean;
@@ -45,11 +32,4 @@ export type AssembledInputs = {
     context: Record<string, unknown>;
     renderComponent?: (key: string, props?: Record<string, unknown>) => unknown;
 };
-/**
- * The PWA's order (CellRenderer.tsx:973-989), so contract props win over
- * `cell.props`: props, children, isLoading / error, baseProps, data / status,
- * actions, the store bundles; then what's new here: size, navigate, context
- * (design/core.md §4). `isLoading` / `error` come from the cell's own data,
- * not, as in the PWA, from whichever page key came first.
- */
 export declare function assembleCellProps(i: AssembledInputs): Record<string, unknown>;

package/dist/types/core/cells.d.ts

@@ -1,39 +1,18 @@
 import type { Diagnostic } from './graph.js';
 import type { PageCell } from './types.js';
-/** The config fields a thin ref took from its DSNS (the PWA's HYDRATED_CELL_FIELDS, which the agency's publish mirrors). */
 export declare const HYDRATED_CELL_FIELDS: readonly ["component", "props", "layout", "conditions", "children", "traversal", "data", "bundle_ref", "actions", "embed"];
-/** Also kept, unlike the PWA, whose hydration and publish dropped them (design/core.md §3). */
 export declare const STORE_FIELDS: readonly ["selections", "viewState", "live"];
-/** What a ref's node owns: everything but the cell's placement. A field its config sets wins, as a whole. */
 export declare const CONTENT_FIELDS: readonly [...("data" | "component" | "props" | "conditions" | "children" | "traversal" | "bundle_ref" | "actions" | "embed")[], "selections", "viewState", "live"];
-/** Where a rendered cell's content came from. */
 export type CellSource = 'inline' | 'node' | 'fallback' | 'pending';
-/** A cell as the renderer reads it: its content resolved, `graph_node_id` its own node (if any). */
 export type ResolvedCell = PageCell & {
     source: CellSource;
 };
-/**
- * The one place the authored forms are read (design/renderer.md §3.1):
- *   1 inline; 2 inline with a `ref`; 3 `{ id, graph_node_id }` (legacy thin ref,
- *   read as 2); 4 inline with a `graph_node_id` (legacy, read as 1, walking
- *   from that node). Legacy forms are reported, so their use can be counted.
- */
 export declare function normalizeCell(cell: PageCell, path?: string): {
     cell: PageCell;
     diagnostics: Diagnostic[];
 };
-/** Whether a (normalized) cell's content is managed by a node. */
 export declare const hasRef: (cell: PageCell) => cell is PageCell & {
     ref: NonNullable<PageCell["ref"]>;
 };
-/**
- * A normalized cell with its node's `page_cell_config` (design/renderer.md §3.2):
- * - the node owns the content (CONTENT_FIELDS): a field the config sets wins;
- * - the page owns the placement: `id`, and `layout` when the entry has one;
- * - `name` from the entry if it has one; `metadata` merged, entry then config;
- * - no config: the entry renders as it is when it names a component
- *   (`fallback`), else the cell is `pending`.
- */
 export declare function resolveCell(cell: PageCell, config: Record<string, unknown> | null | undefined): ResolvedCell;
-/** Cells no other cell lists in `children`: what a flat page renders, in content order. */
 export declare function rootCells<T extends PageCell>(cells: T[]): T[];

package/dist/types/core/data-context.d.ts

@@ -2,48 +2,26 @@ import { type NodeBinding, type NodeRecord, type QueryDescriptor, type StateName
 import { readField, type Diagnostic, type ProcessSystems } from './graph.js';
 export { readField };
 import type { DataContext, ProjectPage } from './types.js';
-/** A system a declaration reads: by name from the page's process, or named outright by id. */
 export type StateRead = {
     name?: StateName;
     systemId: string;
 };
-/** A declaration with the systems it reads, in merge order. */
 export type ResolvedDeclaration = NodeBinding & {
     reads: StateRead[];
 };
-/**
- * Declarations (`data.queries`) with the systems each reads: `system_id`
- * outright, else its `state` names (default `eng_data`) through the page's
- * systems. Only node bindings: a retired registry binding is left to
- * validation. A declaration none of whose systems exist
- * is dropped, with a diagnostic.
- */
 export declare function resolveDeclarations(queries: Record<string, unknown> | undefined, systems: ProcessSystems, diagnostics?: Diagnostic[], cellId?: string): Record<string, ResolvedDeclaration>;
-/** The inline descriptors among declarations (`{ descriptor }`), by label (design/data.md §3). */
 export declare function collectDescriptors(queries: Record<string, unknown> | undefined): Record<string, QueryDescriptor>;
-/** The page's own declarations (`content.data.queries`), which every cell sees. */
 export declare const collectDeclarations: (page: ProjectPage, systems: ProcessSystems, diagnostics?: Diagnostic[]) => Record<string, ResolvedDeclaration>;
-/** The page's static values (`content.data.static`), which every cell sees. */
 export declare function collectStatic(page: ProjectPage): Record<string, unknown>;
-/**
- * The page-wide DataContext: static, then declared on top. A declared label
- * whose producer has no state resolves to null. `states` is keyed
- * `<system_id>/<graph_node_id>`; `records` holds the NodeRecords for
- * `as: 'record'` declarations, by graph node id. Traversal is per cell
- * (the cell's walk; design/renderer.md §5.2), not part of this context.
- */
 export declare function buildDataContext(input: {
     static: Record<string, unknown>;
     declared: Record<string, ResolvedDeclaration>;
     states: Map<string, unknown>;
     records?: Record<string, NodeRecord>;
-    /** The id of each newest state, keyed as `states`: where an edit of a declared value goes (INV-DOC-6). */
     stateIds?: Map<string, string>;
-    /** What version each state was read at (StateRow), by `system/node`, when the page was read at one. */
     stateVersions?: Map<string, {
         versionId: string | null;
         outOfScope: boolean;
     }>;
-    /** Whose static values these are: the page's (the default) or a cell's. */
     staticScope?: 'page' | 'cell';
 }): DataContext;

package/dist/types/core/diagnostics.d.ts

@@ -1,7 +1,5 @@
 export type DiagnosticEntry = {
-    /** What the diagnostic means, in a sentence. */
     meaning: string;
-    /** What to change. */
     fix: string;
 };
 export declare const DIAGNOSTICS: {
@@ -111,7 +109,7 @@ export declare const DIAGNOSTICS: {
     };
     readonly UNSUPPORTED_REGISTRY_BINDING: {
         readonly meaning: "A binding names a registry query (`{ registry: \"x.y\" }`) from the retired host contract.";
-        readonly fix: "Copy the matching recipe’s descriptor into `{ descriptor }` (the component’s pattern pack has it), or bind the graph node that produces the data. docs/plan/host-contract-verdicts.md maps every id.";
+        readonly fix: "Copy the matching recipe’s descriptor into `{ descriptor }` (the component’s pattern pack has it), or bind the graph node that produces the data.";
     };
     readonly STATE_UNKNOWN_NAME: {
         readonly meaning: "A state name is not `<tier>_<role>`.";

package/dist/types/core/graph.d.ts

@@ -1,81 +1,37 @@
 import { type EdgeRecord, type NodeRecord, type StateName, type StateRecord, type Traversal, type TraversalConfig } from '@peripheries/runtime';
 import type { DiagnosticCode } from './diagnostics.js';
 import type { PageCell } from './types.js';
-/** The page's systems by name, from its process's graphs (and, for eng_data, the page's metadata fallback). */
 export type ProcessSystems = Partial<Record<StateName, string>>;
-/**
- * A main, keyless system on one of a process's graphs, as GraphSource.graphSystems returns it:
- * the graph's `graph_type` (its tier) and the system's layer role (`system_layer.role`; null for
- * a layer that isn't a role, such as `edits`).
- */
 export type GraphSystem = {
     id: string;
     graph_type: string | null;
     role: string | null;
 };
-/**
- * A process's systems by name from its graphs (systems.md §3: the tier is `graph.graph_type`, the
- * role the layer's): every registered layer with a role, not only the four the process columns
- * cache. A layer without a role, or a graph of another type, has no name.
- */
 export declare function systemsFromGraphs(rows: readonly GraphSystem[] | null | undefined): ProcessSystems;
-/**
- * Something wrong with a page's configuration (design/renderer.md §7). Codes
- * are stable, so tools can explain them; `legacy` marks a form still read but
- * on its way out.
- */
 export type Diagnostic = {
     severity: 'error' | 'warning' | 'legacy';
-    /** One of DIAGNOSTICS' keys, which says what it means and how to fix it. */
     code: DiagnosticCode;
     message: string;
-    /** Where in the page, e.g. `content.cells[3].traversal`. */
     path?: string;
     cellId?: string;
     label?: string;
-    /** The nearest names in scope, for a name that isn't there (CELL_UNKNOWN_COMPONENT). */
     suggestions?: string[];
 };
-/** A process row's system columns, `<tier>_<role>_system_id`, as names. */
 export declare function systemsFromProcess(row: Record<string, unknown> | null | undefined): ProcessSystems;
-/** The state names a read asks for, in order, duplicates dropped; the default when it names none. */
 export declare function stateNames(state: unknown): {
     names: StateName[];
     unknown: string[];
 };
-/** A value at a dot-path: the whole value without one. */
 export declare function readField(state: unknown, field?: string): unknown;
-/**
- * Several systems' data for one node, merged in order, later winning: plain
- * objects key by key, anything else replaces. `undefined` when none had any,
- * so "not loaded" and "empty" differ.
- */
 export declare function mergeStates(values: readonly unknown[]): unknown;
-/** The named states of a NodeRecord, merged, then `field`. */
 export declare function stateValue(state: NodeRecord['state'], names: readonly StateName[], field?: string): unknown;
 export type WalkStart = {
     graphNodeId: string;
     kind: 'cell' | 'page';
 };
-/** A cell's own node (a thin ref's, or an inline cell's `graph_node_id`), else the page node (agency doc 17). */
 export declare function resolveWalkStart(cell: Pick<PageCell, 'graph_node_id' | 'metadata'>, pageGraphNodeId: string | null | undefined): WalkStart | null;
-/**
- * Labels no declaration or walk can take: the cell's walk, the route's
- * parameters, the host's props, the viewer and the location (design/data.md
- * §5); `input` (an action's argument) and `scope` (the apps release) are kept free.
- */
 export declare const RESERVED_LABELS: readonly ["_traversal", "params", "baseProps", "viewer", "context", "input", "scope"];
-/**
- * Every data label a cell's props and conditions read with a whole-string
- * `@label…` reference. Inside an `@each` projection's `map`, its element's
- * label (`as`) is the projection's own, not the page's.
- */
 export declare function referencedLabels(cell: Pick<PageCell, 'props' | 'conditions'>): Set<string>;
-/**
- * Whether a cell's walk has anything to give it (design/renderer.md §5.2): it
- * reads `@_traversal`, or a label nothing explicit provides. Declarations win
- * over what a walk finds, so a walk whose labels are all declared changes nothing.
- */
 export declare function needsWalk(cell: PageCell, explicit: ReadonlySet<string>): boolean;
 export type WalkRequest = {
     start: WalkStart;
@@ -84,7 +40,6 @@ export type WalkRequest = {
     nodeTypes: string[] | null;
     maxDepth: number;
     maxNodes: number;
-    /** The state names asked for, and the system each resolves to. */
     states: Array<{
         name: StateName;
         systemId: string;
@@ -92,14 +47,11 @@ export type WalkRequest = {
     excludeNodeTypes: string[] | null;
     excludeEdgeTypes: string[] | null;
 };
-/** A cell's walk as a request, or why it can't run. */
 export declare function walkRequest(config: TraversalConfig, start: WalkStart, systems: ProcessSystems): {
     request?: WalkRequest;
     diagnostics: Omit<Diagnostic, 'cellId'>[];
 };
-/** One walk per distinct question: cells asking the same one from the same start share it. */
 export declare const walkKey: (r: WalkRequest) => string;
-/** What walk_graph returns: nodes with their states keyed by system id. */
 export type RawWalk = {
     nodes: Array<Omit<NodeRecord, 'state'> & {
         state: Record<string, StateRecord | null>;
@@ -112,12 +64,6 @@ export type WalkBinding = {
     graph_node_id: string;
     field?: string;
 };
-/**
- * A walk's result for its cells: `@_traversal` (NodeRecords with states by
- * name, noise stripped, edges only between what's left), and the labels its
- * `binding_key` nodes provide. Two nodes with one key is a diagnostic, and
- * neither binds.
- */
 export declare function readWalk(raw: RawWalk, request: WalkRequest): {
     traversal: Traversal;
     bindings: WalkBinding[];

package/dist/types/core/index.d.ts

@@ -1,6 +1,7 @@
 export { CONTENT_FIELDS, hasRef, HYDRATED_CELL_FIELDS, normalizeCell, resolveCell, rootCells, STORE_FIELDS, type CellSource, type ResolvedCell } from './cells.js';
 export { buildDataContext, collectDeclarations, collectDescriptors, collectStatic, readField, resolveDeclarations, type ResolvedDeclaration, type StateRead } from './data-context.js';
 export { mergeStates, needsWalk, readWalk, referencedLabels, RESERVED_LABELS, resolveWalkStart, stateNames, stateValue, systemsFromGraphs, systemsFromProcess, walkKey, walkRequest, type Diagnostic, type GraphSystem, type ProcessSystems, type RawWalk, type WalkBinding, type WalkRequest, type WalkStart, } from './graph.js';
+export { LAYER_ROLES, layerName, type LayerType } from './layers.js';
 export { loadPageData, resolveDataSystem, resolveSystems, type CellData, type CellWalk, type GraphSource, type NodeRecordRow, type PageRuntime, type PageScope, type QueryPage, type ReadContext, type StateRow } from './load-page.js';
 export { descriptorShape, orderByVariable, PAGING_VARIABLES, pageVariables, prepareDocument, queryKey, RENDER_FUNCTIONS, RENDER_FUNCTIONS_AHEAD, resolveDescriptorVariables, selectionShape, shapeAt, UnsafeDocumentError, validateDescriptor, VARIABLE_NAMESPACES, variableLabels, variableReferences, type PreparedDocument, type ResolvedVariables, type SelectionShape, } from './query.js';
 export { selectionIssues } from './selected.js';

package/dist/types/core/layers.d.ts

@@ -0,0 +1,8 @@
+import { LAYER_ROLES, type LayerType } from './layers.gen.js';
+export { LAYER_ROLES, type LayerType };
+export declare function layerName(s: {
+    system_type: string | null;
+    system_layer?: {
+        role: string | null;
+    } | null;
+}): string | null;

package/dist/types/core/layers.gen.d.ts

@@ -0,0 +1,12 @@
+export declare const LAYER_ROLES: {
+    readonly answer: null;
+    readonly "appraisal-system": "appraisal";
+    readonly "data-system": "data";
+    readonly edits: null;
+    readonly "model-system": "model";
+    readonly organisation: null;
+    readonly "process-system": "process";
+    readonly question: null;
+    readonly submission: null;
+};
+export type LayerType = keyof typeof LAYER_ROLES;

package/dist/types/core/layout.d.ts

@@ -1,15 +1,6 @@
 import type { CSSProperties } from 'react';
 import type { CellLayout, PageCell } from './types.js';
-/** The page container (the PWA's ProjectPageRenderer): stack by default; grid of `columns` (12); flex. */
 export declare function pageContainerStyle(layout: Record<string, unknown> | null | undefined): CSSProperties;
-/** A cell's placement in the page grid; a nested cell gets none. */
 export declare function cellPlacementStyle(layout: CellLayout | undefined): CSSProperties;
-/** Hooks for CSS: the renderer's responsive rules (styles.css) and bundles read these names (design/bundles.md §6). */
 export declare function cellAttributes(cell: PageCell): Record<string, string>;
-/**
- * A document page's profile (`layout.profile`), set as `data-profile` on the
- * page container so the document kit's `--doc-*` tokens resolve for it
- * (design/core-and-tokens.md §6.5). Only a document page has one, and only a
- * slug: the value becomes an attribute.
- */
 export declare function documentProfile(layout: Record<string, unknown> | null | undefined): string | undefined;

package/dist/types/core/load-page.d.ts

@@ -2,15 +2,9 @@ import { type EmbedSelector, type NodeRecord, type QueryDescriptor, type StateRe
 import { type ResolvedCell } from './cells.js';
 import { type Diagnostic, type GraphSystem, type ProcessSystems, type RawWalk, type WalkRequest } from './graph.js';
 import type { DataContext, DataEntry, ProjectPage } from './types.js';
-/**
- * The version a read is made at (versions.md §5.1): a release, a channel or a branch id, opaque
- * to the renderer. Passed as each read's last argument only when the page isn't read at main, so
- * a source that takes no context reads main, as before.
- */
 export type ReadContext = {
     versionId: string;
 };
-/** A state row as a source returns it; the version fields when it was read at a version (StateAsOf). */
 export type StateRow = {
     id: string;
     data: unknown;
@@ -18,105 +12,40 @@ export type StateRow = {
     unversioned?: boolean;
     outOfScope?: boolean;
 };
-/** A NodeRecord as a source returns it: its states keyed by system id. */
 export type NodeRecordRow = Omit<NodeRecord, 'state'> & {
     stateBySystem: Record<string, StateRecord | null>;
 };
-/**
- * Where a page's graph data comes from (design/renderer.md §6). The host's
- * reads GraphQL under the viewer's JWT; the harness's reads fixtures; the
- * agency's reads its own client. Every method may cache.
- */
 export interface GraphSource {
-    /**
-     * The main, keyless systems on a process's graphs, with each graph's type and each layer's role
-     * (systems.md §3): how a page finds its systems, any registered layer included. Optional for
-     * 0.22 sources, which have `processSystems`; G4 drops the process columns, so a source needs this
-     * by then.
-     */
     graphSystems?(processId: string): Promise<GraphSystem[]>;
-    /**
-     * The process row: its `<tier>_<role>_system_id` columns, a cache of the four role layers.
-     * Read only by a source without `graphSystems`.
-     */
     processSystems?(processId: string): Promise<Record<string, unknown> | null>;
-    /** The newest `page_cell_config` of each cell node in a system. */
     cellConfigs(systemId: string, graphNodeIds: string[], context?: ReadContext): Promise<Record<string, Record<string, unknown> | null>>;
-    /** The newest state's data of each node in a system; missing nodes absent. */
     latestStates(systemId: string, graphNodeIds: string[], context?: ReadContext): Promise<Record<string, unknown>>;
-    /**
-     * The same, with each state's id: what a content edit's version check names (INV-DOC-6).
-     * Optional: without it, declared values carry no state id, and can't be edited.
-     */
     latestStateRows?(systemId: string, graphNodeIds: string[], context?: ReadContext): Promise<Record<string, StateRow>>;
     walk(request: WalkRequest, context?: ReadContext): Promise<RawWalk>;
     nodeRecords(graphNodeIds: string[], systemIds: string[], context?: ReadContext): Promise<Record<string, NodeRecordRow>>;
-    /**
-     * A query, as the viewer, its result shaped by the descriptor's `result`
-     * (design/data.md §6). Variables are resolved, `$orderBy` included. The
-     * host runs it through prepareDocument; a harness answers from fixtures
-     * keyed by the operation's name.
-     */
     query(descriptor: QueryDescriptor, variables: Record<string, unknown>): Promise<unknown>;
-    /**
-     * One page of a paged descriptor (QueryDescriptor.paging): the connection at
-     * `result.path`, its nodes shaped as `query` shapes them, and its pageInfo.
-     * Optional: without it a paged label loads its first page through `query`,
-     * with no more to load.
-     */
     queryPage?(descriptor: QueryDescriptor, variables: Record<string, unknown>): Promise<QueryPage>;
-    /**
-     * Of these systems, the main ones (`system.version` null; versions.md §4.6, graph-model G1):
-     * a page reads main only, so a branch system a ref, a declaration or a walk names is read as
-     * absent (SYSTEM_NOT_MAIN). Optional: without it, every system named is read.
-     */
     mainSystems?(systemIds: string[]): Promise<ReadonlySet<string>>;
-    /**
-     * The page an embed cell names (PageCell.embed, resolved), as the viewer:
-     * by id, or the newest published of a type in a project. Null when none is
-     * readable. Optional: without it, embed cells report EMBED_NOT_FOUND.
-     */
     page?(selector: EmbedSelector, context?: ReadContext): Promise<ProjectPage | null>;
 }
-/** One page of a paged label. */
 export type QueryPage = {
     items: unknown[];
     hasMore: boolean;
     endCursor: string | null;
 };
-/** What a page's queries may read besides labels (design/data.md §5). */
 export type PageScope = {
     params?: Record<string, unknown>;
     baseProps?: unknown;
-    /** The signed-in person: `userId`, `isAdvisor`, `isClient`… */
     viewer?: unknown;
-    /** The host's location context (core.md §8); the page's own ids are added. */
     context?: Record<string, unknown>;
-    /** Set when loading an embedded page: its own embeds don't load. */
     embedded?: boolean;
-    /**
-     * The version the page is read at (versions.md §6.3), resolved by the host: every read takes it,
-     * and `@context.version` / `@context.versionKind` name it. Absent or main: today's reads.
-     */
     version?: VersionContext;
-    /**
-     * When the page is read at a release, the release it recorded for each page it embeds (its
-     * `metadata.embeds`, from versions_for; versions.md §5.3): an embed renders that release, and
-     * one not recorded renders at the viewer's context.
-     */
     recordedEmbeds?: RecordedEmbed[];
 };
-/** A cell's own walk: `@_traversal`, and the labels its `binding_key` nodes provide. */
 export type CellWalk = {
     traversal: Traversal;
     labels: DataContext;
 };
-/**
- * A cell's own data (design/renderer.md §5.2): its static values, its
- * declarations (inline, or from its ref's config) and its walk. A cell
- * resolves against, lowest first: static (the page's, then its own), its
- * walk, the page's declarations, its own declarations.
- */
 export type CellData = {
     static: DataContext;
     declared: DataContext;
@@ -124,63 +53,23 @@ export type CellData = {
 };
 export type PageRuntime = {
     page: ProjectPage;
-    /** Every cell, its content resolved: inline as written, a ref's from its node (or its fallback). */
     cells: ResolvedCell[];
-    /** Ref cells with neither a node config nor a component of their own: rendered as pending. */
     unresolved: string[];
-    /** The page's static values, then its declarations on top: what every cell sees. */
     data: DataContext;
-    /** Labels the page declares: a walk's label of the same name never replaces them. */
     declared: string[];
-    /** Each cell's own data, by cell id (only cells that have some). */
     cellData: Record<string, CellData>;
     systems: ProcessSystems;
     engDataSystemId: string | null;
-    /**
-     * Every graph node the page reads: its own, its cells', its producers', its
-     * walks' starts. Their graphs are the Realtime topics the page joins
-     * (design/data.md §10).
-     */
     graphNodeIds: string[];
-    /** The version the page was read at; absent at main. */
     version?: VersionContext;
-    /**
-     * The versions the page's states were read from, at a version (each row's `version_id`; nodes
-     * outside the scope left out): what print and an embed say they show ("Release N"). Absent at
-     * main, or when the source returns no rows with versions.
-     */
     readVersionIds?: string[];
-    /** An embedded page's version: the release its host recorded for it, or the viewer's context. */
     embedVersion?: 'recorded' | 'context';
-    /** Each embed cell's page, loaded as the viewer (null when not found), by cell id. */
     embeds?: Record<string, PageRuntime | null>;
     diagnostics: Diagnostic[];
 };
 type SystemsSource = Pick<GraphSource, 'graphSystems' | 'processSystems'>;
-/**
- * A page's systems by name: the main systems on its process's graphs (`graphSystems`; a 0.22
- * source's process columns otherwise), with `metadata.systemGraph` as eng_data's fallback for a
- * page without a process. `metadata.pageProcess`, a copy of the process columns, isn't read: G4
- * drops the columns it copies.
- */
 export declare function resolveSystems(source: SystemsSource, page: ProjectPage): Promise<ProcessSystems>;
-/** The page's DSNS: what thin refs hydrate from and what declarations read by default. */
 export declare function resolveDataSystem(source: SystemsSource, page: ProjectPage): Promise<string | null>;
-/**
- * Everything a page needs before it renders (design/core.md §3, stages 1–3;
- * design/renderer.md §3, §5; design/data.md §6): read every ref's node config
- * (one read per system), then every declaration's producer (one read per
- * system), every walk a cell needs, any NodeRecords, and the queries whose
- * variables read no label, in parallel; then the queries whose variables read
- * a label, and those found in live query nodes. Framework-free: the source
- * decides how each read runs (the host's runs in its route loader, through
- * TanStack Query, under the viewer's JWT).
- */
-/**
- * A query that didn't run because references resolved to nothing. It has nothing to show yet
- * (`unresolved`) only when every reference is simply absent; one into a label whose read failed
- * is that failure (shell audit S1), not an empty result.
- */
 export declare function unresolvedEntry(missing: string[], data: DataContext): DataEntry;
 export declare function loadPageData(page: ProjectPage, source: GraphSource, scope?: PageScope): Promise<PageRuntime>;
 export {};