@peripheries/renderer 0.23.0 → 0.23.1

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/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 {};

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

@@ -1,59 +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[]>>;
-/**
- * Render functions declared before the schema milestone that brings them, by milestone: a
- * document may name one now, and it reads nothing until the function exists. The database test
- * checks each like the rest once it exists, and fails if its milestone is in and it still isn't.
- */
 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;
-    /** The diagnostic a descriptor's check reports; DESCRIPTOR_DOCUMENT_INVALID when unset. */
     readonly code?: 'DESCRIPTOR_VERSION_FILTER' | 'DESCRIPTOR_STATE_UNSCOPED';
     constructor(message: string, options?: {
         code: 'DESCRIPTOR_VERSION_FILTER' | 'DESCRIPTOR_STATE_UNSCOPED';
     });
 }
-/**
- * The collections a render-time document reads main rows of only (versions.md §4.6, graph-model
- * G1 · DF M0): prepareDocument adds `version: { is: NULL }` to each one's filter, at any depth.
- * A branch is read through a version context, never a hand-written filter, so a document that
- * filters on `version` itself is refused.
- */
 export declare const MAIN_ONLY_COLLECTIONS: ReadonlySet<string>;
-/**
- * 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 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';
 } | {
@@ -63,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

@@ -1,21 +1,11 @@
 import type { ReleaseProblem } from '@peripheries/runtime';
 import type { ProjectPage } from './types.js';
 import { type Catalog } from './validate.js';
-/** One page the release records: the node it lives on (the anchor, or its artifact) and its document. */
 export type ManifestPage = {
     graphNodeId: string;
     page: Pick<ProjectPage, 'content' | 'layout'> & {
         is_template?: boolean | null;
     };
 };
-/** The pages' errors as VERSION_INVALID's problems: a release that has any isn't cut. Warnings don't stop one. */
 export declare function validateManifest(pages: ManifestPage[], catalog?: Catalog): ReleaseProblem[];
-/**
- * A page artifact's data state as a ManifestPage (pages.md §2): the artifact's `data` is the page
- * document itself (`cells`, `data`, page configuration such as `layout.editing`), each cell
- * carrying the `layout_entry` the publish splits into the row's `layout.structure`. So the
- * document is the content, and a `layout` key, when the artifact has one, the layout. The
- * structure isn't rebuilt from the entries (the publish's split), so STRUCTURE_INVALID is judged
- * at publish, not here.
- */
 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[];