@pipelex/mthds-form 0.29.0 → 0.31.0

package/dist/generative/index.d.ts

@@ -1,13 +1,14 @@
 import * as _json_render_core from '@json-render/core';
 import { Spec, StateStore, StateModel } from '@json-render/core';
+export { Spec, StateModel, StateStore, createStateStore } from '@json-render/core';
 import * as zod from 'zod';
 import { z } from 'zod';
 import { RunField } from '../core/descriptor.js';
+import { d as AppStyleId, B as BrandManifest } from '../styles-BoXPBjF4.js';
+export { o as brandManifestSchema } from '../styles-BoXPBjF4.js';
 import * as react from 'react';
 import * as _json_render_react from '@json-render/react';
 import { Components, Renderer } from '@json-render/react';
-import { B as BrandManifest } from '../manifest-DUeAWeqa.js';
-export { b as brandManifestSchema } from '../manifest-DUeAWeqa.js';
 import * as zod_v4_core from 'zod/v4/core';
 import { F as FieldEnv } from '../field-renderer-Dz03dpig.js';
 export { seedInputs } from '../core/seed.js';
@@ -16,6 +17,38 @@ import 'mthds/protocol';
 import '../core/file-formats.js';
 import '../core/sources.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 three 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.
@@ -178,6 +211,184 @@ declare const catalog: _json_render_core.Catalog<{
     }>;
 }, {
     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;
@@ -782,6 +993,8 @@ declare const catalog: _json_render_core.Catalog<{
         MthdsField: {
             props: z.ZodObject<{
                 path: z.ZodString;
+                label: z.ZodNullable<z.ZodString>;
+                hint: z.ZodNullable<z.ZodString>;
             }, z.core.$strip>;
             slots: never[];
             description: string;
@@ -806,6 +1019,11 @@ declare const catalog: _json_render_core.Catalog<{
                 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>;
@@ -863,6 +1081,16 @@ type GenerativeSpec = typeof catalog._specType;
  * 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. */
+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. 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"];
@@ -914,6 +1142,16 @@ declare const BriefSchema: z.ZodObject<{
         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>;
@@ -979,6 +1217,12 @@ declare const PathEntrySchema: z.ZodObject<{
     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
@@ -1009,18 +1253,39 @@ type DesignerComponent = Component;
 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;
+/** 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 it was handed.
+ * 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()`). 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
+ * 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 all three 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.
@@ -1037,7 +1302,117 @@ declare function designerCatalog(): DesignerCatalog;
  * 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";
+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;
+}
+/**
+ * Everything the host's two checks find wrong with a layout written for
+ * `frame`, one problem a line, in the words the repair pass reads: first the
+ * catalog's verdict against the frame's own vocabulary (`frameCatalog`), then
+ * whether it fits the descriptor (`layoutProblems`). Empty means the layout
+ * may render. A producer feeds the lines, joined, to `repair_layout` as its
+ * `problems`; a host deciding whether a stored layout renders needs only
+ * whether the list is empty.
+ */
+declare function layoutCheckProblems(spec: Spec, { frame, descriptor }: LayoutCheck): string[];
 
 /**
  * The brief: the model's view of the descriptor, as DATA.
@@ -1072,6 +1447,8 @@ declare const PROMPT_HASH = "2b2325fd1231";
 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 {
@@ -1105,74 +1482,38 @@ declare function isDelegatedInput(field: RunField): boolean;
  * 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.
+ * 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.
  */
-interface LayoutDescriptor {
-    /** The input page's top-level fields, for `/inputs/...` paths. */
-    inputs?: readonly RunField[];
-    /** The result page's descriptor, for `/result/...` paths. */
+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;
 }
-/**
- * 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;
+/** 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.
@@ -1248,6 +1589,12 @@ declare function DescriptorProvider({ scope, children, }: {
     scope: DescriptorScope;
     children: react.ReactNode;
 }): react.JSX.Element;
+/**
+ * Exported for the round-trip test only, not from the entry's index: the pair
+ * is only correct together, so a test that could see just one half of it would
+ * be no guard at all.
+ */
+declare function domIdFor(prefix: string | undefined, path: string): string;
 /**
  * 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
@@ -1793,6 +2140,8 @@ declare const generativeRenderers: Components<_json_render_core.Catalog<{
         MthdsField: {
             props: zod.ZodObject<{
                 path: zod.ZodString;
+                label: zod.ZodNullable<zod.ZodString>;
+                hint: zod.ZodNullable<zod.ZodString>;
             }, zod_v4_core.$strip>;
             slots: never[];
             description: string;
@@ -1817,6 +2166,11 @@ declare const generativeRenderers: Components<_json_render_core.Catalog<{
                 columns: zod.ZodArray<zod.ZodObject<{
                     path: zod.ZodString;
                     label: zod.ZodString;
+                    format: zod.ZodOptional<zod.ZodNullable<zod.ZodEnum<{
+                        number: "number";
+                        date: "date";
+                        text: "text";
+                    }>>>;
                 }, zod_v4_core.$strip>>;
                 caption: zod.ZodNullable<zod.ZodString>;
             }, zod_v4_core.$strip>;
@@ -1873,8 +2227,12 @@ interface GenerativePageProps {
     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;
+    /**
+     * What `run` does. Receives the state at the moment the call to action was
+     * pressed. Return the run's promise and a press while it is pending starts
+     * nothing.
+     */
+    onRun?: (state: StateModel) => void | Promise<unknown>;
     /** Whether a stream is still arriving. */
     loading?: boolean;
     /** A registry over a catalog that extends this entry's, when a host has one. */
@@ -1946,6 +2304,31 @@ declare function BrandProvider({ manifest, children, }: {
 }): react.JSX.Element;
 declare function useBrand(): BrandManifest;
 
+/**
+ * What a host's compose-then-result frame tells the frame components of a
+ * layout - the facts no descriptor carries.
+ *
+ * A layout written for the `composer` frame places the host's action row
+ * through `Composer`, and one written for the `result` frame places the
+ * host's actions through `ResultHeader`. What those rows SAY beyond the
+ * layout's own words is the host's knowledge: how long a run usually takes,
+ * what the result's actions are called and what they do. The layout names
+ * where they go; the host fills them.
+ */
+interface FrameHost {
+    /** How long a run usually takes, from the app's past runs: "Takes about 30 seconds". */
+    eta?: string;
+    /** The result's actions, primary first: "Download PDF", "Share". */
+    actions?: readonly string[];
+    /** What an action does, by its label. */
+    onAction?: (label: string) => void;
+}
+declare function FrameHostProvider({ host, children, }: {
+    host: FrameHost;
+    children: react.ReactNode;
+}): react.JSX.Element;
+declare function useFrameHost(): FrameHost;
+
 /**
  * The two state trees, and how a path into either maps back onto the
  * descriptor.
@@ -2051,6 +2434,15 @@ interface SpecFixture {
     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`. */
@@ -2070,17 +2462,20 @@ interface SpecFixture {
      */
     plan?: PagePlan;
 }
+type Provenance = Pick<SpecFixture, 'producer' | 'model' | 'seed' | 'critic' | 'frame' | 'style'>;
 /**
- * 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`.
+ * 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: Pick<SpecFixture, 'producer' | 'model' | 'seed' | 'critic'>): string;
+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: Pick<SpecFixture, 'producer' | 'model' | 'seed' | 'critic'>): string;
+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 { 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, catalog, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, generativeRegistry, generativeRenderers, inputBrief, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutFits, layoutProblems, pathFromDomId, payloadToState, repeatBasePathOf, resultBrief, resultFieldAtPath, segmentsUnder, specFromJsonl, specToJsonl, useBrand, useDescriptorScope, useResultSlot, useStoreSnapshot, validateAgainstCatalog };
+export { BrandManifest, BrandProvider, type BriefSubject, COMPONENT_NAMES, COMPONENT_RENDERINGS, COMPOSER_COMPONENTS, CUSTOM_COMPONENTS, type ComponentRendering, type CriticLoop, DESIGNER_BRIEF_CONCEPT, DESIGNER_CATALOG_CONCEPT, DescriptorProvider, type DescriptorScope, type DesignerAction, type DesignerBrief, type DesignerCatalog, type DesignerCatalogOptions, type DesignerComponent, type DesignerPathEntry, type DesignerStyle, FRAMES, FRAME_COMPONENTS, type Frame, type FrameHost, FrameHostProvider, GenerativePage, type GenerativePageProps, type GenerativeSpec, ICON_NAMES, INPUTS_ROOT, type InputBriefOptions, type LayoutCheck, type LayoutDescriptor, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, type PageRegistry, type Producer, type ProductComponentName, REPAIR_ATTEMPTS, RESULT_COMPONENTS, RESULT_ROOT, type ResultBriefOptions, type ResultSlot, ResultSlotProvider, type SpecFixture, type SpecProblem, type SpecVerdict, type ValidationCatalog, absoluteHatchPath, catalog, componentNamesFor, designerCatalog, domIdFor, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, frameCatalog, generativeRegistry, generativeRenderers, inputBrief, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutCheckProblems, layoutFits, layoutProblems, pathFromDomId, payloadToState, promptHashSubject, repeatBasePathOf, resultBrief, resultFieldAtPath, seedLine, segmentsUnder, specFromJsonl, specToJsonl, useBrand, useDescriptorScope, useFrameHost, useResultSlot, useStoreSnapshot, validateAgainstCatalog };