@peripheries/renderer 0.22.0 → 0.23.1

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

@@ -2,43 +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>;
-    /** Whose static values these are: the page's (the default) or a cell's. */
+    stateVersions?: Map<string, {
+        versionId: string | null;
+        outOfScope: boolean;
+    }>;
     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,14 +109,14 @@ 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 one of the twelve systems.";
-        readonly fix: "Use `<tier>_<role>`: tier meta, eng or ops; role data, process, model or appraisal (default `eng_data`).";
+        readonly meaning: "A state name is not `<tier>_<role>`.";
+        readonly fix: "Use `<tier>_<role>`: tier meta, eng or ops; role a registered layer’s role (data, process, model, appraisal, or another such as answer); default `eng_data`.";
     };
     readonly STATE_UNKNOWN_SYSTEM: {
-        readonly meaning: "The page’s process has no system of that name.";
+        readonly meaning: "The page’s process has no main system of that name on its graphs.";
         readonly fix: "Read a system the process has, usually `eng_data`.";
     };
     readonly LABEL_RESERVED: {
@@ -133,6 +131,14 @@ export declare const DIAGNOSTICS: {
         readonly meaning: "The document isn’t one query operation that reads only tables, views and the render functions.";
         readonly fix: "Write one `query`, whose root fields are `<table>Collection`, `<table>ByPk`, `node` or a render function such as `walk_graph`; no mutations, RPCs or introspection.";
     };
+    readonly DESCRIPTOR_VERSION_FILTER: {
+        readonly meaning: "The document filters `systemCollection`, `graph_nodeCollection` or `graph_edgeCollection` on `version`, or passes their whole filter as a variable. A page reads main systems and placements only, and the host adds that filter itself.";
+        readonly fix: "Drop the `version` filter and write the filter in the document; a branch is read through a version context.";
+    };
+    readonly DESCRIPTOR_STATE_UNSCOPED: {
+        readonly meaning: "The document reads states, runs or a latest-state view by node or with no filter, so it would read every system’s rows, a branch’s included.";
+        readonly fix: "Read them under a `systemCollection`, or filter `system_id` (or the id, or the run) with `eq` or `in`; for the latest state across systems, use a render function.";
+    };
     readonly DESCRIPTOR_VARIABLE_MISSING: {
         readonly meaning: "The document requires a variable that `variables` doesn’t give.";
         readonly fix: "Give it in `variables`, as a literal or a reference (`@params.clientId`, `@viewer.userId`, `@budget.graph_node_id`); `$orderBy` comes from `order_by`.";
@@ -149,6 +155,10 @@ export declare const DIAGNOSTICS: {
         readonly meaning: "`order_by` is set, but the document declares no `$orderBy`, so it is ignored.";
         readonly fix: "Declare `$orderBy: [<table>OrderBy!]` and pass `orderBy: $orderBy`, or remove `order_by`.";
     };
+    readonly DESCRIPTOR_ALIAS_JSON_ROOT: {
+        readonly meaning: "A render function that returns JSON is aliased at the root; its JSON is decoded by the field’s name, so under an alias it stays a string.";
+        readonly fix: "Name the field without an alias (`form_answers(...)`, not `answers: form_answers(...)`) and point `result.path` at it.";
+    };
     readonly DESCRIPTOR_RESULT_PATH: {
         readonly meaning: "`result.path` names a part of the result the document doesn’t select.";
         readonly fix: "Point it at a selected field (its alias, if it has one), e.g. `clientCollection`.";
@@ -205,6 +215,10 @@ export declare const DIAGNOSTICS: {
         readonly meaning: "`nodeTypes: []` filters nothing.";
         readonly fix: "Leave `nodeTypes` out, or name the types the walk may enter.";
     };
+    readonly SYSTEM_NOT_MAIN: {
+        readonly meaning: "A ref, a declaration or a walk names a system that isn’t a main system (a branch’s, or one the viewer can’t read); a page reads main systems only, so its states read as absent.";
+        readonly fix: "Name the process’s main system (or none, for the page’s DSNS); a branch is read through a version context, not a system id.";
+    };
     readonly WALK_NO_START: {
         readonly meaning: "A cell has a traversal, but neither it nor the page has a graph node to start from.";
         readonly fix: "Publish the page with its graph node, or give the cell a node.";

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

@@ -1,65 +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 (and, for eng_data, the page's metadata fallbacks). */
 export type ProcessSystems = Partial<Record<StateName, string>>;
-/**
- * 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 GraphSystem = {
+    id: string;
+    graph_type: string | null;
+    role: string | null;
+};
+export declare function systemsFromGraphs(rows: readonly GraphSystem[] | null | undefined): ProcessSystems;
 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;
@@ -68,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;
@@ -76,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>;
@@ -96,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,8 +1,8 @@
 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, systemsFromProcess, walkKey, walkRequest, type Diagnostic, type ProcessSystems, type RawWalk, type WalkBinding, type WalkRequest, type WalkStart, } from './graph.js';
-export { loadPageData, resolveDataSystem, resolveSystems, type CellData, type CellWalk, type GraphSource, type NodeRecordRow, type PageRuntime, type PageScope, type QueryPage } from './load-page.js';
-export { descriptorShape, orderByVariable, PAGING_VARIABLES, pageVariables, prepareDocument, queryKey, RENDER_FUNCTIONS, resolveDescriptorVariables, selectionShape, shapeAt, UnsafeDocumentError, validateDescriptor, VARIABLE_NAMESPACES, variableLabels, variableReferences, type PreparedDocument, type ResolvedVariables, type SelectionShape, } from './query.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 { 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';
 export { cellPropSources, editTarget, patchAt, STRUCTURE_FIELDS, TOOL_OWNED_KEYS, type EditCell, type EditRefusal, type EditTarget, type OnSource, type PropSource, type PropSourceEntry } from './sources.js';
 export { cellContext, cellResolutionContext, EACH, pageContext, EACH_DEFAULT_AS, isEach, passesConditions, resolveReferences, settled, type CellScope, type Each, type ResolutionContext } from './references.js';
@@ -25,3 +25,4 @@ export { clearScope, loadScope, saveScope, type StorageMode } from './store/pers
 export { attachSelectionSetters, attachViewStateSetters, collectScopeIds, projectLive, projectSelections, projectViewState, shallowEqualBundle } from './store/projection.js';
 export { pageScopeKey, projectScopeKey, resolveScopeId, type ScopeContext } from './store/scope-keys.js';
 export type * from './store/types.js';
+export { manifestPageFrom, validateManifest, type ManifestPage } from './release.js';

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

@@ -1,82 +1,51 @@
-import { type EmbedSelector, type NodeRecord, type QueryDescriptor, type StateRecord, type Traversal } from '@peripheries/runtime';
+import { type EmbedSelector, type NodeRecord, type QueryDescriptor, type StateRecord, type RecordedEmbed, type Traversal, type VersionContext } from '@peripheries/runtime';
 import { type ResolvedCell } from './cells.js';
-import { type Diagnostic, type ProcessSystems, type RawWalk, type WalkRequest } from './graph.js';
+import { type Diagnostic, type GraphSystem, type ProcessSystems, type RawWalk, type WalkRequest } from './graph.js';
 import type { DataContext, DataEntry, ProjectPage } from './types.js';
-/** A NodeRecord as a source returns it: its states keyed by system id. */
+export type ReadContext = {
+    versionId: string;
+};
+export type StateRow = {
+    id: string;
+    data: unknown;
+    versionId?: string | null;
+    unversioned?: boolean;
+    outOfScope?: boolean;
+};
 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 process row: its `<tier>_<role>_system_id` columns. */
-    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[]): 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[]): 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[]): Promise<Record<string, {
-        id: string;
-        data: unknown;
-    }>>;
-    walk(request: WalkRequest): Promise<RawWalk>;
-    nodeRecords(graphNodeIds: string[], systemIds: string[]): 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.
-     */
+    graphSystems?(processId: string): Promise<GraphSystem[]>;
+    processSystems?(processId: string): Promise<Record<string, unknown> | null>;
+    cellConfigs(systemId: string, graphNodeIds: string[], context?: ReadContext): Promise<Record<string, Record<string, unknown> | null>>;
+    latestStates(systemId: string, graphNodeIds: string[], context?: ReadContext): Promise<Record<string, unknown>>;
+    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>>;
     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>;
-    /**
-     * 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): Promise<ProjectPage | null>;
+    mainSystems?(systemIds: string[]): Promise<ReadonlySet<string>>;
+    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;
+    version?: VersionContext;
+    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;
@@ -84,50 +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[];
-    /** Each embed cell's page, loaded as the viewer (null when not found), by cell id. */
+    version?: VersionContext;
+    readVersionIds?: string[];
+    embedVersion?: 'recorded' | 'context';
     embeds?: Record<string, PageRuntime | null>;
     diagnostics: Diagnostic[];
 };
-/**
- * A page's systems by name: its process's twelve system columns, with the two
- * denormalised copies in metadata as eng_data's fallbacks (the PWA's
- * eng-data-system-id.ts order: the process, pageProcess, systemGraph).
- */
-export declare function resolveSystems(source: Pick<GraphSource, 'processSystems'>, page: ProjectPage): Promise<ProcessSystems>;
-/** The page's DSNS: what thin refs hydrate from and what declarations read by default. */
-export declare function resolveDataSystem(source: Pick<GraphSource, 'processSystems'>, 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.
- */
+type SystemsSource = Pick<GraphSource, 'graphSystems' | 'processSystems'>;
+export declare function resolveSystems(source: SystemsSource, page: ProjectPage): Promise<ProcessSystems>;
+export declare function resolveDataSystem(source: SystemsSource, page: ProjectPage): Promise<string | null>;
 export declare function unresolvedEntry(missing: string[], data: DataContext): DataEntry;
 export declare function loadPageData(page: ProjectPage, source: GraphSource, scope?: PageScope): Promise<PageRuntime>;
+export {};

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

@@ -1,41 +1,23 @@
 import { type QueryDescriptor, type QueryOrderBy } from '@peripheries/runtime';
 import type { Diagnostic } from './graph.js';
 import { type ResolutionContext } from './references.js';
-/**
- * Functions a render-time document may read, with the tables each reads (for
- * invalidation). pg_graphql reflects every stable function the role can run
- * as a Query field, and many are SECURITY DEFINER, so a function is allowed
- * only by name, once a database test has pinned it as stable, SECURITY
- * INVOKER, closed to anon and with a fixed search_path
- * (tests/integration/graph-reads.test.ts).
- */
 export declare const RENDER_FUNCTIONS: Readonly<Record<string, readonly string[]>>;
+export declare const RENDER_FUNCTIONS_AHEAD: Readonly<Record<string, string>>;
 export type PreparedDocument = {
     text: string;
     operationName: string | undefined;
-    /** Root entity names, e.g. `project_page` for `project_pageCollection`; `*` for `node`; a render function's tables. */
     entities: readonly string[];
-    /** Stable short hash of the prepared text; part of query keys. */
     hash: string;
 };
 export declare class UnsafeDocumentError extends Error {
     name: string;
+    readonly code?: 'DESCRIPTOR_VERSION_FILTER' | 'DESCRIPTOR_STATE_UNSCOPED';
+    constructor(message: string, options?: {
+        code: 'DESCRIPTOR_VERSION_FILTER' | 'DESCRIPTOR_STATE_UNSCOPED';
+    });
 }
-/**
- * A GraphQL document checked against the render-time rule (design/renderer.md
- * §4.5) and ready to send: exactly one `query` operation whose root fields are
- * table or view collections, `ByPk` reads, `node`, or a render function.
- * `__typename` is added to every nested selection, so a host can find JSON
- * columns in the result. Throws UnsafeDocumentError.
- */
+export declare const MAIN_ONLY_COLLECTIONS: ReadonlySet<string>;
 export declare function prepareDocument(source: string): PreparedDocument;
-/**
- * The shape of a query's result, from its selection alone (design/data.md
- * §2.1): a field without a selection set is a `leaf` (a scalar, a JSON column
- * or an array column, so any path below it may exist); `edges { node }` is a
- * list. With `flatten_connections`, a connection that selects edges is the
- * list of its nodes, as the host shapes it.
- */
 export type SelectionShape = {
     kind: 'leaf';
 } | {
@@ -45,53 +27,25 @@ export type SelectionShape = {
     kind: 'list';
     of: SelectionShape;
 };
-/** The shape a document's selection yields, before `result.path`. */
 export declare function selectionShape(document: string, flatten?: boolean): SelectionShape;
-/**
- * The shape at a dot path, or null when the selection doesn't select it. A
- * numeric segment indexes a list; anything below a leaf is accepted.
- */
 export declare function shapeAt(shape: SelectionShape, path: readonly string[]): SelectionShape | null;
-/** What a descriptor's label holds: its selection, flattened, at `result.path`. Null when the path isn't selected. */
 export declare function descriptorShape(descriptor: QueryDescriptor): SelectionShape | null;
-/** Namespaces a variable may read, besides labels (design/data.md §5). */
 export declare const VARIABLE_NAMESPACES: readonly ["params", "baseProps", "viewer", "context"];
-/** Every whole-string reference in a descriptor's variables, by the label or namespace it reads. */
 export declare function variableReferences(variables: unknown): Array<{
     ref: string;
     label: string;
 }>;
-/** The labels (not namespaces) a descriptor's variables read: what decides its round (design/data.md §5, §6). */
 export declare const variableLabels: (descriptor: Pick<QueryDescriptor, "variables">) => string[];
-/**
- * A descriptor's static checks (design/data.md §4): the version-1 shape, one
- * query operation under the render-time rule, every required variable given
- * (`$orderBy` by `order_by`), references well formed, and `result.path`
- * selected. It doesn't run anything; a dry run under a real viewer checks the
- * rest against the database. `path` prefixes each diagnostic's path.
- */
 export declare function validateDescriptor(descriptor: unknown, path?: string): Diagnostic[];
-/** `order_by` as pg_graphql's `orderBy` argument: `[{ updated_at: DescNullsLast }]`. */
 export declare const orderByVariable: (orderBy: readonly QueryOrderBy[]) => {
     [x: string]: string;
 }[];
 export type ResolvedVariables = {
     variables: Record<string, unknown>;
-    /** References that resolved to nothing (null or undefined): the query doesn't run (QUERY_UNRESOLVED). */
     unresolved: string[];
-    /** References whose data is still loading: the query waits. */
     pending: string[];
 };
-/**
- * A descriptor's variables, resolved with the one reference grammar (the same
- * resolver as props), plus `$orderBy` from `order_by` when the document
- * declares it. A whole-string reference that resolves to null or nothing is
- * unresolved; interpolation (`${x}`) works as in props.
- */
 export declare function resolveDescriptorVariables(descriptor: QueryDescriptor, ctx: ResolutionContext): ResolvedVariables;
-/** The variables a paged descriptor's document declares and the renderer sets. */
 export declare const PAGING_VARIABLES: ReadonlySet<string>;
-/** A paged descriptor's variables for one page: `$first` its size, `$after` the cursor (null for the first page). */
 export declare const pageVariables: (descriptor: QueryDescriptor, variables: Record<string, unknown>, after?: string | null) => Record<string, unknown>;
-/** One query per distinct question: the document and the resolved variables, and the result's shape. */
 export declare const queryKey: (descriptor: QueryDescriptor, variables: Record<string, unknown>) => string;

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

@@ -3,16 +3,11 @@ import type { DataContext } from './types.js';
 export type ResolutionContext = {
     data: DataContext;
     params: Record<string, unknown>;
-    /** Told of each whole-string `@ref` that resolves to nothing (a missing label, path or leaf), except while its data loads. */
     onUnresolved?: (ref: string) => void;
-    /** Told of each whole-string `@ref` whose data is still loading. */
     onLoading?: (ref: string) => void;
-    /** Told of each resolved leaf, by its prop path, with where its value came from (INV-DOC-6; sources.ts). */
     onSource?: OnSource;
 };
-/** The key that marks a projection: `{ "@each": "@label.path", "as": "item", "map": … }`. */
 export declare const EACH = "@each";
-/** The element's label inside `map` when `as` is not given. */
 export declare const EACH_DEFAULT_AS = "item";
 export type Each = {
     [EACH]: string;
@@ -20,17 +15,12 @@ export type Each = {
     map: unknown;
 };
 export declare const isEach: (value: unknown) => value is Each;
-/**
- * Resolve every string in a value, recursively through arrays and plain objects. Keys aren't
- * resolved. `at` is the value's path among the props, for `onSource`.
- */
 export declare function resolveReferences<T = unknown>(value: T, ctx: ResolutionContext, at?: string[]): T;
 export declare const settled: (data: unknown) => {
     data: unknown;
     isLoading: boolean;
     error: null;
 };
-/** What a cell brings to its own resolution (loadPageData's CellData), and the labels the page declares. */
 export type CellScope = {
     static?: DataContext;
     declared?: DataContext;
@@ -43,14 +33,6 @@ export type CellScope = {
     };
     pageDeclared?: ReadonlySet<string>;
 };
-/**
- * The context one cell resolves against (design/renderer.md §5.2), lowest
- * first: the page's static values, the cell's own static values, the labels
- * the cell's walk found, the page's declarations, the cell's own
- * declarations; then the reserved
- * `_traversal`, `params`, `baseProps`, `viewer` and `context`, which nothing
- * can shadow. Explicit beats discovered: no walk label replaces a declared one.
- */
 export declare function cellResolutionContext(_cell: {
     data?: {
         queries?: Record<string, unknown>;
@@ -59,7 +41,6 @@ export declare function cellResolutionContext(_cell: {
     viewer?: unknown;
     context?: unknown;
 }): ResolutionContext;
-/** The location context every cell on a page shares (core.md §8): the host's, with the page's own ids. */
 export declare const pageContext: (context: Record<string, unknown> | undefined, page: {
     id: string;
     project_id: string | null;
@@ -69,14 +50,12 @@ export declare const pageContext: (context: Record<string, unknown> | undefined,
     projectId: string | null;
     processId: string | null;
 };
-/** One cell's location context: the page's, with the cell's own node. */
 export declare const cellContext: (context: Record<string, unknown>, cell: {
     graph_node_id?: string;
     metadata?: Record<string, unknown>;
 }) => {
     nodeId: string | undefined;
 };
-/** showIf / hideIf: values (usually strict refs) tested for truthiness. An empty string skips the check. */
 export declare function passesConditions(conditions: {
     showIf?: unknown;
     hideIf?: unknown;

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

@@ -0,0 +1,11 @@
+import type { ReleaseProblem } from '@peripheries/runtime';
+import type { ProjectPage } from './types.js';
+import { type Catalog } from './validate.js';
+export type ManifestPage = {
+    graphNodeId: string;
+    page: Pick<ProjectPage, 'content' | 'layout'> & {
+        is_template?: boolean | null;
+    };
+};
+export declare function validateManifest(pages: ManifestPage[], catalog?: Catalog): ReleaseProblem[];
+export declare function manifestPageFrom(graphNodeId: string, data: unknown): ManifestPage;

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

@@ -1,3 +1,2 @@
-/** The page layout types `pageContainerStyle` and the structure renderer handle. */
 export declare const LAYOUT_TYPES: readonly ["stack", "grid", "flex", "document"];
 export declare const PAGE_RULES: string;

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

@@ -1,9 +1,4 @@
 import type { QueryDescriptor } from '@peripheries/runtime';
 import type { Diagnostic } from './graph.js';
 import type { PageCell } from './types.js';
-/**
- * The paths one cell's props and conditions read from the given query labels
- * that the queries don't select. Inside an `@each` over a query's list, the
- * element's paths are checked against the list's element. `at` prefixes paths.
- */
 export declare function selectionIssues(cell: Pick<PageCell, 'id' | 'props' | 'conditions'>, queries: Record<string, QueryDescriptor>, at: string): Diagnostic[];