@pipelex/mthds-form 0.31.0 → 0.33.0

package/dist/generative/headless/index.d.ts

@@ -0,0 +1,1733 @@
+import * as _json_render_core from '@json-render/core';
+import { Spec } from '@json-render/core';
+export { Spec } from '@json-render/core';
+import { z } from 'zod';
+import { RunField } from '../../core/descriptor.js';
+import { d as AppStyleId } from '../../styles-Bn8byNdo.js';
+import '../../core/contracts.js';
+import 'mthds/protocol';
+import '../../core/file-formats.js';
+
+/**
+ * The frames a layout is written for, and the vocabulary each adds.
+ *
+ * `page` is a whole product page of its own, the frame every layout had
+ * before a host drew one around it. `composer` and `result` are the two
+ * moments of a host's compose-then-result app: the inputs before a run, in a
+ * centred column whose host draws the band above it and the action row's
+ * mechanics, and the result after one, under the host's bar restating the
+ * request. The two moments carry their own components, found by measuring the
+ * designer against hand-drawn screens of several methods: the composer's frame
+ * (`Composer`, with the page's h1, the panel and the host's action row) and a
+ * group of inputs inside it, and a result's header, a proportion bar, colour
+ * swatches, a picture, a fact, a labelled detail, a date in words and a list
+ * of short texts. A date range, chips for a list of texts and compact rows
+ * for a list of structures were found too, and went to the kernel's own
+ * controls instead, since they improve the plain form as much as a designed
+ * one: a composer delegates those inputs to `MthdsField`.
+ *
+ * Zod only, importable from node: `designerCatalog()` renders these into the
+ * data the designer method takes. Each description says what the component IS
+ * and how it renders, never where a page must put it.
+ */
+/** The frame a layout is written for: a whole product page, or one of the two moments of a host's compose-then-result app. */
+declare const FRAMES: readonly ["page", "composer", "result"];
+type Frame = (typeof FRAMES)[number];
+/** The components the composer frame adds to the catalog. */
+declare const COMPOSER_COMPONENTS: readonly ["Composer", "FieldGroup"];
+/** The components the result frame adds to the catalog. */
+declare const RESULT_COMPONENTS: readonly ["ResultHeader", "ProportionBar", "Swatches", "Picture", "Fact", "Detail", "DateText", "TextList"];
+/** Every component a frame adds, which the `page` frame's vocabulary leaves out. */
+declare const FRAME_COMPONENTS: readonly ["Composer", "FieldGroup", "ResultHeader", "ProportionBar", "Swatches", "Picture", "Fact", "Detail", "DateText", "TextList"];
+
+/**
+ * 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: {
+        Composer: {
+            props: z.ZodObject<{
+                headline: z.ZodString;
+                lede: z.ZodNullable<z.ZodString>;
+                runLabel: z.ZodString;
+                columns: z.ZodNullable<z.ZodEnum<{
+                    1: "1";
+                    2: "2";
+                }>>;
+                notes: z.ZodNullable<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            slots: string[];
+            events: string[];
+            description: string;
+            example: {
+                headline: string;
+                lede: string;
+                runLabel: string;
+                columns: string;
+            };
+        };
+        FieldGroup: {
+            props: z.ZodObject<{
+                title: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: string[];
+            description: string;
+            example: {
+                title: string;
+            };
+        };
+        ResultHeader: {
+            props: z.ZodObject<{
+                eyebrow: z.ZodNullable<z.ZodString>;
+                title: z.ZodString;
+                subtitle: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                eyebrow: string;
+                title: {
+                    $state: string;
+                };
+                subtitle: {
+                    $template: string;
+                };
+            };
+        };
+        ProportionBar: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                total: z.ZodNullable<z.ZodNumber>;
+                of: z.ZodNullable<z.ZodNumber>;
+                unit: z.ZodNullable<z.ZodString>;
+                items: z.ZodNullable<z.ZodArray<z.ZodAny>>;
+                labelKey: z.ZodString;
+                valueKey: z.ZodString;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                total: {
+                    $state: string;
+                };
+                unit: {
+                    $state: string;
+                };
+                items: {
+                    $state: string;
+                };
+                labelKey: string;
+                valueKey: string;
+            };
+        };
+        Swatches: {
+            props: z.ZodObject<{
+                colors: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                colors: {
+                    $item: string;
+                }[];
+            };
+        };
+        Picture: {
+            props: z.ZodObject<{
+                path: z.ZodString;
+                alt: z.ZodNullable<z.ZodString>;
+                aspect: z.ZodNullable<z.ZodEnum<{
+                    "1:1": "1:1";
+                    "16:9": "16:9";
+                    "4:3": "4:3";
+                    auto: "auto";
+                }>>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                path: string;
+                alt: string;
+                aspect: string;
+            };
+        };
+        Fact: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodAny;
+                detail: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                value: {
+                    $state: string;
+                };
+            };
+        };
+        DateText: {
+            props: z.ZodObject<{
+                value: z.ZodNullable<z.ZodString>;
+                style: z.ZodNullable<z.ZodEnum<{
+                    long: "long";
+                    short: "short";
+                    weekday: "weekday";
+                }>>;
+                tone: z.ZodNullable<z.ZodEnum<{
+                    default: "default";
+                    muted: "muted";
+                    accent: "accent";
+                }>>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                value: {
+                    $item: string;
+                };
+                style: string;
+                tone: string;
+            };
+        };
+        TextList: {
+            props: z.ZodObject<{
+                items: z.ZodNullable<z.ZodArray<z.ZodString>>;
+                marker: z.ZodNullable<z.ZodEnum<{
+                    number: "number";
+                    check: "check";
+                    bullet: "bullet";
+                }>>;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                items: {
+                    $state: string;
+                };
+                marker: string;
+            };
+        };
+        Detail: {
+            props: z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodAny;
+            }, z.core.$strip>;
+            slots: never[];
+            description: string;
+            example: {
+                label: string;
+                value: {
+                    $item: string;
+                };
+            };
+        };
+        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;
+                label: z.ZodNullable<z.ZodString>;
+                hint: z.ZodNullable<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;
+                    format: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                        number: "number";
+                        date: "date";
+                        text: "text";
+                    }>>>;
+                }, 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 component names a layout written for `frame` may use, in the order the
+ * designer method lists them. Frozen, like the catalog `frameCatalog` builds
+ * over them: both are shared by every check, so a caller that edited one
+ * would change what every later check accepts.
+ */
+declare function componentNamesFor(frame: Frame): readonly string[];
+/**
+ * The catalog a layout written for `frame` is validated against: the same
+ * definitions and renderings as `catalog`, held to the frame's vocabulary.
+ * Built once per frame and shared, so it is frozen with its vocabulary. A
+ * composer that names an `AppBar` is refused here as an unknown component,
+ * though the entry's registry could render one, because the host's frame
+ * already draws what it stands for.
+ */
+declare function frameCatalog(frame: Frame): ValidationCatalog;
+
+/** 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>>;
+    returns: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    frame: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        page: "page";
+        composer: "composer";
+        result: "result";
+    }>>>;
+    style: z.ZodOptional<z.ZodNullable<z.ZodLazy<z.ZodObject<{
+        name: z.ZodString;
+        direction: z.ZodString;
+    }, z.core.$strip>>>>;
+    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>;
+/** An app style: a named look the components draw - faces, weights, radii, panels and rhythm - and the one sentence that says what it is, which the composition follows. */
+declare const StyleSchema: z.ZodObject<{
+    name: z.ZodString;
+    direction: z.ZodString;
+}, z.core.$strip>;
+type Style = z.infer<typeof StyleSchema>;
+
+/**
+ * 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";
+/** What a catalog is built for. */
+interface DesignerCatalogOptions {
+    /**
+     * The frame the layout is written for: `page` (the default), a whole
+     * product page; `composer` or `result`, a moment of a host's
+     * compose-then-result app, whose vocabulary leaves out what that host draws
+     * and adds the frame's own components (`componentNamesFor`).
+     */
+    frame?: Frame;
+}
+/**
+ * The catalog as the designer method's `catalog` input, for one frame. The
+ * same frame's `frameCatalog` is what the layout it produces is validated
+ * against, so the vocabulary a model was shown and the one it is held to are
+ * one list.
+ */
+declare function designerCatalog({ frame }?: DesignerCatalogOptions): 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 of every frame.
+ *
+ * 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({ frame })`). 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. A run
+ * is given the catalog of one frame, and the hash covers every frame's in a
+ * fixed order: one pin a host compares every stored layout with, whichever
+ * frame it was written for, and which any frame's vocabulary moving moves. The frame a
+ * layout was written for is its own provenance, beside the hash. The brief is
+ * not hashed: it is the per-method half, recorded with each layout. 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 = "30cf9bc059f6";
+/**
+ * What the hash is computed over: the method's text as shipped, then the
+ * catalog of each frame as a run request carries it, in `FRAMES` order. The
+ * one recipe the test, the fixture pass and a host's producer share, so the
+ * pin they check and the stamp they write agree: a producer that runs the
+ * method off a checkout hashes this string (SHA-256, the first twelve hex
+ * digits) and compares it with `PROMPT_HASH` before it spends anything. It is
+ * a string rather than the hash so the entry stays free of a hashing
+ * dependency and importable from a browser.
+ */
+declare function promptHashSubject(method: string): string;
+
+/**
+ * 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;
+
+/**
+ * What a producer of layouts needs beside the method, the catalog and the
+ * brief: the line a creative seed travels as, the checks a produced layout is
+ * held to, and how many times a refused one goes back to the method's repair
+ * pass. Nothing here calls a model; the producer is the host's, on the far
+ * side of this seam (docs/generative-ui.md, "Producing a layout").
+ */
+/**
+ * The one line a creative seed reaches the designer method as, under its
+ * `seed` input. The planner's seed procedure was written against this line,
+ * so a host that hands the method a seed sends it, rather than restating it.
+ */
+declare function seedLine(seed: string): string;
+/**
+ * How many times a producer hands a refused layout to the method's
+ * `repair_layout` pass before it gives up and the host keeps the plain form.
+ * The refusals the designer makes are slips of one prop or one heading, which
+ * one pass told what it broke fixes; a second covers a fix that broke a rule
+ * of its own, and a third would be paying for a page that is not converging.
+ */
+declare const REPAIR_ATTEMPTS = 2;
+/** What a layout is checked against: the frame it was written for and the descriptor it binds. */
+interface LayoutCheck {
+    frame: Frame;
+    descriptor: LayoutDescriptor;
+}
+/**
+ * The checks' answer on a layout: every problem they found, one a line, and
+ * whether they themselves failed on it.
+ */
+interface LayoutVerdict {
+    /** Every problem, one a line, in the words the repair pass reads; empty means the layout may render. */
+    problems: string[];
+    /**
+     * Whether a check threw on a layout of the right shape: a defect in the
+     * checks, stated among the problems in a line of its own. The layout is
+     * refused all the same - the host keeps the plain form - but a producer
+     * stops here instead of handing the lines to the repair pass, which can
+     * change the layout and not the checks.
+     */
+    checksFailed: boolean;
+}
+/**
+ * Everything the host's two checks find wrong with a layout written for
+ * `frame`, and whether the checks themselves failed on it: first the
+ * catalog's verdict against the frame's own vocabulary (`frameCatalog`), then
+ * whether it fits the descriptor (`layoutProblems`). Empty problems mean the
+ * layout may render. A producer feeds the lines, joined, to `repair_layout`
+ * as its `problems`, unless `checksFailed` says no repair can help; a host
+ * deciding whether a stored layout renders needs only whether the list is
+ * empty, which `layoutCheckProblems` answers alone.
+ *
+ * It never throws. Its subject is whatever a model wrote, or a layout and a
+ * frame a host stored and read back, and a throw is the one answer a host
+ * cannot act on: it arrives instead of the problem that would have sent the
+ * page to its fallback. So a frame this package does not draw, a missing or
+ * misshapen descriptor, and anything not shaped like a spec are each a
+ * problem line, and a throw left in a walk below on a layout of the right
+ * shape is the checks' own failure: a line saying so, and `checksFailed`.
+ * The shape is checked once, before either check walks the layout.
+ */
+declare function layoutCheck(spec: Spec, { frame, descriptor }: LayoutCheck): LayoutVerdict;
+/**
+ * Everything the host's two checks find wrong with a layout written for
+ * `frame`, one problem a line: `layoutCheck`'s problems alone, for a host
+ * that needs only whether a stored layout renders. Never throws.
+ */
+declare function layoutCheckProblems(spec: Spec, check: LayoutCheck): string[];
+
+/**
+ * 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 style a brief carries: its name and its direction, as `APP_STYLES` states them. */
+type DesignerStyle = Style;
+/** 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.
+ *
+ * The result frame's vocabulary shows two of them itself: a picture
+ * (`Picture`) and a date in words (`DateText`), so on a result page written
+ * for that frame neither is delegated. A date with a time stays delegated:
+ * `DateText` writes the day alone, and the kernel's result shows the time.
+ */
+declare function isDelegatedResult(field: RunField, frame?: Frame): boolean;
+/** How an input page's brief is built: the frame it is written for, the team's style, and what a run returns. */
+interface InputBriefOptions {
+    /** `page` (the default), a whole product page; `composer`, the inputs of a host's compose-then-result app. */
+    frame?: Extract<Frame, 'page' | 'composer'>;
+    /**
+     * The style the team's apps wear. The brief carries its name and its
+     * direction, which the composition follows; its faces, radii and panels are
+     * the components' to draw and never reach the brief. Absent, the brief
+     * names no style.
+     */
+    style?: AppStyleId;
+    /** The result's descriptor, from which a composer's brief says what one run gives back. */
+    result?: RunField;
+}
+/** How a result page's brief is built: the frame it is written for and the team's style. */
+interface ResultBriefOptions {
+    /** `page` (the default), a whole product page; `result`, the result page of a host's compose-then-result app. */
+    frame?: Extract<Frame, 'page' | 'result'>;
+    /** The style the team's apps wear (see `InputBriefOptions.style`). */
+    style?: AppStyleId;
+}
+/** The brief for an INPUT page: the form a run is started from. */
+declare function inputBrief(subject: BriefSubject, fields: readonly RunField[], { frame, style, result }?: InputBriefOptions): DesignerBrief;
+/** The brief for a RESULT page: what one run produced, laid out. */
+declare function resultBrief(subject: BriefSubject, field: RunField, state: unknown, { frame, style }?: ResultBriefOptions): DesignerBrief;
+
+/**
+ * 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[];
+
+/**
+ * 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;
+
+/**
+ * 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 frame it was written for, when not a whole product page: `composer` or `result`. */
+    frame?: Exclude<Frame, 'page'>;
+    /** The style the brief carried, when it carried one. */
+    style?: AppStyleId;
+    /**
+     * How many times the method's repair pass re-emitted it before it passed
+     * the checks, when it needed any: the page as stored is the last pass's.
+     */
+    repairs?: number;
+    /** 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;
+}
+type Provenance = Pick<SpecFixture, 'producer' | 'model' | 'seed' | 'critic' | 'frame' | 'style'>;
+/**
+ * The id a story and a screenshot are keyed by: producer, model, the frame and
+ * the style it was written for, and the two procedures that change what a run
+ * is. `pipelex-method--gpt-5.5--seeded`,
+ * `pipelex-method--gpt-6.1-sol--composer--soft--seeded`.
+ */
+declare function fixtureId(fixture: Provenance): 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: Provenance & Pick<SpecFixture, 'repairs'>): 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 BriefSubject, COMPONENT_NAMES, COMPONENT_RENDERINGS, COMPOSER_COMPONENTS, CUSTOM_COMPONENTS, type ComponentRendering, type CriticLoop, DESIGNER_BRIEF_CONCEPT, DESIGNER_CATALOG_CONCEPT, type DesignerAction, type DesignerBrief, type DesignerCatalog, type DesignerCatalogOptions, type DesignerComponent, type DesignerPathEntry, type DesignerStyle, FRAMES, FRAME_COMPONENTS, type Frame, type GenerativeSpec, ICON_NAMES, INPUTS_ROOT, type InputBriefOptions, type LayoutCheck, type LayoutDescriptor, type LayoutVerdict, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, type Producer, type ProductComponentName, REPAIR_ATTEMPTS, RESULT_COMPONENTS, RESULT_ROOT, type ResultBriefOptions, type SpecFixture, type SpecProblem, type SpecVerdict, type ValidationCatalog, absoluteHatchPath, catalog, componentNamesFor, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, frameCatalog, inputBrief, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutCheck, layoutCheckProblems, layoutFits, layoutProblems, payloadToState, promptHashSubject, repeatBasePathOf, resultBrief, resultFieldAtPath, seedLine, segmentsUnder, specFromJsonl, specToJsonl, validateAgainstCatalog };