@pipelex/mthds-form 0.8.0 → 0.10.0

package/dist/generative/index.d.ts

@@ -0,0 +1,2106 @@
+import * as _json_render_core from '@json-render/core';
+import { Spec, StateStore, StateModel } from '@json-render/core';
+import * as zod from 'zod';
+import { z } from 'zod';
+import { RunField } from '../core/descriptor.js';
+import * as react from 'react';
+import * as _json_render_react from '@json-render/react';
+import { Components, Renderer } from '@json-render/react';
+import * as zod_v4_core from 'zod/v4/core';
+import { F as FieldEnv } from '../field-renderer-BSU2hMf6.js';
+import '../core/contracts.js';
+import 'mthds/protocol';
+import '../core/file-formats.js';
+
+/**
+ * Whether a spec is one this catalog can render - the check every source
+ * passes, whoever wrote it.
+ *
+ * Three layers, because json-render's own `catalog.validate()` covers only the
+ * first two once a catalog has more than one component: it checks the element
+ * TYPE against the component names, but `propsOf` degrades to "any record"
+ * when several definitions could apply, so a misspelt or invented prop passes.
+ * The per-component prop check is therefore this module's, and it has to be
+ * expression-aware: a bound prop's raw value is `{ "$state": "/path" }`, which
+ * the component's own zod schema (`z.string()`) would reject, so a dynamic
+ * expression is accepted wherever the prop EXISTS and a literal is parsed
+ * against the prop's schema.
+ *
+ * The checks are the same whichever catalog a spec was written against; the
+ * catalog is a parameter, this entry's own by default, so a host that defines
+ * a vocabulary of its own is validated by the same code and not by a copy of
+ * it.
+ *
+ * What a component renders beyond its schema - the heading its title is, the
+ * landmark it renders as, the fixed number of children it lays out, the panel
+ * per entry of one of its props - is a fact about its renderer that no schema
+ * states, so the catalog carries it as `renders`, declared beside the
+ * definitions, and the validator reads it off the catalog it is handed rather
+ * than assuming it from a component's name, which a host's vocabulary may
+ * reuse for something that renders nothing of the kind. This entry's catalog
+ * declares its own; a host's declares what its renderers do, or nothing, and
+ * is then held only to what its schemas and its `Heading` elements say.
+ */
+/**
+ * What one component renders beyond what its props schema says, and what the
+ * validator holds a layout to on that account. Every member is optional: a
+ * component with none is held to its schema alone.
+ */
+interface ComponentRendering {
+    /**
+     * The heading its renderer emits, at this level - a `Hero`'s headline is
+     * the h1 - and, when it emits one only if a prop is set, the prop: a `Card`
+     * renders its `title` as an h3 and nothing when it has none.
+     */
+    heading?: {
+        level: 1 | 2 | 3 | 4;
+        when?: string;
+    };
+    /** What it renders as that a page has one of - a landmark, in the words a refusal uses: "the page's banner". */
+    once?: string;
+    /** The number of children its renderer lays out, dropping the rest in silence, and what they are. */
+    children?: {
+        count: number;
+        roles: string;
+    };
+    /** A panelled container: the prop that lists its panels, one child per entry, and what one is called. */
+    panels?: {
+        prop: string;
+        noun: string;
+    };
+}
+/** What the validator reads off a catalog: its names, its definitions, and what its components render. */
+interface ValidationCatalog {
+    componentNames: readonly string[];
+    /** The catalog's own action names. A `defineCatalog` result carries this already. */
+    actionNames?: readonly string[];
+    data: unknown;
+    /** The schema the catalog was defined against, for the actions its runtime handles without a handler. */
+    schema?: {
+        builtInActions?: readonly {
+            name: string;
+        }[];
+    };
+    /** What each component renders beyond its schema, by component name. Absent, no component renders a heading, a landmark or a fixed set of children. */
+    renders?: Readonly<Record<string, ComponentRendering>>;
+}
+interface SpecProblem {
+    elementKey?: string;
+    message: string;
+}
+interface SpecVerdict {
+    ok: boolean;
+    problems: SpecProblem[];
+}
+/**
+ * Whether a spec is one this catalog can render.
+ *
+ * The checks live in `checkAgainstCatalog`; this is the boundary that keeps the
+ * documented promise around them - it answers with problems, not exceptions.
+ * That promise was not kept: `validateSpec` throws on `repeat: null`, on
+ * `children: 5`, on `props: 5`, on a null element and on a missing `elements`
+ * map, all of which a model can emit. A host calls this to decide whether it is
+ * safe to render, so a throw leaves it with no verdict at the one moment it
+ * needs one, and the fallback to the plain form never fires.
+ */
+declare function validateAgainstCatalog(spec: Spec, catalog?: ValidationCatalog): SpecVerdict;
+/** The problems as one block, for a failing test or a repair prompt. */
+declare function formatProblems(problems: readonly SpecProblem[]): string;
+
+/**
+ * The catalog: everything the base vocabulary has, plus the chrome of a
+ * product page - a bar with the logo, a hero, a workspace that puts a panel
+ * beside the work, a section, a raised rail, the summary rows a rail can be
+ * made of, a call to action, a footer line. They are vocabulary, not a
+ * template: the designer method prescribes no composition, and a layout uses
+ * whichever of them serve it. Each description says what the component IS and
+ * how it renders - a heading level, a landmark, a fixed child count - and never
+ * where it must go or whether a page must have it, because the descriptions
+ * travel to the model as data and would otherwise be the mandate the method
+ * gave up. The vocabulary names no brand: the logo is whichever the manifest
+ * carries and the accent is whichever the host's theme tokens set.
+ *
+ * Rule 1 holds here as it does everywhere in this entry: a component takes
+ * copy and bound values, never a schema, and the fields the kernel owns are
+ * still `MthdsField` elements naming a path.
+ */
+declare const PRODUCT_COMPONENTS: readonly ["AppBar", "Hero", "Workspace", "Section", "Rail", "SummaryRow", "Cta", "Footer"];
+type ProductComponentName = (typeof PRODUCT_COMPONENTS)[number];
+/**
+ * What this entry's components render beyond their schemas - the heading a
+ * title is, the landmark a bar or a footer renders as, the two children a
+ * split lays out, the panel per tab or step - declared once here, where the
+ * descriptions above say the same in prose for the model, and carried on the
+ * catalog so the validator reads it off whichever catalog it is handed. A
+ * host validating against a vocabulary of its own declares what its
+ * renderers do, or nothing.
+ */
+declare const COMPONENT_RENDERINGS: Readonly<Record<string, ComponentRendering>>;
+declare const catalog: _json_render_core.Catalog<{
+    spec: _json_render_core.SchemaType<"object", {
+        root: _json_render_core.SchemaType<"string", unknown>;
+        elements: _json_render_core.SchemaType<"record", _json_render_core.SchemaType<"object", {
+            type: _json_render_core.SchemaType<"ref", string>;
+            props: _json_render_core.SchemaType<"propsOf", string>;
+            children: _json_render_core.SchemaType<"array", _json_render_core.SchemaType<"string", unknown>>;
+            slots: {
+                optional: true;
+                kind: "record";
+                inner?: _json_render_core.SchemaType<"array", _json_render_core.SchemaType<"string", unknown>> | undefined;
+            };
+            visible: {
+                optional: true;
+                kind: "any";
+                inner?: unknown;
+            };
+            repeat: {
+                optional: true;
+                kind: "any";
+                inner?: unknown;
+            };
+        }>>;
+    }>;
+    catalog: _json_render_core.SchemaType<"object", {
+        components: _json_render_core.SchemaType<"map", {
+            props: _json_render_core.SchemaType<"zod", unknown>;
+            slots: _json_render_core.SchemaType<"array", _json_render_core.SchemaType<"string", unknown>>;
+            description: _json_render_core.SchemaType<"string", unknown>;
+            example: _json_render_core.SchemaType<"any", unknown>;
+        }>;
+        actions: _json_render_core.SchemaType<"map", {
+            params: _json_render_core.SchemaType<"zod", unknown>;
+            description: _json_render_core.SchemaType<"string", unknown>;
+        }>;
+    }>;
+}, {
+    components: {
+        AppBar: {
+            props: z.ZodObject<{
+                app: z.ZodString;
+                links: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                tag: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                app: string;
+                links: string[];
+                tag: string;
+            };
+        };
+        Hero: {
+            props: z.ZodObject<{
+                headline: z.ZodString;
+                lede: z.ZodNullable<z.ZodString>;
+                eyebrow: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                headline: string;
+                lede: string;
+            };
+        };
+        Workspace: {
+            props: z.ZodObject<{
+                rail: z.ZodNullable<z.ZodEnum<{
+                    right: "right";
+                    left: "left";
+                }>>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                rail: string;
+            };
+        };
+        Section: {
+            props: z.ZodObject<{
+                number: z.ZodNullable<z.ZodString>;
+                title: z.ZodString;
+                lede: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                number: string;
+                title: string;
+            };
+        };
+        Rail: {
+            props: z.ZodObject<{
+                title: z.ZodString;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                title: string;
+            };
+        };
+        SummaryRow: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodNullable<z.ZodAny>;
+                detail: z.ZodNullable<z.ZodAny>;
+                separator: z.ZodNullable<z.ZodString>;
+                placeholder: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                value: {
+                    $state: string;
+                };
+                detail: {
+                    $state: string;
+                };
+            };
+        };
+        Cta: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                hint: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            events: string[];
+            description: string;
+            example: {
+                label: string;
+                hint: string;
+            };
+        };
+        Footer: {
+            props: z.ZodObject<{
+                text: z.ZodString;
+                tag: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                text: string;
+                tag: string;
+            };
+        };
+        Card: {
+            props: z.ZodObject<{
+                description: z.ZodNullable<z.ZodString>;
+                title: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            description: string;
+            slots: string[];
+            example: {
+                title: string;
+                description: string;
+            };
+        };
+        Stack: {
+            props: z.ZodObject<{
+                direction: z.ZodNullable<z.ZodEnum<{
+                    horizontal: "horizontal";
+                    vertical: "vertical";
+                }>>;
+                gap: z.ZodNullable<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                    none: "none";
+                    xl: "xl";
+                }>>;
+                align: z.ZodNullable<z.ZodEnum<{
+                    start: "start";
+                    center: "center";
+                    end: "end";
+                    stretch: "stretch";
+                }>>;
+                justify: z.ZodNullable<z.ZodEnum<{
+                    start: "start";
+                    center: "center";
+                    end: "end";
+                    between: "between";
+                    around: "around";
+                }>>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                direction: string;
+                gap: string;
+            };
+        };
+        Grid: {
+            props: z.ZodObject<{
+                gap: z.ZodNullable<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                columns: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                columns: number;
+                gap: string;
+            };
+        };
+        Separator: {
+            props: z.ZodObject<{
+                orientation: z.ZodNullable<z.ZodEnum<{
+                    horizontal: "horizontal";
+                    vertical: "vertical";
+                }>>;
+            }, z.core.$strip>;
+            description: string;
+        };
+        Collapsible: {
+            props: z.ZodObject<{
+                title: z.ZodString;
+                defaultOpen: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+        };
+        Heading: {
+            props: z.ZodObject<{
+                text: z.ZodString;
+                level: z.ZodNullable<z.ZodEnum<{
+                    h1: "h1";
+                    h2: "h2";
+                    h3: "h3";
+                    h4: "h4";
+                }>>;
+            }, z.core.$strip>;
+            description: string;
+            example: {
+                text: string;
+                level: string;
+            };
+        };
+        Text: {
+            props: z.ZodObject<{
+                text: z.ZodString;
+                variant: z.ZodNullable<z.ZodEnum<{
+                    body: "body";
+                    caption: "caption";
+                    muted: "muted";
+                    lead: "lead";
+                    code: "code";
+                }>>;
+            }, z.core.$strip>;
+            description: string;
+            example: {
+                text: string;
+            };
+        };
+        Badge: {
+            props: z.ZodObject<{
+                text: z.ZodString;
+                variant: z.ZodNullable<z.ZodEnum<{
+                    default: "default";
+                    secondary: "secondary";
+                    destructive: "destructive";
+                    outline: "outline";
+                }>>;
+            }, z.core.$strip>;
+            description: string;
+            example: {
+                text: string;
+                variant: string;
+            };
+        };
+        Alert: {
+            props: z.ZodObject<{
+                title: z.ZodString;
+                message: z.ZodNullable<z.ZodString>;
+                type: z.ZodNullable<z.ZodEnum<{
+                    success: "success";
+                    info: "info";
+                    warning: "warning";
+                    error: "error";
+                }>>;
+            }, z.core.$strip>;
+            description: string;
+            example: {
+                title: string;
+                message: string;
+                type: string;
+            };
+        };
+        Progress: {
+            props: z.ZodObject<{
+                value: z.ZodNumber;
+                max: z.ZodNullable<z.ZodNumber>;
+                label: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            description: string;
+            example: {
+                value: number;
+                max: number;
+                label: string;
+            };
+        };
+        Avatar: {
+            description: string;
+            props: z.ZodObject<{
+                src: z.ZodNullable<z.ZodString>;
+                name: z.ZodString;
+                size: z.ZodNullable<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+            }, z.core.$strip>;
+            example: {
+                name: string;
+                size: string;
+            };
+        };
+        Input: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                name: z.ZodString;
+                type: z.ZodNullable<z.ZodEnum<{
+                    number: "number";
+                    text: "text";
+                    email: "email";
+                    password: "password";
+                }>>;
+                placeholder: z.ZodNullable<z.ZodString>;
+                value: z.ZodNullable<z.ZodString>;
+                checks: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                    message: z.ZodString;
+                    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+                validateOn: z.ZodNullable<z.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, z.core.$strip>;
+            events: string[];
+            description: string;
+            example: {
+                label: string;
+                name: string;
+                type: string;
+                placeholder: string;
+            };
+        };
+        Textarea: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                name: z.ZodString;
+                placeholder: z.ZodNullable<z.ZodString>;
+                rows: z.ZodNullable<z.ZodNumber>;
+                value: z.ZodNullable<z.ZodString>;
+                checks: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                    message: z.ZodString;
+                    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+                validateOn: z.ZodNullable<z.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, z.core.$strip>;
+            description: string;
+        };
+        Select: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                name: z.ZodString;
+                options: z.ZodArray<z.ZodString>;
+                placeholder: z.ZodNullable<z.ZodString>;
+                value: z.ZodNullable<z.ZodString>;
+                checks: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                    message: z.ZodString;
+                    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+                validateOn: z.ZodNullable<z.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, z.core.$strip>;
+            events: string[];
+            description: string;
+        };
+        Radio: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                name: z.ZodString;
+                options: z.ZodArray<z.ZodString>;
+                value: z.ZodNullable<z.ZodString>;
+                checks: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                    message: z.ZodString;
+                    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+                validateOn: z.ZodNullable<z.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, z.core.$strip>;
+            events: string[];
+            description: string;
+        };
+        Checkbox: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                name: z.ZodString;
+                checked: z.ZodNullable<z.ZodBoolean>;
+                checks: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                    message: z.ZodString;
+                    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+                validateOn: z.ZodNullable<z.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, z.core.$strip>;
+            events: string[];
+            description: string;
+        };
+        Switch: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                name: z.ZodString;
+                checked: z.ZodNullable<z.ZodBoolean>;
+                checks: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                    message: z.ZodString;
+                    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+                validateOn: z.ZodNullable<z.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, z.core.$strip>;
+            events: string[];
+            description: string;
+        };
+        Button: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                variant: z.ZodNullable<z.ZodEnum<{
+                    secondary: "secondary";
+                    primary: "primary";
+                    danger: "danger";
+                }>>;
+                disabled: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strip>;
+            events: string[];
+            description: string;
+            example: {
+                label: string;
+                variant: string;
+            };
+        };
+        Split: {
+            props: z.ZodObject<{
+                ratio: z.ZodNullable<z.ZodEnum<{
+                    "1:1": "1:1";
+                    "1:2": "1:2";
+                    "2:1": "2:1";
+                }>>;
+                gap: z.ZodNullable<z.ZodEnum<{
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                ratio: string;
+                gap: string;
+            };
+        };
+        Tabs: {
+            props: z.ZodObject<{
+                tabs: z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    value: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                tabs: {
+                    label: string;
+                    value: string;
+                }[];
+            };
+        };
+        Steps: {
+            props: z.ZodObject<{
+                steps: z.ZodArray<z.ZodString>;
+                nextLabel: z.ZodNullable<z.ZodString>;
+                backLabel: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                steps: string[];
+                nextLabel: string;
+            };
+        };
+        Icon: {
+            props: z.ZodObject<{
+                name: z.ZodEnum<{
+                    Sparkles: "Sparkles";
+                    Rocket: "Rocket";
+                    Compass: "Compass";
+                    Map: "Map";
+                    MapPin: "MapPin";
+                    Route: "Route";
+                    Plane: "Plane";
+                    Train: "Train";
+                    Car: "Car";
+                    Ship: "Ship";
+                    Hotel: "Hotel";
+                    Home: "Home";
+                    Building2: "Building2";
+                    Landmark: "Landmark";
+                    Globe: "Globe";
+                    Mountain: "Mountain";
+                    Leaf: "Leaf";
+                    Sun: "Sun";
+                    Moon: "Moon";
+                    Calendar: "Calendar";
+                    Clock: "Clock";
+                    Hourglass: "Hourglass";
+                    Users: "Users";
+                    User: "User";
+                    Baby: "Baby";
+                    Accessibility: "Accessibility";
+                    Heart: "Heart";
+                    Star: "Star";
+                    Utensils: "Utensils";
+                    Coffee: "Coffee";
+                    Music: "Music";
+                    Camera: "Camera";
+                    Image: "Image";
+                    Ticket: "Ticket";
+                    Gift: "Gift";
+                    Wallet: "Wallet";
+                    Banknote: "Banknote";
+                    Coins: "Coins";
+                    Receipt: "Receipt";
+                    Percent: "Percent";
+                    Hash: "Hash";
+                    TrendingUp: "TrendingUp";
+                    BarChart3: "BarChart3";
+                    FileText: "FileText";
+                    Upload: "Upload";
+                    Paperclip: "Paperclip";
+                    Mail: "Mail";
+                    Phone: "Phone";
+                    Tag: "Tag";
+                    Layers: "Layers";
+                    ListChecks: "ListChecks";
+                    CheckCircle2: "CheckCircle2";
+                    AlertCircle: "AlertCircle";
+                    Info: "Info";
+                    Shield: "Shield";
+                    Flag: "Flag";
+                    Bookmark: "Bookmark";
+                    Briefcase: "Briefcase";
+                    Package: "Package";
+                    Truck: "Truck";
+                    Lightbulb: "Lightbulb";
+                    Zap: "Zap";
+                    Pencil: "Pencil";
+                    Send: "Send";
+                }>;
+                size: z.ZodNullable<z.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                name: string;
+                size: string;
+            };
+        };
+        Segmented: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                name: z.ZodString;
+                options: z.ZodArray<z.ZodString>;
+                value: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                name: string;
+                options: string[];
+                value: {
+                    $bindState: string;
+                };
+            };
+        };
+        NumberInput: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                name: z.ZodString;
+                value: z.ZodNullable<z.ZodNumber>;
+                placeholder: z.ZodNullable<z.ZodString>;
+                unit: z.ZodNullable<z.ZodString>;
+                min: z.ZodNullable<z.ZodNumber>;
+                max: z.ZodNullable<z.ZodNumber>;
+                step: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                name: string;
+                value: {
+                    $bindState: string;
+                };
+                placeholder: string;
+            };
+        };
+        MthdsField: {
+            props: z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                path: string;
+            };
+        };
+        MthdsResult: {
+            props: z.ZodObject<{
+                path: z.ZodString;
+                hideLabel: z.ZodNullable<z.ZodBoolean>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                path: string;
+            };
+        };
+        DataTable: {
+            props: z.ZodObject<{
+                rows: z.ZodAny;
+                columns: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>>;
+                caption: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                rows: {
+                    $state: string;
+                };
+                columns: {
+                    path: string;
+                    label: string;
+                }[];
+            };
+        };
+        Metric: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodAny;
+                unit: z.ZodNullable<z.ZodString>;
+                format: z.ZodNullable<z.ZodEnum<{
+                    plain: "plain";
+                    integer: "integer";
+                    decimal: "decimal";
+                    compact: "compact";
+                }>>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                value: {
+                    $state: string;
+                };
+                unit: string;
+                format: string;
+            };
+        };
+    };
+    actions: {
+        run: {
+            params: z.ZodObject<{}, z.core.$strip>;
+            description: string;
+        };
+    };
+}> & {
+    renders: Readonly<Record<string, ComponentRendering>>;
+};
+/** The spec type a layout is written against. */
+type GenerativeSpec = typeof catalog._specType;
+/**
+ * Every component name the catalog knows, the shadcn subset first. This is
+ * the order the designer method lists them in, since `designerCatalog()`
+ * walks it; the rules and the direction that name them are the method's own
+ * prose, in `methods/layout-design.mthds`.
+ */
+declare const COMPONENT_NAMES: readonly string[];
+
+/** The shadcn subset, by name. The order is the order the prompt lists them. */
+declare const PICKED_SHADCN: readonly ["Card", "Stack", "Grid", "Separator", "Heading", "Text", "Badge", "Alert", "Collapsible", "Progress", "Avatar", "Input", "Textarea", "Select", "Radio", "Checkbox", "Switch", "Button"];
+/** Our own, by name. */
+declare const CUSTOM_COMPONENTS: readonly ["Split", "Tabs", "Steps", "Icon", "Segmented", "NumberInput", "MthdsField", "MthdsResult", "DataTable", "Metric"];
+/**
+ * The value formats a `Metric` can apply. A model picks one; the registry
+ * formats with `Intl.NumberFormat`.
+ */
+declare const METRIC_FORMATS: readonly ["plain", "integer", "decimal", "compact"];
+/**
+ * The icons a spec may name: lucide's, a closed list so a misspelt name fails
+ * validation rather than rendering nothing. Chosen for what pages about
+ * methods talk about - people, places, money, time, files, standing.
+ */
+declare const ICON_NAMES: readonly ["Sparkles", "Rocket", "Compass", "Map", "MapPin", "Route", "Plane", "Train", "Car", "Ship", "Hotel", "Home", "Building2", "Landmark", "Globe", "Mountain", "Leaf", "Sun", "Moon", "Calendar", "Clock", "Hourglass", "Users", "User", "Baby", "Accessibility", "Heart", "Star", "Utensils", "Coffee", "Music", "Camera", "Image", "Ticket", "Gift", "Wallet", "Banknote", "Coins", "Receipt", "Percent", "Hash", "TrendingUp", "BarChart3", "FileText", "Upload", "Paperclip", "Mail", "Phone", "Tag", "Layers", "ListChecks", "CheckCircle2", "AlertCircle", "Info", "Shield", "Flag", "Bookmark", "Briefcase", "Package", "Truck", "Lightbulb", "Zap", "Pencil", "Send"];
+
+/** One action a page may bind to an event: its name, what it does, and whether the runtime handles it on its own. */
+declare const ActionSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    built_in: z.ZodBoolean;
+}, z.core.$strip>;
+type Action = z.infer<typeof ActionSchema>;
+/** The page's half of the prompt, as data: which page it is and for which pipe, every path in the state with what it is, which paths are delegated and what gates the run, and on a result page the state of one real run - rendered from the method's own descriptor and from nothing else. */
+declare const BriefSchema: z.ZodObject<{
+    side: z.ZodEnum<{
+        input: "input";
+        result: "result";
+    }>;
+    pipe_ref: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    paths: z.ZodArray<z.ZodLazy<z.ZodObject<{
+        depth: z.ZodNumber;
+        path: z.ZodString;
+        kind: z.ZodString;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        required: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        gating: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        default: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        delegated: z.ZodBoolean;
+        relative: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        item_kind: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        item_description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        item_laid_out: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    run_control: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sample_state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type Brief = z.infer<typeof BriefSchema>;
+/** The vocabulary a page may be made of: the components a renderer implements and the actions a page may bind to an event, each with its contract. */
+declare const CatalogSchema: z.ZodObject<{
+    components: z.ZodArray<z.ZodLazy<z.ZodObject<{
+        name: z.ZodString;
+        props: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        accepts_children: z.ZodBoolean;
+        slots: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        events: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    actions: z.ZodArray<z.ZodLazy<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        built_in: z.ZodBoolean;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Catalog = z.infer<typeof CatalogSchema>;
+/** One component of the catalog: its name, the signature of its props, what it is for, and what it accepts. */
+declare const ComponentSchema: z.ZodObject<{
+    name: z.ZodString;
+    props: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    accepts_children: z.ZodBoolean;
+    slots: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    events: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+type Component = z.infer<typeof ComponentSchema>;
+/** The designer's plan for one page, settled before any element is written: what the page is for, how it is composed - a decision the plan makes, with no shape given in advance - what each region shows or collects and with which components, what runs the method, and what is delegated. */
+declare const PagePlanSchema: z.ZodObject<{
+    purpose: z.ZodString;
+    title: z.ZodString;
+    composition: z.ZodString;
+    regions: z.ZodArray<z.ZodLazy<z.ZodObject<{
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        purpose: z.ZodString;
+        container: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        elements: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
+    call_to_action: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    defaults: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    delegated: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+type PagePlan = z.infer<typeof PagePlanSchema>;
+/** One path of the state, as the brief describes it: where it is, what it holds, what it is called, what constrains it, and whether the page lays it out or hands it back to the kernel's own control. */
+declare const PathEntrySchema: z.ZodObject<{
+    depth: z.ZodNumber;
+    path: z.ZodString;
+    kind: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    required: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    gating: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    default: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    delegated: z.ZodBoolean;
+    relative: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    item_kind: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    item_description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    item_laid_out: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+type PathEntry = z.infer<typeof PathEntrySchema>;
+
+/**
+ * The catalog as the designer method's `catalog` input: the vocabulary as
+ * DATA, which the method's own prompt lays out.
+ *
+ * The prompt a model reads is the method - `methods/layout-design.mthds`
+ * carries every paragraph of it as prose and loops over these two lists for
+ * the component and action sections. What this package contributes is what
+ * only code can state: each component's props signature, rendered from its
+ * zod schema, beside the description and the slots its definition declares.
+ * One function so the fixture pass, the briefs and the tests hand over one
+ * value, and the hash stamped on a captured layout covers what was actually
+ * sent.
+ *
+ * The shapes are the method's own: codegen projects the `Catalog`,
+ * `Component` and `Action` structures the bundle declares into
+ * `src/generated/layout-design/`, and the aliases below are those types. So a
+ * field renamed in the bundle fails the type check on the literals here
+ * rather than a run, and the value goes over as the content of a structured
+ * input, verbatim. The import is type-only: the generated zod schemas stay
+ * out of the entry, which ships no validator for this value.
+ */
+/** The `Catalog` structure of `methods/layout-design.mthds`, as codegen projects it. */
+type DesignerCatalog = Catalog;
+/** One component of the catalog: its name, its props signature, what it is for, what it accepts. */
+type DesignerComponent = Component;
+/** One action a page may bind to an event. */
+type DesignerAction = Action;
+/** The concept a run request names for the `catalog` input: the method's own, domain-qualified. */
+declare const DESIGNER_CATALOG_CONCEPT = "generative.Catalog";
+declare function designerCatalog(): DesignerCatalog;
+
+/**
+ * The hash that pairs a captured layout with the prompt it was produced
+ * against: the first twelve hex digits of the SHA-256 of `promptHashSubject`,
+ * which is the designer method's text and the catalog it was handed.
+ *
+ * The prompt is no longer one string this package renders: it is the method
+ * (`methods/layout-design.mthds`, every paragraph as prose) applied to
+ * the catalog as data (`designerCatalog()`). Both are what a run was actually
+ * given, so both are hashed - a reworded rule and a renamed prop each move
+ * the pin, exactly as they did when the prompt was rendered here. The model
+ * pin in the method file moves it too, since the file is hashed whole; a
+ * fixture records its model on its own, so that costs a regeneration, never a
+ * misread.
+ *
+ * It is a PIN rather than a computation, so that this entry stays importable
+ * from a browser (hashing would mean `node:crypto` or an async Web Crypto
+ * call, and a host compares this value synchronously while deciding whether a
+ * stored layout still stands - and the entry must not read the method file).
+ * `__tests__/prompt.test.ts` recomputes it from the file and the catalog and
+ * fails on any drift, so the pin cannot go stale quietly: a catalog, rule or
+ * direction change is a failing test, which is exactly what it was for.
+ *
+ * A stored layout whose hash is not this one is not rendered - the host falls
+ * back to the kernel's own form - because the vocabulary it was written in is
+ * no longer the vocabulary this entry renders.
+ */
+declare const PROMPT_HASH = "2b2325fd1231";
+
+/**
+ * The brief: the model's view of the descriptor, as DATA.
+ *
+ * Rule 1, restated for a model. The model's input is the DESCRIPTOR, never JSON
+ * Schema: it receives the kinds, the labels, the descriptions, the choices, the
+ * presence and what gates the run - projected from `RunField[]` here, and from
+ * nowhere else, into the `Brief` structure the designer method declares. On the
+ * result side it also receives one real run's loaded state, so it can judge
+ * magnitudes, but it never sees the wire: the state it reads is what
+ * `payloadToState` produced, with the envelopes already gone.
+ *
+ * Nothing here is prose. The sentences a model reads - the headings, how a
+ * path line is worded, what "delegated" says - are the method's own, in the
+ * `render_brief` stage of `methods/layout-design.mthds`: a Jinja2 template
+ * over this value, and the one place the brief's wording is edited. What this
+ * module contributes is what only code can state: every path, flattened in
+ * reading order with its depth, its kind in words, its constraints in words,
+ * and which of them the kernel keeps. The shape is the method's own: codegen
+ * projects its `Brief` and `PathEntry` structures into
+ * `src/generated/layout-design/`, and the aliases below are those types,
+ * imported type-only so the generated schemas stay out of the entry. A field
+ * renamed in the bundle fails the type check on the literals here rather than
+ * a run.
+ *
+ * Pure, no React, and the only place the descriptor is projected for a model.
+ * What a path is marked as (delegated or not) is decided here too, so the
+ * projection, the brief and the validator agree on which paths the kernel
+ * renders.
+ */
+/** The `Brief` structure of `methods/layout-design.mthds`, as codegen projects it. */
+type DesignerBrief = Brief;
+/** One path of the brief: where it is, what it holds, what constrains it, whether the kernel keeps it. */
+type DesignerPathEntry = PathEntry;
+/** The concept a run request names for the `brief` input: the method's own, domain-qualified. */
+declare const DESIGNER_BRIEF_CONCEPT = "generative.Brief";
+interface BriefSubject {
+    /** `results.nested_result`. */
+    pipeRef: string;
+    /** The pipe's description, when the wire carries one. */
+    description?: string;
+    /**
+     * The method's name as a host lists it - an authored method's, since a host
+     * has one for every method it lists; absent on a synthesized carrier, which
+     * no host lists. The brief hands it to the layout as the one product name
+     * the page may carry, because the brand catalog's AppBar asks for a name
+     * and a brief that gives none gets one invented.
+     */
+    name?: string;
+}
+/**
+ * On the input side, the kinds the catalog's inputs cannot enter - and one
+ * shape of a kind they otherwise can. The standard puts no floor on a choice,
+ * so an enum may carry `""`; the catalog's own choices may not, because no
+ * dropdown row or pill can offer nothing, and the validator refuses an empty
+ * option. A model told to list the brief's choices exactly would copy the
+ * empty one into a layout the validator then refuses, so the brief hands the
+ * input back to the kernel's own control instead.
+ */
+declare function isDelegatedInput(field: RunField): boolean;
+/**
+ * On the result side, the kinds and concepts the catalog cannot show.
+ *
+ * A native value is one of them, and so is a list of one: the native
+ * predicates refuse a `list` node, because a list of dates is a list and not a
+ * date, but no catalog component reads a date's `{date, time}` either, so the
+ * kernel renders the list whole - one value per line, as the result view does.
+ */
+declare function isDelegatedResult(field: RunField): boolean;
+/** The brief for an INPUT page: the form a run is started from. */
+declare function inputBrief(subject: BriefSubject, fields: readonly RunField[]): DesignerBrief;
+/** The brief for a RESULT page: what one run produced, laid out. */
+declare function resultBrief(subject: BriefSubject, field: RunField, state: unknown): DesignerBrief;
+
+/**
+ * Whether a stored layout still fits the descriptor it will be rendered over.
+ *
+ * A layout is produced once per method version and stored; a descriptor is
+ * derived from the method every time it is read. Those two can part company -
+ * a method's input is renamed, a structure loses a member - and when they do,
+ * a delegated path resolves to nothing and a bound path writes into a corner of
+ * the state the run never reads. Neither fails loudly on its own, so the host
+ * asks this before it renders and falls back to the kernel's own form when the
+ * answer is no.
+ *
+ * Two directions, and the second is the one a corpus cannot notice. The first
+ * is staleness: every path the layout MENTIONS is a path the descriptor still
+ * has, which is the corpus test's check lifted out of the test and into the
+ * product. The second is coverage: every path the descriptor REQUIRES is one
+ * the layout offers somewhere. A layout that simply omits an input is not
+ * stale and validates perfectly - it renders a page with no field for a
+ * required input, the run gate then refuses the run for that input, and the
+ * person has nowhere to type it. A page you cannot complete is worse than the
+ * plain form, which is what the fallback is for.
+ *
+ * It answers with problems, not exceptions, and that is a promise rather than
+ * a habit: a host calls this to decide whether it is safe to render, so a
+ * throw leaves it with no verdict at the one moment it needs one. A layout is
+ * model-produced and may be malformed in ways the walk below trips on
+ * (`children: 5`, a null element, no `elements` map at all), and the other
+ * gate, which refuses those shapes outright, is exported separately - so
+ * neither may assume the other ran first.
+ *
+ * A third check sits between the two and is about KIND rather than presence:
+ * a path a layout shows as a value must be a scalar, and a path it reads into
+ * a prop that takes a list must be a list. A `SummaryRow` whose `value` reads
+ * `/inputs/document`, a structure of a url and a filename, is not stale - the
+ * path exists - and it validates perfectly; it renders `[object Object]`,
+ * because the renderer stringifies what it is handed and nothing anywhere said
+ * the path was not a value. An `AppBar` whose `links` read that same structure
+ * is the mirror image: its renderer maps over what it is handed, renders
+ * nothing for a structure and throws for a text. Only the descriptor knows
+ * what kind a path is, so this is where that is said.
+ *
+ * What is NOT checked here is whether the layout validates against the catalog
+ * - that is `validateAgainstCatalog`, and a host runs both.
+ */
+interface LayoutDescriptor {
+    /** The input page's top-level fields, for `/inputs/...` paths. */
+    inputs?: readonly RunField[];
+    /** The result page's descriptor, for `/result/...` paths. */
+    result?: RunField;
+}
+/**
+ * Every way this layout no longer fits, in the words a host can count by:
+ * one line per element or path, empty when it fits.
+ *
+ * The checks live in `collectLayoutProblems`; this is the boundary that keeps
+ * the promise in the header around them. A malformed spec is one line, naming
+ * what the walk tripped on, which is a verdict the fallback can act on where a
+ * throw was not.
+ */
+declare function layoutProblems(descriptor: LayoutDescriptor, spec: Spec): string[];
+/** The predicate: `layoutProblems` is empty. */
+declare function layoutFits(descriptor: LayoutDescriptor, spec: Spec): boolean;
+
+/**
+ * A spec as JSONL patches, and back.
+ *
+ * json-render's wire format is RFC 6902 patches, one per line, root first and
+ * parents before children, so a renderer can paint a partial tree at every
+ * line. A model emits that format; a projected or authored spec is a finished
+ * object. This is the bridge: any of the three sources can be replayed through
+ * `specToJsonl`, and what a model emitted is compiled through `specFromJsonl`
+ * before it is validated.
+ */
+/**
+ * The patch lines for a spec: `/root`, then every element reachable from the
+ * root in breadth-first order (a parent always precedes its children), then
+ * any element the root does not reach (kept, so a validator can report it),
+ * then one patch per top-level `state` key.
+ */
+declare function specToJsonl(spec: Spec): string;
+/**
+ * The spec a JSONL stream compiles to. Blank lines and non-JSON lines are
+ * skipped by the compiler; a line whose `path` or `from` would reach a
+ * prototype is dropped here, before the compiler sees it; and a line the
+ * compiler refuses is dropped too, which is why the stream is applied one line
+ * at a time.
+ *
+ * A batch compile made a single bad line fatal to the whole layout. Two of them
+ * are reachable from produced text: a `test` op whose value does not match
+ * throws `Test operation failed`, and a non-string `path` throws
+ * `path.startsWith is not a function`. A host follows the documented flow -
+ * compile, then ask the two gates - so a throw here arrives before there is any
+ * verdict to act on, and the fallback that exists for exactly this case never
+ * fires. Skipping the line degrades instead: what survives is a partial spec,
+ * which the gates then judge on its merits and reject if it is not renderable.
+ */
+declare function specFromJsonl(jsonl: string): Spec;
+/** The individual patch lines of a stream, for a replay that feeds them one at a time. */
+declare function jsonlLines(jsonl: string): string[];
+
+declare const brandManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    website: z.ZodURL;
+    logo: z.ZodObject<{
+        onLight: z.ZodURL;
+        onDark: z.ZodURL;
+    }, z.core.$strict>;
+    webfont: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodLiteral<"google-fonts">;
+        family: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type BrandManifest = z.infer<typeof brandManifestSchema>;
+
+/**
+ * The registry: what each catalog entry RENDERS as.
+ *
+ * The shadcn subset binds the package's own implementations. The custom
+ * components are implemented here over this package's controls and vendored
+ * primitives - the vocabulary of an app (Split, Tabs, Steps, Icon, Segmented,
+ * NumberInput), the bound equivalents of what a model most wants to inline
+ * (DataTable, Metric), and the two escape hatches the design rests on:
+ *
+ *  - `MthdsField` renders ONE input through `FieldRenderer`, two-way at the
+ *    path the spec names. It is the arm for the kinds the catalog cannot
+ *    enter, and it is always available for a scalar the model would rather
+ *    not style.
+ *  - `MthdsResult` renders ONE result subtree through `ResultField`, reading
+ *    state at the path the spec names.
+ *
+ * Both resolve the path against the DESCRIPTOR, through `DescriptorProvider`,
+ * which is what keeps rule 1: the spec names a path and nothing more, and the
+ * kernel is handed the `RunField` the host already holds. A spec never
+ * restates what a field is.
+ */
+interface DescriptorScope {
+    /** The input page's top-level fields, for `/inputs/...` paths. */
+    inputs?: readonly RunField[];
+    /** The result page's descriptor, for `/result/...` paths. */
+    result?: RunField;
+    /** What the host injects into the controls: upload, disabled, resolver. */
+    env?: FieldEnv;
+    /** Prefix for the DOM ids `MthdsField` mints; two pages on one screen need two. */
+    idPrefix?: string;
+}
+/** The scope the nearest `DescriptorProvider` set - for a renderer defined outside this file. */
+declare function useDescriptorScope(): DescriptorScope;
+declare function DescriptorProvider({ scope, children, }: {
+    scope: DescriptorScope;
+    children: react.ReactNode;
+}): react.JSX.Element;
+/**
+ * The inverse of `domIdFor`, for a host's upload seam: the kernel reports a
+ * drop by the DOM id of the field it landed on, which for a nested one is the
+ * hatch's id with the child's name or index joined by `.` (the kernel's own
+ * composition, `FieldRenderer` through `ObjectField` and `ListField`), and
+ * the host writes the file at the store path that id was minted from. Kept
+ * beside `domIdFor` so the two cannot drift, and exact for any name by
+ * construction rather than by assumption.
+ */
+declare function pathFromDomId(prefix: string | undefined, id: string): string | undefined;
+/** The renderers, for the registry over the catalog that extends this vocabulary. */
+declare const generativeRenderers: Components<_json_render_core.Catalog<{
+    spec: _json_render_core.SchemaType<"object", {
+        root: _json_render_core.SchemaType<"string", unknown>;
+        elements: _json_render_core.SchemaType<"record", _json_render_core.SchemaType<"object", {
+            type: _json_render_core.SchemaType<"ref", string>;
+            props: _json_render_core.SchemaType<"propsOf", string>;
+            children: _json_render_core.SchemaType<"array", _json_render_core.SchemaType<"string", unknown>>;
+            slots: {
+                optional: true;
+                kind: "record";
+                inner?: _json_render_core.SchemaType<"array", _json_render_core.SchemaType<"string", unknown>> | undefined;
+            };
+            visible: {
+                optional: true;
+                kind: "any";
+                inner?: unknown;
+            };
+            repeat: {
+                optional: true;
+                kind: "any";
+                inner?: unknown;
+            };
+        }>>;
+    }>;
+    catalog: _json_render_core.SchemaType<"object", {
+        components: _json_render_core.SchemaType<"map", {
+            props: _json_render_core.SchemaType<"zod", unknown>;
+            slots: _json_render_core.SchemaType<"array", _json_render_core.SchemaType<"string", unknown>>;
+            description: _json_render_core.SchemaType<"string", unknown>;
+            example: _json_render_core.SchemaType<"any", unknown>;
+        }>;
+        actions: _json_render_core.SchemaType<"map", {
+            params: _json_render_core.SchemaType<"zod", unknown>;
+            description: _json_render_core.SchemaType<"string", unknown>;
+        }>;
+    }>;
+}, {
+    components: {
+        Card: {
+            props: zod.ZodObject<{
+                description: zod.ZodNullable<zod.ZodString>;
+                title: zod.ZodNullable<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+            description: string;
+            slots: string[];
+            example: {
+                title: string;
+                description: string;
+            };
+        };
+        Stack: {
+            props: zod.ZodObject<{
+                direction: zod.ZodNullable<zod.ZodEnum<{
+                    horizontal: "horizontal";
+                    vertical: "vertical";
+                }>>;
+                gap: zod.ZodNullable<zod.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                    none: "none";
+                    xl: "xl";
+                }>>;
+                align: zod.ZodNullable<zod.ZodEnum<{
+                    start: "start";
+                    center: "center";
+                    end: "end";
+                    stretch: "stretch";
+                }>>;
+                justify: zod.ZodNullable<zod.ZodEnum<{
+                    start: "start";
+                    center: "center";
+                    end: "end";
+                    between: "between";
+                    around: "around";
+                }>>;
+            }, zod_v4_core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                direction: string;
+                gap: string;
+            };
+        };
+        Grid: {
+            props: zod.ZodObject<{
+                gap: zod.ZodNullable<zod.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+                columns: zod.ZodNullable<zod.ZodNumber>;
+            }, zod_v4_core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                columns: number;
+                gap: string;
+            };
+        };
+        Separator: {
+            props: zod.ZodObject<{
+                orientation: zod.ZodNullable<zod.ZodEnum<{
+                    horizontal: "horizontal";
+                    vertical: "vertical";
+                }>>;
+            }, zod_v4_core.$strip>;
+            description: string;
+        };
+        Collapsible: {
+            props: zod.ZodObject<{
+                title: zod.ZodString;
+                defaultOpen: zod.ZodNullable<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>;
+            slots: string[];
+            description: string;
+        };
+        Heading: {
+            props: zod.ZodObject<{
+                text: zod.ZodString;
+                level: zod.ZodNullable<zod.ZodEnum<{
+                    h1: "h1";
+                    h2: "h2";
+                    h3: "h3";
+                    h4: "h4";
+                }>>;
+            }, zod_v4_core.$strip>;
+            description: string;
+            example: {
+                text: string;
+                level: string;
+            };
+        };
+        Text: {
+            props: zod.ZodObject<{
+                text: zod.ZodString;
+                variant: zod.ZodNullable<zod.ZodEnum<{
+                    body: "body";
+                    caption: "caption";
+                    muted: "muted";
+                    lead: "lead";
+                    code: "code";
+                }>>;
+            }, zod_v4_core.$strip>;
+            description: string;
+            example: {
+                text: string;
+            };
+        };
+        Badge: {
+            props: zod.ZodObject<{
+                text: zod.ZodString;
+                variant: zod.ZodNullable<zod.ZodEnum<{
+                    default: "default";
+                    secondary: "secondary";
+                    destructive: "destructive";
+                    outline: "outline";
+                }>>;
+            }, zod_v4_core.$strip>;
+            description: string;
+            example: {
+                text: string;
+                variant: string;
+            };
+        };
+        Alert: {
+            props: zod.ZodObject<{
+                title: zod.ZodString;
+                message: zod.ZodNullable<zod.ZodString>;
+                type: zod.ZodNullable<zod.ZodEnum<{
+                    success: "success";
+                    info: "info";
+                    warning: "warning";
+                    error: "error";
+                }>>;
+            }, zod_v4_core.$strip>;
+            description: string;
+            example: {
+                title: string;
+                message: string;
+                type: string;
+            };
+        };
+        Progress: {
+            props: zod.ZodObject<{
+                value: zod.ZodNumber;
+                max: zod.ZodNullable<zod.ZodNumber>;
+                label: zod.ZodNullable<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+            description: string;
+            example: {
+                value: number;
+                max: number;
+                label: string;
+            };
+        };
+        Avatar: {
+            description: string;
+            props: zod.ZodObject<{
+                src: zod.ZodNullable<zod.ZodString>;
+                name: zod.ZodString;
+                size: zod.ZodNullable<zod.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+            }, zod_v4_core.$strip>;
+            example: {
+                name: string;
+                size: string;
+            };
+        };
+        Input: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                name: zod.ZodString;
+                type: zod.ZodNullable<zod.ZodEnum<{
+                    number: "number";
+                    text: "text";
+                    email: "email";
+                    password: "password";
+                }>>;
+                placeholder: zod.ZodNullable<zod.ZodString>;
+                value: zod.ZodNullable<zod.ZodString>;
+                checks: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+                    type: zod.ZodString;
+                    message: zod.ZodString;
+                    args: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>>>;
+                validateOn: zod.ZodNullable<zod.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, zod_v4_core.$strip>;
+            events: string[];
+            description: string;
+            example: {
+                label: string;
+                name: string;
+                type: string;
+                placeholder: string;
+            };
+        };
+        Textarea: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                name: zod.ZodString;
+                placeholder: zod.ZodNullable<zod.ZodString>;
+                rows: zod.ZodNullable<zod.ZodNumber>;
+                value: zod.ZodNullable<zod.ZodString>;
+                checks: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+                    type: zod.ZodString;
+                    message: zod.ZodString;
+                    args: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>>>;
+                validateOn: zod.ZodNullable<zod.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, zod_v4_core.$strip>;
+            description: string;
+        };
+        Select: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                name: zod.ZodString;
+                options: zod.ZodArray<zod.ZodString>;
+                placeholder: zod.ZodNullable<zod.ZodString>;
+                value: zod.ZodNullable<zod.ZodString>;
+                checks: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+                    type: zod.ZodString;
+                    message: zod.ZodString;
+                    args: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>>>;
+                validateOn: zod.ZodNullable<zod.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, zod_v4_core.$strip>;
+            events: string[];
+            description: string;
+        };
+        Radio: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                name: zod.ZodString;
+                options: zod.ZodArray<zod.ZodString>;
+                value: zod.ZodNullable<zod.ZodString>;
+                checks: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+                    type: zod.ZodString;
+                    message: zod.ZodString;
+                    args: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>>>;
+                validateOn: zod.ZodNullable<zod.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, zod_v4_core.$strip>;
+            events: string[];
+            description: string;
+        };
+        Checkbox: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                name: zod.ZodString;
+                checked: zod.ZodNullable<zod.ZodBoolean>;
+                checks: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+                    type: zod.ZodString;
+                    message: zod.ZodString;
+                    args: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>>>;
+                validateOn: zod.ZodNullable<zod.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, zod_v4_core.$strip>;
+            events: string[];
+            description: string;
+        };
+        Switch: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                name: zod.ZodString;
+                checked: zod.ZodNullable<zod.ZodBoolean>;
+                checks: zod.ZodNullable<zod.ZodArray<zod.ZodObject<{
+                    type: zod.ZodString;
+                    message: zod.ZodString;
+                    args: zod.ZodOptional<zod.ZodRecord<zod.ZodString, zod.ZodUnknown>>;
+                }, zod_v4_core.$strip>>>;
+                validateOn: zod.ZodNullable<zod.ZodEnum<{
+                    change: "change";
+                    blur: "blur";
+                    submit: "submit";
+                }>>;
+            }, zod_v4_core.$strip>;
+            events: string[];
+            description: string;
+        };
+        Button: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                variant: zod.ZodNullable<zod.ZodEnum<{
+                    secondary: "secondary";
+                    primary: "primary";
+                    danger: "danger";
+                }>>;
+                disabled: zod.ZodNullable<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>;
+            events: string[];
+            description: string;
+            example: {
+                label: string;
+                variant: string;
+            };
+        };
+        Split: {
+            props: zod.ZodObject<{
+                ratio: zod.ZodNullable<zod.ZodEnum<{
+                    "1:1": "1:1";
+                    "1:2": "1:2";
+                    "2:1": "2:1";
+                }>>;
+                gap: zod.ZodNullable<zod.ZodEnum<{
+                    md: "md";
+                    lg: "lg";
+                    xl: "xl";
+                }>>;
+            }, zod_v4_core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                ratio: string;
+                gap: string;
+            };
+        };
+        Tabs: {
+            props: zod.ZodObject<{
+                tabs: zod.ZodArray<zod.ZodObject<{
+                    label: zod.ZodString;
+                    value: zod.ZodString;
+                }, zod_v4_core.$strip>>;
+            }, zod_v4_core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                tabs: {
+                    label: string;
+                    value: string;
+                }[];
+            };
+        };
+        Steps: {
+            props: zod.ZodObject<{
+                steps: zod.ZodArray<zod.ZodString>;
+                nextLabel: zod.ZodNullable<zod.ZodString>;
+                backLabel: zod.ZodNullable<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                steps: string[];
+                nextLabel: string;
+            };
+        };
+        Icon: {
+            props: zod.ZodObject<{
+                name: zod.ZodEnum<{
+                    Sparkles: "Sparkles";
+                    Rocket: "Rocket";
+                    Compass: "Compass";
+                    Map: "Map";
+                    MapPin: "MapPin";
+                    Route: "Route";
+                    Plane: "Plane";
+                    Train: "Train";
+                    Car: "Car";
+                    Ship: "Ship";
+                    Hotel: "Hotel";
+                    Home: "Home";
+                    Building2: "Building2";
+                    Landmark: "Landmark";
+                    Globe: "Globe";
+                    Mountain: "Mountain";
+                    Leaf: "Leaf";
+                    Sun: "Sun";
+                    Moon: "Moon";
+                    Calendar: "Calendar";
+                    Clock: "Clock";
+                    Hourglass: "Hourglass";
+                    Users: "Users";
+                    User: "User";
+                    Baby: "Baby";
+                    Accessibility: "Accessibility";
+                    Heart: "Heart";
+                    Star: "Star";
+                    Utensils: "Utensils";
+                    Coffee: "Coffee";
+                    Music: "Music";
+                    Camera: "Camera";
+                    Image: "Image";
+                    Ticket: "Ticket";
+                    Gift: "Gift";
+                    Wallet: "Wallet";
+                    Banknote: "Banknote";
+                    Coins: "Coins";
+                    Receipt: "Receipt";
+                    Percent: "Percent";
+                    Hash: "Hash";
+                    TrendingUp: "TrendingUp";
+                    BarChart3: "BarChart3";
+                    FileText: "FileText";
+                    Upload: "Upload";
+                    Paperclip: "Paperclip";
+                    Mail: "Mail";
+                    Phone: "Phone";
+                    Tag: "Tag";
+                    Layers: "Layers";
+                    ListChecks: "ListChecks";
+                    CheckCircle2: "CheckCircle2";
+                    AlertCircle: "AlertCircle";
+                    Info: "Info";
+                    Shield: "Shield";
+                    Flag: "Flag";
+                    Bookmark: "Bookmark";
+                    Briefcase: "Briefcase";
+                    Package: "Package";
+                    Truck: "Truck";
+                    Lightbulb: "Lightbulb";
+                    Zap: "Zap";
+                    Pencil: "Pencil";
+                    Send: "Send";
+                }>;
+                size: zod.ZodNullable<zod.ZodEnum<{
+                    sm: "sm";
+                    md: "md";
+                    lg: "lg";
+                }>>;
+            }, zod_v4_core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                name: string;
+                size: string;
+            };
+        };
+        Segmented: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                name: zod.ZodString;
+                options: zod.ZodArray<zod.ZodString>;
+                value: zod.ZodNullable<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                name: string;
+                options: string[];
+                value: {
+                    $bindState: string;
+                };
+            };
+        };
+        NumberInput: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                name: zod.ZodString;
+                value: zod.ZodNullable<zod.ZodNumber>;
+                placeholder: zod.ZodNullable<zod.ZodString>;
+                unit: zod.ZodNullable<zod.ZodString>;
+                min: zod.ZodNullable<zod.ZodNumber>;
+                max: zod.ZodNullable<zod.ZodNumber>;
+                step: zod.ZodNullable<zod.ZodNumber>;
+            }, zod_v4_core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                name: string;
+                value: {
+                    $bindState: string;
+                };
+                placeholder: string;
+            };
+        };
+        MthdsField: {
+            props: zod.ZodObject<{
+                path: zod.ZodString;
+            }, zod_v4_core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                path: string;
+            };
+        };
+        MthdsResult: {
+            props: zod.ZodObject<{
+                path: zod.ZodString;
+                hideLabel: zod.ZodNullable<zod.ZodBoolean>;
+            }, zod_v4_core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                path: string;
+            };
+        };
+        DataTable: {
+            props: zod.ZodObject<{
+                rows: zod.ZodAny;
+                columns: zod.ZodArray<zod.ZodObject<{
+                    path: zod.ZodString;
+                    label: zod.ZodString;
+                }, zod_v4_core.$strip>>;
+                caption: zod.ZodNullable<zod.ZodString>;
+            }, zod_v4_core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                rows: {
+                    $state: string;
+                };
+                columns: {
+                    path: string;
+                    label: string;
+                }[];
+            };
+        };
+        Metric: {
+            props: zod.ZodObject<{
+                label: zod.ZodString;
+                value: zod.ZodAny;
+                unit: zod.ZodNullable<zod.ZodString>;
+                format: zod.ZodNullable<zod.ZodEnum<{
+                    plain: "plain";
+                    integer: "integer";
+                    decimal: "decimal";
+                    compact: "compact";
+                }>>;
+            }, zod_v4_core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                value: {
+                    $state: string;
+                };
+                unit: string;
+                format: string;
+            };
+        };
+    };
+    actions: {
+        run: {
+            params: zod.ZodObject<{}, zod_v4_core.$strip>;
+            description: string;
+        };
+    };
+}>>;
+
+/** What a page renders through: this entry's registry unless a host brings its own. */
+type PageRegistry = react.ComponentProps<typeof Renderer>['registry'];
+interface GenerativePageProps {
+    /** The layout to render; `null` while a stream has produced nothing yet. */
+    spec: Spec | null;
+    /** The state the layout binds to. The host owns it; the page reads and writes it. */
+    store: StateStore;
+    /** The descriptor the escape hatches resolve paths against. */
+    scope: DescriptorScope;
+    /** What `run` does. Receives the state at the moment the call to action was pressed. */
+    onRun?: (state: StateModel) => void;
+    /** Whether a stream is still arriving. */
+    loading?: boolean;
+    /** A registry over a catalog that extends this entry's, when a host has one. */
+    registry?: PageRegistry;
+    /**
+     * The brand the product chrome renders: the app bar's logo pair and name,
+     * the web font. Required by this entry's own registry, whose `AppBar` reads
+     * it - without one the bar throws, json-render's element boundary drops it
+     * from the page, and the console names the cure. A host registry with no
+     * brand components may omit it.
+     */
+    brand?: BrandManifest;
+}
+/**
+ * One generative page: providers, registry and renderer wired together.
+ *
+ * The store is CONTROLLED - the host creates it, seeds it (`seedInputs`) and
+ * reads it back to start the run - so what the page writes is exactly what the
+ * kernel's readiness is computed from, and generation is nowhere in the
+ * request path: a layout is a data file, and this renders it.
+ */
+declare function GenerativePage({ spec, store, scope, onRun, loading, registry, brand, }: GenerativePageProps): react.JSX.Element;
+/** The store's current state, re-rendering on every change. For a receipt beside a page. */
+declare function useStoreSnapshot(store: StateStore): StateModel;
+
+/**
+ * The registry over the product catalog: components only. `run` is supplied
+ * by `GenerativePage`, which hands it to `JSONUIProvider` as a handler closing
+ * over the host's `onRun`, or by a host's own provider; json-render's type
+ * asks for an `actions` entry because the catalog declares one, but only the
+ * `handlers` factory this destructure discards would ever read it, so the
+ * entry is stated absent rather than filled with a no-op a reader would take
+ * for the handler.
+ *
+ * Its `AppBar` reads the brand, so the page it renders in needs one:
+ * `GenerativePage`'s `brand` prop, or a `BrandProvider` above the tree.
+ */
+declare const generativeRegistry: _json_render_react.ComponentRegistry;
+
+/**
+ * What the page paints under the work column, when there is anything to paint.
+ *
+ * No spec names a result: the layout a model writes is the INPUT page, and the
+ * result has shapes of its own. So the page leaves a slot instead, and the host
+ * fills it with whatever the run yielded - the kernel's own viewer over the
+ * output descriptor, a line while the run is in flight, a failure. The slot is
+ * a React node and nothing more: this entry knows how to place it in the page's
+ * grammar and nothing about how a run is started, followed or delivered.
+ *
+ * A host that provides nothing gets a page with no result section at all, which
+ * is what an input page is before its first run.
+ */
+interface ResultSlot {
+    /** What to paint. Nothing is painted at all while this is absent or `null`. */
+    content: react.ReactNode;
+    /** The heading above it. "Result" unless the host names it. */
+    title?: string;
+}
+declare function ResultSlotProvider({ slot, children, }: {
+    slot: ResultSlot | null;
+    children: react.ReactNode;
+}): react.JSX.Element;
+/** The slot the nearest page provides, or `null` on a page with no result yet. */
+declare function useResultSlot(): ResultSlot | null;
+
+declare function BrandProvider({ manifest, children, }: {
+    manifest: BrandManifest;
+    children: react.ReactNode;
+}): react.JSX.Element;
+declare function useBrand(): BrandManifest;
+
+/**
+ * The two state trees, and how a path into either maps back onto the
+ * descriptor.
+ *
+ * An input page binds at `/inputs/<name>`, recursing into structures as the
+ * descriptor does; a result page binds at `/result/<path>`. Both are JSON
+ * Pointers (RFC 6901), because that is what json-render's state store reads.
+ * Nothing here knows a value - a path is resolved against the DESCRIPTOR, which
+ * is how the two escape hatches find the `RunField` to hand the kernel.
+ */
+declare const INPUTS_ROOT = "/inputs";
+declare const RESULT_ROOT = "/result";
+/** `/inputs` + `invoice` + `billed_to` → `/inputs/invoice/billed_to`. */
+declare function joinPath(root: string, ...segments: readonly string[]): string;
+/** The segments of a pointer, root excluded: `/inputs/a/b` under `/inputs` → `['a', 'b']`. */
+declare function segmentsUnder(root: string, path: string): string[] | undefined;
+/**
+ * The descriptor node a path names, or `undefined` when the path leaves the
+ * tree. An object's children are found by name; a list's are found by index,
+ * and every index resolves to the same item descriptor.
+ */
+declare function fieldAtSegments(fields: readonly RunField[], segments: readonly string[]): RunField | undefined;
+/** `/inputs/<...>` resolved against a form's top-level fields. */
+declare function inputFieldAtPath(fields: readonly RunField[], path: string): RunField | undefined;
+/** `/result/<...>` resolved against a result descriptor; `/result` itself is the root. */
+declare function resultFieldAtPath(field: RunField, path: string): RunField | undefined;
+/**
+ * The base path a relative hatch path resolves against, statically: the chain
+ * of `repeat`s from the root down to `key`, each contributing its list path
+ * and a first index. `undefined` outside any repeat. Mirrors what
+ * `useRepeatScope` gives the hatch at render time, for a test that never
+ * renders.
+ *
+ * The walk up the parent chain STOPS on a key it has already seen. A layout is
+ * model-produced, and an element that is its own ancestor - `children: ["self"]`
+ * at its simplest - is a shape json-render's `validateSpec` accepts without a
+ * word, so without the guard this loop never terminates. Since a host calls
+ * this through `layoutFits` precisely to decide whether an untrusted layout is
+ * safe to render, the gate hanging is worse than the layout it was asked about.
+ */
+declare function repeatBasePathOf(spec: Spec, key: string, parents?: Map<string, string>): string | undefined;
+/** A hatch's path as the layer resolves it: absolute as written, or relative to the repeat it sits in. */
+declare function absoluteHatchPath(spec: Spec, key: string, path: string, parents?: Map<string, string>): string | undefined;
+
+/**
+ * A payload, as the result tree a spec binds to at `/result`.
+ *
+ *  - a `date` becomes the ISO string (`2026-03-14`, or `2026-03-14 15:40:00`
+ *    when a time rides along), whatever envelope it arrived in;
+ *  - a `list` becomes an array whether the wire sent one or the plural
+ *    envelope `{items: [...]}`, each item loaded by the item descriptor;
+ *  - an `object` is loaded member by member, keeping any member the descriptor
+ *    does not name as it came;
+ *  - a `document` or `image` passes through verbatim: the pinned content model
+ *    is what `ResultField` reads, and its member names (`url`, `filename`) are
+ *    the ones a model would bind to anyway;
+ *  - the three native concepts the kind vocabulary cannot name (`native.Html`,
+ *    `native.Date`, `native.Composite`) pass through whole, for the escape
+ *    hatch to render - and a list of one is still a list, an array of whole
+ *    values, which is what the kernel renders when the brief delegates it;
+ *  - a scalar passes through.
+ *
+ * A top-level scalar's `contentKey` wrapper is NOT unwrapped: `ResultField`
+ * unwraps it itself, and the brief names the wrapped path (`/result/text`), so
+ * the model and the escape hatch read the same tree.
+ */
+declare function payloadToState(field: RunField, payload: unknown): unknown;
+/**
+ * The `/inputs` seed: the authored defaults, and nothing else.
+ *
+ * A defaulted field carries `defaultValue` (never the `null` a schema
+ * projection attaches to an optional field); a structure's defaults sit inside
+ * it. What is NOT seeded is an empty string or a zero for an unfilled field -
+ * the kernel's readiness treats an absent value as absent, and a seeded
+ * placeholder would count as filled.
+ */
+declare function seedInputs(fields: readonly RunField[]): Record<string, unknown>;
+
+/**
+ * A spec with its provenance - the shape every fixture takes, whoever produced
+ * it, so a story renders any of them without knowing which it holds.
+ *
+ * A spec is a payload's twin: the one artifact no projection can produce. So
+ * it follows the payload's rules - produced by a pass, committed with its
+ * provenance - plus what a spec needs and a payload does not: WHO produced it,
+ * on WHICH model, under WHAT prompt (its hash), and, when the run was given
+ * one, the creative seed and the critic loop. The stories and the comparison
+ * viewer are titled from this record and from nothing else, so a page is
+ * never labelled with a role ("authored", "generated") but with what actually
+ * made it.
+ */
+/** How a spec came to be. */
+type Producer = 
+/** The designer method, `methods/layout-design.mthds`, run on the hosted API. */
+'pipelex-method'
+/** A Claude Code subagent in a fresh context, given the method, the catalog data and the brief and nothing else. */
+ | 'claude-code-subagent'
+/** The Claude Code session working in this repo, writing the spec by hand in TypeScript. */
+ | 'claude-code-session';
+interface CriticLoop {
+    /** The model that judged the screenshots. */
+    model: string;
+    /** How many critique-and-revise rounds ran. */
+    rounds: number;
+}
+interface SpecFixture {
+    /** `results.nested_result`. */
+    pipeRef: string;
+    producer: Producer;
+    /** The model id: the one the method ran with, or the Claude Code model behind the agent. */
+    model: string;
+    /** The creative seed handed over with the brief, verbatim, when one was. */
+    seed?: string;
+    /** The critic loop the producer ran, when one did. */
+    critic?: CriticLoop;
+    /** The first twelve hex digits of the SHA-256 of the catalog prompt at the time. */
+    promptHash: string;
+    /** The day it was produced, `YYYY-MM-DD`. */
+    date: string;
+    /** The brief it was produced from, repo-relative. */
+    brief: string;
+    /** The JSONL patch lines, exactly as emitted, or as `specToJsonl` renders a hand-written spec. */
+    jsonl: string;
+    /** The compiled spec. */
+    spec: Spec;
+    /**
+     * The planner's plan, when the producer was the designer method: the
+     * intermediate the builder was handed, read from the run's working memory.
+     * It is what a person reads to see why a page has the shape it has, and it
+     * is the one stage a comparison between two runs can be made at. Absent for
+     * a producer that plans nowhere the harness can read.
+     */
+    plan?: PagePlan;
+}
+/**
+ * The id a story and a screenshot are keyed by: producer, model and the two
+ * procedures that change what a run is. `pipelex-method--gpt-5.5--seeded`.
+ */
+declare function fixtureId(fixture: Pick<SpecFixture, 'producer' | 'model' | 'seed' | 'critic'>): string;
+/**
+ * The honest title: what made the page. `Pipelex method · gpt-5.5 · with a
+ * seed`, never a role ("authored", "generated").
+ */
+declare function fixtureLabel(fixture: Pick<SpecFixture, 'producer' | 'model' | 'seed' | 'critic'>): string;
+/** The fixture a story asks for, or a loud failure: a story must never render a page it did not name. */
+declare function findFixture(fixtures: readonly SpecFixture[], pipeRef: string, id: string): SpecFixture;
+
+export { type BrandManifest, BrandProvider, type BriefSubject, COMPONENT_NAMES, COMPONENT_RENDERINGS, CUSTOM_COMPONENTS, type ComponentRendering, type CriticLoop, DESIGNER_BRIEF_CONCEPT, DESIGNER_CATALOG_CONCEPT, DescriptorProvider, type DescriptorScope, type DesignerAction, type DesignerBrief, type DesignerCatalog, type DesignerComponent, type DesignerPathEntry, GenerativePage, type GenerativePageProps, type GenerativeSpec, ICON_NAMES, INPUTS_ROOT, type LayoutDescriptor, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, type PageRegistry, type Producer, type ProductComponentName, RESULT_ROOT, type ResultSlot, ResultSlotProvider, type SpecFixture, type SpecProblem, type SpecVerdict, type ValidationCatalog, absoluteHatchPath, brandManifestSchema, catalog, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, generativeRegistry, generativeRenderers, inputBrief, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutFits, layoutProblems, pathFromDomId, payloadToState, repeatBasePathOf, resultBrief, resultFieldAtPath, seedInputs, segmentsUnder, specFromJsonl, specToJsonl, useBrand, useDescriptorScope, useResultSlot, useStoreSnapshot, validateAgainstCatalog };