@pipelex/mthds-form 0.9.0 → 0.10.0

package/dist/generative/index.d.ts

@@ -10,6 +10,7 @@ import * as zod_v4_core from 'zod/v4/core';
 import { F as FieldEnv } from '../field-renderer-BSU2hMf6.js';
 import '../core/contracts.js';
 import 'mthds/protocol';
+import '../core/file-formats.js';
 
 /**
  * Whether a spec is one this catalog can render - the check every source
@@ -855,7 +856,7 @@ 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 `data/generative/ui-designer.mthds`.
+ * prose, in `methods/layout-design.mthds`.
  */
 declare const COMPONENT_NAMES: readonly string[];
 
@@ -882,6 +883,36 @@ declare const ActionSchema: z.ZodObject<{
     built_in: z.ZodBoolean;
 }, z.core.$strip>;
 type Action = z.infer<typeof ActionSchema>;
+/** The page's half of the prompt, as data: which page it is and for which pipe, every path in the state with what it is, which paths are delegated and what gates the run, and on a result page the state of one real run - rendered from the method's own descriptor and from nothing else. */
+declare const BriefSchema: z.ZodObject<{
+    side: z.ZodEnum<{
+        input: "input";
+        result: "result";
+    }>;
+    pipe_ref: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    paths: z.ZodArray<z.ZodLazy<z.ZodObject<{
+        depth: z.ZodNumber;
+        path: z.ZodString;
+        kind: z.ZodString;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        required: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        gating: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        notes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        default: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        delegated: z.ZodBoolean;
+        relative: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        item_kind: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        item_description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        item_laid_out: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strip>>>;
+    run_control: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    sample_state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+type Brief = z.infer<typeof BriefSchema>;
 /** The vocabulary a page may be made of: the components a renderer implements and the actions a page may bind to an event, each with its contract. */
 declare const CatalogSchema: z.ZodObject<{
     components: z.ZodArray<z.ZodLazy<z.ZodObject<{
@@ -925,12 +956,31 @@ declare const PagePlanSchema: z.ZodObject<{
     delegated: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
 }, z.core.$strip>;
 type PagePlan = z.infer<typeof PagePlanSchema>;
+/** One path of the state, as the brief describes it: where it is, what it holds, what it is called, what constrains it, and whether the page lays it out or hands it back to the kernel's own control. */
+declare const PathEntrySchema: z.ZodObject<{
+    depth: z.ZodNumber;
+    path: z.ZodString;
+    kind: z.ZodString;
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    required: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    gating: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    default: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    delegated: z.ZodBoolean;
+    relative: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    item_kind: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    item_description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    item_laid_out: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strip>;
+type PathEntry = z.infer<typeof PathEntrySchema>;
 
 /**
  * The catalog as the designer method's `catalog` input: the vocabulary as
  * DATA, which the method's own prompt lays out.
  *
- * The prompt a model reads is the method - `data/generative/ui-designer.mthds`
+ * 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
@@ -941,13 +991,13 @@ type PagePlan = z.infer<typeof PagePlanSchema>;
  *
  * The shapes are the method's own: codegen projects the `Catalog`,
  * `Component` and `Action` structures the bundle declares into
- * `src/generated/ui-designer/`, and the aliases below are those types. So a
+ * `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 `data/generative/ui-designer.mthds`, as codegen projects it. */
+/** 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;
@@ -963,7 +1013,7 @@ declare function designerCatalog(): DesignerCatalog;
  * which is the designer method's text and the catalog it was handed.
  *
  * The prompt is no longer one string this package renders: it is the method
- * (`data/generative/ui-designer.mthds`, every paragraph as prose) applied to
+ * (`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
@@ -983,8 +1033,43 @@ 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 = "15d195df65f3";
+declare const PROMPT_HASH = "2b2325fd1231";
 
+/**
+ * The brief: the model's view of the descriptor, as DATA.
+ *
+ * Rule 1, restated for a model. The model's input is the DESCRIPTOR, never JSON
+ * Schema: it receives the kinds, the labels, the descriptions, the choices, the
+ * presence and what gates the run - projected from `RunField[]` here, and from
+ * nowhere else, into the `Brief` structure the designer method declares. On the
+ * result side it also receives one real run's loaded state, so it can judge
+ * magnitudes, but it never sees the wire: the state it reads is what
+ * `payloadToState` produced, with the envelopes already gone.
+ *
+ * Nothing here is prose. The sentences a model reads - the headings, how a
+ * path line is worded, what "delegated" says - are the method's own, in the
+ * `render_brief` stage of `methods/layout-design.mthds`: a Jinja2 template
+ * over this value, and the one place the brief's wording is edited. What this
+ * module contributes is what only code can state: every path, flattened in
+ * reading order with its depth, its kind in words, its constraints in words,
+ * and which of them the kernel keeps. The shape is the method's own: codegen
+ * projects its `Brief` and `PathEntry` structures into
+ * `src/generated/layout-design/`, and the aliases below are those types,
+ * imported type-only so the generated schemas stay out of the entry. A field
+ * renamed in the bundle fails the type check on the literals here rather than
+ * a run.
+ *
+ * Pure, no React, and the only place the descriptor is projected for a model.
+ * What a path is marked as (delegated or not) is decided here too, so the
+ * projection, the brief and the validator agree on which paths the kernel
+ * renders.
+ */
+/** The `Brief` structure of `methods/layout-design.mthds`, as codegen projects it. */
+type DesignerBrief = Brief;
+/** One path of the brief: where it is, what it holds, what constrains it, whether the kernel keeps it. */
+type DesignerPathEntry = PathEntry;
+/** The concept a run request names for the `brief` input: the method's own, domain-qualified. */
+declare const DESIGNER_BRIEF_CONCEPT = "generative.Brief";
 interface BriefSubject {
     /** `results.nested_result`. */
     pipeRef: string;
@@ -1009,12 +1094,19 @@ interface BriefSubject {
  * 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. */
+/**
+ * On the result side, the kinds and concepts the catalog cannot show.
+ *
+ * A native value is one of them, and so is a list of one: the native
+ * predicates refuse a `list` node, because a list of dates is a list and not a
+ * date, but no catalog component reads a date's `{date, time}` either, so the
+ * kernel renders the list whole - one value per line, as the result view does.
+ */
 declare function isDelegatedResult(field: RunField): boolean;
 /** The brief for an INPUT page: the form a run is started from. */
-declare function renderInputBrief(subject: BriefSubject, fields: readonly RunField[]): string;
+declare function inputBrief(subject: BriefSubject, fields: readonly RunField[]): DesignerBrief;
 /** The brief for a RESULT page: what one run produced, laid out. */
-declare function renderResultBrief(subject: BriefSubject, field: RunField, state: unknown): string;
+declare function resultBrief(subject: BriefSubject, field: RunField, state: unknown): DesignerBrief;
 
 /**
  * Whether a stored layout still fits the descriptor it will be rendered over.
@@ -1922,7 +2014,8 @@ declare function absoluteHatchPath(spec: Spec, key: string, path: string, parent
  *    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;
+ *    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`
@@ -1956,7 +2049,7 @@ declare function seedInputs(fields: readonly RunField[]): Record<string, unknown
  */
 /** How a spec came to be. */
 type Producer = 
-/** The designer method, `data/generative/ui-designer.mthds`, run on the hosted API. */
+/** 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'
@@ -2010,4 +2103,4 @@ declare function fixtureLabel(fixture: Pick<SpecFixture, 'producer' | 'model' |
 /** The fixture a story asks for, or a loud failure: a story must never render a page it did not name. */
 declare function findFixture(fixtures: readonly SpecFixture[], pipeRef: string, id: string): SpecFixture;
 
-export { type BrandManifest, BrandProvider, type BriefSubject, COMPONENT_NAMES, COMPONENT_RENDERINGS, CUSTOM_COMPONENTS, type ComponentRendering, type CriticLoop, DESIGNER_CATALOG_CONCEPT, DescriptorProvider, type DescriptorScope, type DesignerAction, type DesignerCatalog, type DesignerComponent, GenerativePage, type GenerativePageProps, type GenerativeSpec, ICON_NAMES, INPUTS_ROOT, type LayoutDescriptor, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, type PageRegistry, type Producer, type ProductComponentName, RESULT_ROOT, type ResultSlot, ResultSlotProvider, type SpecFixture, type SpecProblem, type SpecVerdict, type ValidationCatalog, absoluteHatchPath, brandManifestSchema, catalog, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, generativeRegistry, generativeRenderers, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutFits, layoutProblems, pathFromDomId, payloadToState, renderInputBrief, renderResultBrief, repeatBasePathOf, resultFieldAtPath, seedInputs, segmentsUnder, specFromJsonl, specToJsonl, useBrand, useDescriptorScope, useResultSlot, useStoreSnapshot, validateAgainstCatalog };
+export { type BrandManifest, BrandProvider, type BriefSubject, COMPONENT_NAMES, COMPONENT_RENDERINGS, CUSTOM_COMPONENTS, type ComponentRendering, type CriticLoop, DESIGNER_BRIEF_CONCEPT, DESIGNER_CATALOG_CONCEPT, DescriptorProvider, type DescriptorScope, type DesignerAction, type DesignerBrief, type DesignerCatalog, type DesignerComponent, type DesignerPathEntry, GenerativePage, type GenerativePageProps, type GenerativeSpec, ICON_NAMES, INPUTS_ROOT, type LayoutDescriptor, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, type PageRegistry, type Producer, type ProductComponentName, RESULT_ROOT, type ResultSlot, ResultSlotProvider, type SpecFixture, type SpecProblem, type SpecVerdict, type ValidationCatalog, absoluteHatchPath, brandManifestSchema, catalog, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, generativeRegistry, generativeRenderers, inputBrief, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutFits, layoutProblems, pathFromDomId, payloadToState, repeatBasePathOf, resultBrief, resultFieldAtPath, seedInputs, segmentsUnder, specFromJsonl, specToJsonl, useBrand, useDescriptorScope, useResultSlot, useStoreSnapshot, validateAgainstCatalog };

package/dist/generative/index.js

@@ -1,9 +1,9 @@
 "use client";
-import { cn, fieldControlClass, ResultField, FieldRenderer, ToggleGroup, ToggleGroupItem, Switch, Select, SelectTrigger, SelectValue, SelectContent, SelectItem } from '../chunk-KG4IYFWI.js';
-import '../chunk-S4CB423P.js';
-import { isNativeHtmlNode, isNativeDateNode, isNativeCompositeNode, readDateContent, formatDateContent } from '../chunk-AZZAAGNX.js';
-import '../chunk-25I6JDIK.js';
-import '../chunk-2JWRG53S.js';
+import { cn, fieldControlClass, ResultField, FieldRenderer, ToggleGroup, ToggleGroupItem, Switch, Select, SelectTrigger, SelectValue, SelectContent, SelectItem } from '../chunk-G6BWZUGV.js';
+import '../chunk-4JQAJT7C.js';
+import { isNativeValueNode, readDateContent, formatDateContent, isNativeHtmlNode, isNativeDateNode, isNativeCompositeNode } from '../chunk-TID7ZN63.js';
+import '../chunk-FABY3DEY.js';
+import '../chunk-XCO6GTEC.js';
 import '../chunk-PM55AHRO.js';
 import '../chunk-GKV77RAS.js';
 import { hasOwnProp } from '../chunk-V3OV2XQT.js';
@@ -725,7 +725,7 @@ function designerCatalog() {
 }
 
 // src/generative/prompt-hash.ts
-var PROMPT_HASH = "15d195df65f3";
+var PROMPT_HASH = "2b2325fd1231";
 
 // src/generative/paths.ts
 var INPUTS_ROOT = "/inputs";
@@ -813,14 +813,14 @@ function repeatListPathOf(spec, key, parents = parentMapOf(spec)) {
 }
 
 // src/generative/brief.ts
+var DESIGNER_BRIEF_CONCEPT = "generative.Brief";
 var RUN_COMPONENT = "Cta";
 function isDelegatedInput(field) {
   return field.kind === "document" || field.kind === "image" || field.kind === "date" || field.kind === "list" || field.kind === "unknown" || field.kind === "enum" && field.options.includes("");
 }
 function isDelegatedResult(field) {
-  if (isNativeHtmlNode(field) || isNativeDateNode(field) || isNativeCompositeNode(field)) {
-    return true;
-  }
+  if (isNativeValueNode(field)) return true;
+  if (field.kind === "list" && isNativeValueNode(field.item)) return true;
   return field.kind === "document" || field.kind === "image" || field.kind === "date" || field.kind === "prose" || field.kind === "unknown";
 }
 function kindLabel(field) {
@@ -854,9 +854,6 @@ function kindLabel(field) {
       return field;
   }
 }
-function labelOf(field) {
-  return field.title && field.title !== field.name ? `${field.title} (\`${field.name}\`)` : `\`${field.name}\``;
-}
 function constraints(field) {
   const notes = [];
   if (field.kind === "number") {
@@ -883,174 +880,101 @@ function constraints(field) {
   }
   return notes;
 }
-function describe(field, path, depth, side, lines) {
-  const delegated = side === "input" ? isDelegatedInput(field) : isDelegatedResult(field);
-  const parts = [`\`${path}\` \u2014 ${kindLabel(field)}`];
-  if (side === "input") {
-    parts.push(field.required ? "required" : "optional");
-    if (field.gating) parts.push("gates the run");
-  }
-  const head = parts.join(", ");
-  const tail = [labelOf(field), field.description ?? ""].filter(Boolean).join(": ");
+function entryOf(field, path, depth, side, relative, seeded) {
   const notes = constraints(field);
-  const delegation = delegated ? ` **[delegate: ${side === "input" ? "MthdsField" : "MthdsResult"}]**` : "";
-  lines.push({
+  return {
     depth,
-    text: `${head} \u2014 ${tail}${notes.length > 0 ? ` (${notes.join("; ")})` : ""}${delegation}`
-  });
-  if (delegated) return;
+    path,
+    kind: kindLabel(field),
+    name: field.name,
+    title: field.title && field.title !== field.name ? field.title : void 0,
+    description: field.description,
+    required: side === "input" ? field.required : void 0,
+    gating: side === "input" && field.gating ? true : void 0,
+    notes: notes.length > 0 ? notes : void 0,
+    default: seeded || field.defaultValue === void 0 ? void 0 : JSON.stringify(field.defaultValue),
+    delegated: side === "input" ? isDelegatedInput(field) : isDelegatedResult(field),
+    relative: relative ? true : void 0
+  };
+}
+function describe(field, path, depth, side, entries, seeded = false) {
+  const entry = entryOf(field, path, depth, side, false, seeded);
+  entries.push(entry);
+  if (entry.delegated) return;
   if (field.kind === "object") {
+    const seededBelow = seeded || field.defaultValue !== void 0;
     for (const child of field.fields) {
-      describe(child, joinPath(path, child.name), depth + 1, side, lines);
+      describe(child, joinPath(path, child.name), depth + 1, side, entries, seededBelow);
     }
   }
   if (field.kind === "list" && side === "result") {
     const item = field.item;
+    entry.item_kind = kindLabel(item);
+    entry.item_description = item.description;
     if (item.kind === "object" && !isDelegatedResult(item)) {
-      lines.push({
-        depth: depth + 1,
-        text: `each item is a ${kindLabel(item)}${item.description ? ` (${item.description})` : ""}, with these members (paths relative to one item, for DataTable columns or $item):`
-      });
+      entry.item_laid_out = true;
       for (const child of item.fields) {
-        describeRelative(child, child.name, depth + 2, lines);
+        describeRelative(child, child.name, depth + 2, entries);
       }
-    } else {
-      lines.push({ depth: depth + 1, text: `each item is a ${kindLabel(item)}` });
     }
   }
 }
-function describeRelative(field, relativePath, depth, lines) {
-  const notes = constraints(field);
-  lines.push({
-    depth,
-    text: `\`${relativePath}\` \u2014 ${kindLabel(field)} \u2014 ${[labelOf(field), field.description ?? ""].filter(Boolean).join(": ")}${notes.length > 0 ? ` (${notes.join("; ")})` : ""}${isDelegatedResult(field) ? " (a DataTable prints it as text; delegate the whole list to MthdsResult to render it properly)" : ""}`
-  });
+function describeRelative(field, relativePath, depth, entries) {
+  const entry = entryOf(field, relativePath, depth, "result", true, false);
+  entries.push(entry);
+  if (entry.delegated) return;
   if (field.kind === "object") {
-    for (const child of field.fields)
-      describeRelative(child, joinPath(relativePath, child.name), depth + 1, lines);
-  }
-  if (field.kind === "list" && field.item.kind === "object") {
-    lines.push({ depth: depth + 1, text: `each item is a ${kindLabel(field.item)}, with:` });
-    for (const child of field.item.fields) {
-      describeRelative(child, joinPath(relativePath, "<i>", child.name), depth + 2, lines);
+    for (const child of field.fields) {
+      describeRelative(child, joinPath(relativePath, child.name), depth + 1, entries);
     }
   }
-}
-function render(lines) {
-  return lines.map((line) => `${"  ".repeat(line.depth)}- ${line.text}`).join("\n");
-}
-function collectDelegated(fields, root, side) {
-  const out = [];
-  const walk = (field, path) => {
-    const delegated = side === "input" ? isDelegatedInput(field) : isDelegatedResult(field);
-    if (delegated) {
-      out.push(`\`${path}\` (${kindLabel(field)})`);
-      return;
-    }
-    if (field.kind === "object") {
-      for (const child of field.fields) walk(child, joinPath(path, child.name));
+  if (field.kind === "list") {
+    const item = field.item;
+    entry.item_kind = kindLabel(item);
+    entry.item_description = item.description;
+    if (item.kind === "object" && !isDelegatedResult(item)) {
+      entry.item_laid_out = true;
+      for (const child of item.fields) {
+        describeRelative(child, joinPath(relativePath, "<i>", child.name), depth + 2, entries);
+      }
     }
-  };
-  for (const field of fields) walk(field, joinPath(root, field.name));
-  return out;
+  }
 }
-function collectDefaults(fields, root) {
-  const out = [];
-  const walk = (field, path) => {
-    if (field.defaultValue !== void 0) {
-      out.push(`\`${path}\` = ${JSON.stringify(field.defaultValue)}`);
-      return;
-    }
-    if (field.kind === "object") {
-      for (const child of field.fields) walk(child, joinPath(path, child.name));
-    }
+function inputBrief(subject, fields) {
+  const paths = [];
+  for (const field of fields) describe(field, joinPath(INPUTS_ROOT, field.name), 0, "input", paths);
+  return {
+    side: "input",
+    pipe_ref: subject.pipeRef,
+    description: subject.description,
+    name: subject.name,
+    paths,
+    run_control: RUN_COMPONENT
   };
-  for (const field of fields) walk(field, joinPath(root, field.name));
-  return out;
 }
-function renderInputBrief(subject, fields) {
-  const lines = [];
-  for (const field of fields) describe(field, joinPath(INPUTS_ROOT, field.name), 0, "input", lines);
-  const delegated = collectDelegated(fields, INPUTS_ROOT, "input");
-  const defaults = collectDefaults(fields, INPUTS_ROOT);
-  const gating = fields.filter((field) => field.gating).map((field) => `\`${field.name}\``);
-  return [
-    `# Input page: ${subject.pipeRef}`,
-    "",
-    subject.description ?? "A method with the inputs below.",
-    "",
-    ...subject.name ? [
-      "## Name",
-      "",
-      `The method is called \xAB${subject.name}\xBB, as the host lists it. That is the app's name wherever the layout asks for one; invent no other. Links, if the layout carries any, name this page's own sections. The page states nothing the method does not: no promise about storage, privacy, speed, or what happens after the run.`,
-      ""
-    ] : [],
-    "## State",
-    "",
-    `The form's values live under \`${INPUTS_ROOT}\`, one member per input, exactly as listed. Bind each input with \`$bindState\` at its path; a structure's members bind at their own paths beneath it.`,
-    "",
-    render(lines),
-    "",
-    "## Delegated",
-    "",
-    delegated.length > 0 ? `Render these with \`MthdsField\` at the path, and nothing else:
-
-${delegated.map((entry) => `- ${entry}`).join("\n")}` : "None: every input can be entered with the catalog's own inputs. `MthdsField` remains available for any you would rather not style.",
-    "",
-    "## Defaults",
-    "",
-    defaults.length > 0 ? `Seed these, and only these, with \`/state\` patches (\`{"op":"add","path":"/state/inputs/...","value":...}\`):
-
-${defaults.map((entry) => `- ${entry}`).join("\n")}` : "None. Emit no `/state` patches.",
-    "",
-    "## Run",
-    "",
-    gating.length > 0 ? `The run waits for ${gating.join(", ")}; say so near the ${RUN_COMPONENT}, briefly.` : "Nothing gates the run.",
-    `The page has exactly one \`${RUN_COMPONENT}\`, \`on.press\` bound to \`validateForm\` then \`run\`; label it with what the method does, in a person's words.`,
-    ""
-  ].join("\n");
-}
-function renderResultBrief(subject, field, state) {
-  const lines = [];
-  const delegatedWhole = isDelegatedResult(field);
-  if (field.kind === "object" && !delegatedWhole) {
-    lines.push({
+function resultBrief(subject, field, state) {
+  const paths = [];
+  if (field.kind === "object" && !isDelegatedResult(field)) {
+    paths.push({
       depth: 0,
-      text: `\`${RESULT_ROOT}\` \u2014 ${kindLabel(field)}${field.description ? `: ${field.description}` : ""}`
+      path: RESULT_ROOT,
+      kind: kindLabel(field),
+      description: field.description,
+      delegated: false
     });
     for (const child of field.fields) {
-      describe(child, joinPath(RESULT_ROOT, child.name), 1, "result", lines);
+      describe(child, joinPath(RESULT_ROOT, child.name), 1, "result", paths);
     }
   } else {
-    describe(field, RESULT_ROOT, 0, "result", lines);
+    describe(field, RESULT_ROOT, 0, "result", paths);
   }
-  const delegated = field.kind === "object" && !delegatedWhole ? collectDelegated(field.fields, RESULT_ROOT, "result") : delegatedWhole ? [`\`${RESULT_ROOT}\` (${kindLabel(field)})`] : [];
-  return [
-    `# Result page: ${subject.pipeRef}`,
-    "",
-    subject.description ?? "The result of a method, described below.",
-    "",
-    "## State",
-    "",
-    `The host loads the run's result under \`${RESULT_ROOT}\` before the page renders. Read every value with \`$state\`; emit no \`/state\` patches. Paths:`,
-    "",
-    render(lines),
-    "",
-    "## Delegated",
-    "",
-    delegated.length > 0 ? `Render these with \`MthdsResult\` at the path - they are kinds the catalog cannot show properly:
-
-${delegated.map((entry) => `- ${entry}`).join("\n")}` : "None. `MthdsResult` remains available for any structure you choose not to lay out.",
-    "",
-    "## One real run, as loaded",
-    "",
-    "The state of one actual run, so you can judge magnitudes and lengths. Bind to the paths; do not copy these values into the spec.",
-    "",
-    "```json",
-    JSON.stringify(state, null, 2),
-    "```",
-    ""
-  ].join("\n");
+  return {
+    side: "result",
+    pipe_ref: subject.pipeRef,
+    description: subject.description,
+    paths,
+    sample_state: JSON.stringify(state, null, 2)
+  };
 }
 var EXPRESSION_KEYS = [
   "$state",
@@ -3082,9 +3006,7 @@ function isRecord(value) {
 }
 function payloadToState(field, payload) {
   if (payload === void 0 || payload === null) return payload;
-  if (isNativeHtmlNode(field) || isNativeDateNode(field) || isNativeCompositeNode(field)) {
-    return payload;
-  }
+  if (isNativeValueNode(field)) return payload;
   switch (field.kind) {
     case "date": {
       const content = readDateContent(payload);
@@ -3166,6 +3088,6 @@ function findFixture(fixtures, pipeRef, id) {
   return found;
 }
 
-export { BrandProvider, COMPONENT_NAMES, COMPONENT_RENDERINGS, CUSTOM_COMPONENTS, DESIGNER_CATALOG_CONCEPT, DescriptorProvider, GenerativePage, ICON_NAMES, INPUTS_ROOT, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, RESULT_ROOT, ResultSlotProvider, absoluteHatchPath, brandManifestSchema, catalog, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, generativeRegistry, generativeRenderers, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutFits, layoutProblems, pathFromDomId, payloadToState, renderInputBrief, renderResultBrief, repeatBasePathOf, resultFieldAtPath, seedInputs, segmentsUnder, specFromJsonl, specToJsonl, useBrand, useDescriptorScope, useResultSlot, useStoreSnapshot, validateAgainstCatalog };
+export { BrandProvider, COMPONENT_NAMES, COMPONENT_RENDERINGS, CUSTOM_COMPONENTS, DESIGNER_BRIEF_CONCEPT, DESIGNER_CATALOG_CONCEPT, DescriptorProvider, GenerativePage, ICON_NAMES, INPUTS_ROOT, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, RESULT_ROOT, ResultSlotProvider, absoluteHatchPath, brandManifestSchema, catalog, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, generativeRegistry, generativeRenderers, inputBrief, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutFits, layoutProblems, pathFromDomId, payloadToState, repeatBasePathOf, resultBrief, resultFieldAtPath, seedInputs, segmentsUnder, specFromJsonl, specToJsonl, useBrand, useDescriptorScope, useResultSlot, useStoreSnapshot, validateAgainstCatalog };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map