@pipelex/mthds-form 0.32.0 → 0.33.0

package/README.md

@@ -4,7 +4,7 @@ The input form for MTHDS methods, as a library: a headless kernel that maps the
 
 It exists because "the form" is one problem that keeps being solved separately. A method declares its inputs; something has to decide what widget each input deserves, whether the Run button may light up, what shape the values take on the wire, and what a validation failure says to a person. That logic belongs in one place with tests around it, not copied into each surface that happens to need a form.
 
-## Five entry points
+## Entry points
 
 ```ts
 import { buildRunFields, computeReadiness } from '@pipelex/mthds-form'; // headless

package/dist/{chunk-VBXFGUCG.js → chunk-4SRSGZWM.js}

@@ -778,59 +778,77 @@ var COMPONENT_NAMES = [
   ...CUSTOM_COMPONENTS,
   ...PRODUCT_COMPONENTS
 ];
-var FRAME_EXCLUDED = {
-  page: [...FRAME_COMPONENTS],
-  composer: [
-    "AppBar",
-    "Footer",
-    "Workspace",
-    "Rail",
-    "Cta",
-    "Button",
-    "Hero",
-    "SummaryRow",
-    "MthdsResult",
-    "DataTable",
-    "Metric",
-    "Progress",
-    // `TextList` stays: a composer may list short texts too, such as what a
-    // run gives back.
-    ...RESULT_COMPONENTS.filter((name) => name !== "TextList")
-  ],
-  result: [
-    "AppBar",
-    "Footer",
-    "Workspace",
-    "Rail",
-    "Cta",
-    "Button",
-    "Hero",
-    "MthdsField",
+var FRAME_VOCABULARIES = {
+  composer: Object.freeze([
+    "Card",
+    "Stack",
+    "Grid",
+    "Separator",
+    "Heading",
+    "Text",
+    "Badge",
+    "Alert",
+    "Collapsible",
+    "Avatar",
     "Input",
     "Textarea",
     "Select",
     "Radio",
     "Checkbox",
     "Switch",
+    "Split",
+    "Tabs",
+    "Steps",
+    "Icon",
     "Segmented",
     "NumberInput",
-    "Steps",
-    ...COMPOSER_COMPONENTS
-  ]
+    "MthdsField",
+    "Section",
+    ...COMPOSER_COMPONENTS,
+    "TextList"
+  ]),
+  result: Object.freeze([
+    "Card",
+    "Stack",
+    "Grid",
+    "Separator",
+    "Heading",
+    "Text",
+    "Badge",
+    "Alert",
+    "Collapsible",
+    "Progress",
+    "Avatar",
+    "Split",
+    "Tabs",
+    "Icon",
+    "MthdsResult",
+    "DataTable",
+    "Metric",
+    "Section",
+    "SummaryRow",
+    ...RESULT_COMPONENTS
+  ])
 };
+var PAGE_VOCABULARY = Object.freeze(
+  COMPONENT_NAMES.filter((name) => !FRAME_COMPONENTS.includes(name))
+);
 function componentNamesFor(frame) {
-  const excluded = new Set(FRAME_EXCLUDED[frame]);
-  const own = frame === "page" ? [] : [...FRAME_COMPONENTS];
-  return [...COMPONENT_NAMES, ...own].filter((name) => !excluded.has(name));
+  return frame === "page" ? PAGE_VOCABULARY : FRAME_VOCABULARIES[frame];
 }
+var frameCatalogs = /* @__PURE__ */ new Map();
 function frameCatalog(frame) {
-  return {
+  const built = frameCatalogs.get(frame);
+  if (built) return built;
+  const made = Object.freeze({
     componentNames: componentNamesFor(frame),
     actionNames: catalog.actionNames,
     data: catalog.data,
     schema: catalog.schema,
     renders: COMPONENT_RENDERINGS
-  };
+  });
+  frameCatalogs.set(frame, made);
+  return made;
 }
 
 // src/generative/props-signature.ts
@@ -917,18 +935,106 @@ ${JSON.stringify(catalogs)}`;
 }
 
 // src/generative/expressions.ts
-var EXPRESSION_KEYS = [
-  "$state",
-  "$item",
-  "$index",
-  "$bindState",
-  "$bindItem",
-  "$cond",
-  "$computed",
-  "$template"
-];
 function isExpression(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).some((key) => EXPRESSION_KEYS.includes(key));
+  return expressionForm(value) !== void 0;
+}
+function expressionForm(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  if (typeof record.$state === "string") return "$state";
+  if (typeof record.$item === "string") return "$item";
+  if (record.$index === true) return "$index";
+  if (typeof record.$bindState === "string") return "$bindState";
+  if (typeof record.$bindItem === "string") return "$bindItem";
+  if ("$cond" in record && "$then" in record && "$else" in record) return "$cond";
+  if (typeof record.$computed === "string") return "$computed";
+  if (typeof record.$template === "string") return "$template";
+  return void 0;
+}
+function condBranches(value) {
+  if (expressionForm(value) !== "$cond") return void 0;
+  const record = value;
+  return [record.$then, record.$else];
+}
+
+// src/generative/share-amount.ts
+function shareAmount(raw) {
+  if (typeof raw === "number") return raw;
+  if (typeof raw === "string" && raw.trim() !== "") return Number(raw);
+  return Number.NaN;
+}
+
+// src/generative/spec-shape.ts
+function shown(value) {
+  if (Array.isArray(value)) return "a list";
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "symbol" || typeof value === "function") return `a ${typeof value}`;
+  try {
+    return String(JSON.stringify(value ?? null));
+  } catch {
+    return "a value that cannot be written out";
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function specMalformation(spec) {
+  if (!isRecord(spec)) return `it is ${shown(spec)}, not a structure`;
+  if (!isRecord(spec.elements)) return 'it has no "elements" map';
+  for (const [key, element] of Object.entries(spec.elements)) {
+    const at = JSON.stringify(key);
+    if (!isRecord(element)) return `the element ${at} is not a structure`;
+    const { type, props, children, slots, repeat } = element;
+    if (typeof type !== "string") return `the element ${at} names no component "type"`;
+    if (props != null && !isRecord(props))
+      return `the element ${at} has "props" that are not a structure`;
+    if (children != null && !Array.isArray(children))
+      return `the element ${at} has "children" that are not a list`;
+    if (slots != null && (!isRecord(slots) || !Object.values(slots).every(Array.isArray))) {
+      return `the element ${at} has "slots" that are not lists`;
+    }
+    if (repeat !== void 0 && !repeatsOver(repeat)) {
+      return `the element ${at} has a "repeat" that names no "statePath"`;
+    }
+  }
+  return void 0;
+}
+function repeatsOver(repeat) {
+  if (!isRecord(repeat)) return false;
+  const { statePath } = repeat;
+  return typeof statePath === "string" || isRecord(statePath) && typeof statePath.$item === "string";
+}
+function malformedLine(what) {
+  return `the layout is not a well-formed spec: ${what}`;
+}
+function checksFailedLine(error) {
+  let said;
+  try {
+    said = String(error);
+  } catch {
+    said = "an error that cannot be written out";
+  }
+  return `the checks failed on this layout (${said}): a defect in the checks, which no repair of the layout can fix`;
+}
+
+// src/generative/zod-definition.ts
+function definitionOf2(schema) {
+  if (typeof schema !== "object" || schema === null) return void 0;
+  return schema._zod?.def;
+}
+function definitionChain(schema) {
+  const chain = [];
+  let def = definitionOf2(schema);
+  for (let depth = 0; depth < 8 && def; depth += 1) {
+    chain.push(def);
+    if (def.innerType === void 0) return chain;
+    def = definitionOf2(def.innerType);
+  }
+  return [];
+}
+function unwrapped(schema) {
+  const chain = definitionChain(schema);
+  return chain[chain.length - 1];
 }
 
 // src/generative/paths.ts
@@ -1017,6 +1123,7 @@ function repeatListPathOf(spec, key, parents = parentMapOf(spec)) {
 }
 
 // src/generative/layout-fits.ts
+var MAX_COND_DEPTH = 8;
 function isUnder(root, path) {
   return path === root || path.startsWith(`${root}/`);
 }
@@ -1095,13 +1202,15 @@ function staleRepeats(spec, parents, root, fieldAt, side) {
   }
   return problems;
 }
+function withArticle(word) {
+  return `${/^["']?[aeiou]/i.test(word) ? "an" : "a"} ${word}`;
+}
 function memberWords(name) {
-  return `${/^[aeiou]/i.test(name) ? "an" : "a"} ${JSON.stringify(name)}`;
+  return withArticle(JSON.stringify(name));
 }
 function kindWords(kind) {
-  if (kind === "object") return "a structure";
-  if (kind === "document" || kind === "image") return "a file";
-  return `${/^[aeiou]/i.test(kind) ? "an" : "a"} ${kind} value`;
+  const wrong = hasOwnProp(NOT_A_VALUE, kind) ? NOT_A_VALUE[kind] : void 0;
+  return wrong ? wrong.what : withArticle(`${kind} value`);
 }
 var NOT_A_VALUE = {
   object: { what: "a structure", instead: "a structure is shown through its members" },
@@ -1135,16 +1244,6 @@ function listProps() {
   return found;
 }
 var VALUE_SCHEMAS = /* @__PURE__ */ new Set(["string", "number", "boolean", "enum", "literal"]);
-function unwrapped(schema) {
-  let current = schema;
-  for (let depth = 0; depth < 8; depth += 1) {
-    const def = current.def;
-    if (!def) return void 0;
-    if (def.innerType === void 0) return def;
-    current = def.innerType;
-  }
-  return void 0;
-}
 function listItemsOf(schema) {
   const def = unwrapped(schema);
   if (def?.type !== "array") return void 0;
@@ -1214,27 +1313,84 @@ function nonScalarReads(spec, parents, root, fieldAt) {
         );
       }
     };
+    const readPath = (value) => {
+      const form = expressionForm(value);
+      const record = value;
+      if (form === "$state" || form === "$bindState") return record[form];
+      if (form === "$item" || form === "$bindItem") return itemPath(record[form]);
+      return void 0;
+    };
+    const readsIndex = (value) => expressionForm(value) === "$index";
+    const outcomes = (value, depth = 0) => {
+      const branches = depth < MAX_COND_DEPTH ? condBranches(value) : void 0;
+      return branches ? branches.flatMap((branch) => outcomes(branch, depth + 1)) : [value];
+    };
     const inlineShares = (entries) => {
       if (element.type !== "ProportionBar") return entries;
       const { labelKey, valueKey } = element.props ?? {};
       if (typeof labelKey !== "string" || typeof valueKey !== "string") return entries;
-      const how = `each part is written as a structure with ${memberWords(labelKey)} member and ${memberWords(valueKey)} member, or the whole list is read with { "$state" }`;
-      return entries.filter((entry, index) => {
-        const part = `${key}: ProportionBar's part ${index + 1}`;
+      const how = `each part is written as a structure with ${memberWords(labelKey)} member and ${memberWords(valueKey)} member holding a number, or the whole list is read with { "$state" }`;
+      const amountRefused = (part, amount) => {
+        if (Number.isFinite(shareAmount(amount)) || readsIndex(amount)) return false;
+        const path = readPath(amount);
+        if (path === void 0) {
+          const shown2 = isExpression(amount) ? "an expression that reads no number" : String(JSON.stringify(amount ?? null));
+          problems.push(`${part}'s ${JSON.stringify(valueKey)} is ${shown2}, not a number; ${how}`);
+          return true;
+        }
+        const field = isUnder(root, path) ? fieldAt(path) : void 0;
+        if (field && field.kind !== "number" && field.kind !== "unknown") {
+          problems.push(
+            `${part}'s ${JSON.stringify(valueKey)} reads ${path}, which holds ${kindWords(field.kind)}, not a number; ${how}`
+          );
+          return true;
+        }
+        return false;
+      };
+      const sharePart = (part, entry) => {
         if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-          const shown = Array.isArray(entry) ? "a list" : String(JSON.stringify(entry ?? null));
-          problems.push(`${part} is ${shown}, not a structure; ${how}`);
-          return false;
+          const shown2 = Array.isArray(entry) ? "a list" : String(JSON.stringify(entry ?? null));
+          problems.push(`${part} is ${shown2}, not a structure; ${how}`);
+          return [];
         }
         if (isExpression(entry)) {
-          problems.push(`${part} is an expression, not a structure; ${how}`);
-          return false;
+          const path = readPath(entry);
+          if (path === void 0) {
+            problems.push(`${part} is an expression that reads no structure; ${how}`);
+            return [];
+          }
+          const field = isUnder(root, path) ? fieldAt(path) : void 0;
+          if (!field || field.kind === "unknown") return [];
+          if (field.kind !== "object") {
+            problems.push(`${part} reads ${path}, which holds ${kindWords(field.kind)}; ${how}`);
+            return [];
+          }
+          for (const name of [labelKey, valueKey]) {
+            const member = field.fields.find((m) => m.name === name);
+            if (!member) {
+              problems.push(
+                `${part} reads ${path}, which has no ${JSON.stringify(name)} member; ${how}`
+              );
+            } else if (name === valueKey && member.kind !== "number" && member.kind !== "unknown") {
+              problems.push(
+                `${part} reads ${path}, whose ${JSON.stringify(name)} member holds ${kindWords(member.kind)}, not a number; ${how}`
+              );
+            }
+          }
+          return [];
         }
         const missing = [labelKey, valueKey].find((name) => !hasOwnProp(entry, name));
         if (missing !== void 0) {
           problems.push(`${part} has no ${JSON.stringify(missing)} member; ${how}`);
+          return [entry];
         }
-        return true;
+        const { [valueKey]: amount, ...rest } = entry;
+        const refused = outcomes(amount).map((outcome) => amountRefused(part, outcome)).some(Boolean);
+        return refused ? [rest] : [entry];
+      };
+      return entries.flatMap((entry, index) => {
+        const part = `${key}: ProportionBar's part ${index + 1}`;
+        return outcomes(entry).flatMap((outcome) => sharePart(part, outcome));
       });
     };
     const walk = (prop, value) => {
@@ -1324,10 +1480,38 @@ function uncoveredUnder(field, path, offered) {
   return [path];
 }
 function layoutProblems(descriptor, spec) {
+  const misshapen = descriptorMalformation(descriptor);
+  if (misshapen !== void 0) return [misshapen];
+  const malformed = specMalformation(spec);
+  if (malformed !== void 0) return [malformedLine(malformed)];
+  return fitCheck(descriptor, spec).problems;
+}
+function descriptorMalformation(descriptor) {
+  if (typeof descriptor !== "object" || descriptor === null) {
+    return "the layout has no descriptor to be checked against";
+  }
+  const { inputs, result } = descriptor;
+  if (inputs != null && !Array.isArray(inputs)) {
+    return `the descriptor's "inputs" is not a list of fields`;
+  }
+  if (result != null && (typeof result !== "object" || Array.isArray(result) || typeof result.kind !== "string")) {
+    return `the descriptor's "result" is not a field`;
+  }
+  return void 0;
+}
+function fitCheck(descriptor, spec) {
   try {
-    return collectLayoutProblems(descriptor, spec);
+    return { problems: collectLayoutProblems(descriptor, spec), checksFailed: false };
   } catch (error) {
-    return [`the layout is not a well-formed spec: ${String(error)}`];
+    return { problems: [checksFailedLine(error)], checksFailed: true };
+  }
+}
+function shownAs(value) {
+  if (typeof value === "string") return value;
+  try {
+    return String(JSON.stringify(value ?? null));
+  } catch {
+    return "a value that cannot be written out";
   }
 }
 function collectLayoutProblems(descriptor, spec) {
@@ -1339,14 +1523,14 @@ function collectLayoutProblems(descriptor, spec) {
     const path = typeof written === "string" ? absoluteHatchPath(spec, key, written, parents) : void 0;
     if (element.type === "MthdsField") {
       if (!path || !inputFieldAtPath(descriptor.inputs ?? [], path)) {
-        problems.push(`${key}: MthdsField delegates ${String(written)}, which no input has`);
+        problems.push(`${key}: MthdsField delegates ${shownAs(written)}, which no input has`);
       } else {
         delegated.push(path);
       }
     }
     if (element.type === "MthdsResult") {
       if (!path || !descriptor.result || !resultFieldAtPath(descriptor.result, path)) {
-        problems.push(`${key}: MthdsResult delegates ${String(written)}, which no result has`);
+        problems.push(`${key}: MthdsResult delegates ${shownAs(written)}, which no result has`);
       }
     }
     const [onlyKey] = element.children?.length === 1 ? element.children : [];
@@ -1357,12 +1541,12 @@ function collectLayoutProblems(descriptor, spec) {
       );
     }
     if (element.type === "Picture") {
-      const shown = written === "" ? repeatBasePathOf(spec, key, parents) : path ?? void 0;
-      const field = shown && descriptor.result ? resultFieldAtPath(descriptor.result, shown) : void 0;
+      const shown2 = written === "" ? repeatBasePathOf(spec, key, parents) : path ?? void 0;
+      const field = shown2 && descriptor.result ? resultFieldAtPath(descriptor.result, shown2) : void 0;
       if (!field) {
         problems.push(`${key}: Picture shows ${JSON.stringify(written)}, which no result has`);
       } else if (field.kind !== "image") {
-        problems.push(`${key}: Picture shows ${shown}, which holds a ${field.kind}, not an image`);
+        problems.push(`${key}: Picture shows ${shown2}, which holds a ${field.kind}, not an image`);
       }
     }
   }
@@ -1418,26 +1602,32 @@ function valueAt(value, path) {
   return at;
 }
 function isClosedVocabulary(schema) {
-  let current = schema;
-  for (let depth = 0; depth < 8; depth += 1) {
-    const def = current.def;
-    if (!def) return false;
-    if (def.type === "enum" || def.type === "literal") return true;
-    if (def.innerType === void 0) return false;
-    current = def.innerType;
+  const type = unwrapped(schema)?.type;
+  return type === "enum" || type === "literal";
+}
+function closedExpressionPaths(schema, value, path = []) {
+  if (schema === void 0 || typeof value !== "object" || value === null) return [];
+  if (path.length > 0 && isExpression(value)) return isClosedVocabulary(schema) ? [[...path]] : [];
+  const def = unwrapped(schema);
+  if (Array.isArray(value)) {
+    return def?.type === "array" ? value.flatMap((entry, index) => closedExpressionPaths(def.element, entry, [...path, index])) : [];
   }
-  return false;
+  if (def?.type !== "object" || !def.shape) return [];
+  const shape = def.shape;
+  return Object.entries(value).flatMap(
+    ([name, member]) => hasOwnProp(shape, name) ? closedExpressionPaths(shape[name], member, [...path, name]) : []
+  );
 }
-function definitionOf2(catalog2, type) {
+function definitionOf3(catalog2, type) {
   const components2 = catalog2.data.components;
   return hasOwnProp(components2, type) ? components2[type] : void 0;
 }
 function propsSchemaOf(catalog2, type) {
-  const props = definitionOf2(catalog2, type)?.props;
+  const props = definitionOf3(catalog2, type)?.props;
   return props && typeof props === "object" && "shape" in props ? props : void 0;
 }
 function eventsOf(catalog2, type) {
-  const definition = definitionOf2(catalog2, type);
+  const definition = definitionOf3(catalog2, type);
   if (!definition) return void 0;
   return Array.isArray(definition.events) ? definition.events.filter((event) => typeof event === "string") : [];
 }
@@ -1484,12 +1674,19 @@ function deepestChain(spec) {
   return deepest;
 }
 function validateAgainstCatalog(spec, catalog2 = frameCatalog("page")) {
+  const malformed = specMalformation(spec);
+  if (malformed !== void 0) {
+    return { ok: false, problems: [{ message: malformedLine(malformed) }] };
+  }
+  return catalogCheck(spec, catalog2).verdict;
+}
+function catalogCheck(spec, catalog2) {
   try {
-    return checkAgainstCatalog(spec, catalog2);
+    return { verdict: checkAgainstCatalog(spec, catalog2), checksFailed: false };
   } catch (error) {
     return {
-      ok: false,
-      problems: [{ message: `the layout is not a well-formed spec: ${String(error)}` }]
+      verdict: { ok: false, problems: [{ message: checksFailedLine(error) }] },
+      checksFailed: true
     };
   }
 }
@@ -1541,6 +1738,20 @@ function checkAgainstCatalog(spec, catalog2) {
       problems.push({ elementKey: key, message: `unknown component type "${element.type}"` });
     }
   }
+  for (const [key, element] of Object.entries(spec.elements)) {
+    const slots = element.slots;
+    if (typeof slots !== "object" || slots === null) continue;
+    const definition = definitionOf3(catalog2, element.type);
+    if (!definition) continue;
+    const declared2 = Array.isArray(definition.slots) ? definition.slots : [];
+    for (const name of Object.keys(slots)) {
+      if (name !== "default" && declared2.includes(name)) continue;
+      problems.push({
+        elementKey: key,
+        message: name === "default" ? `"${key}" puts children in a slot named "default"; a component's own content goes in "children".` : `"${key}" puts children in slot "${name}", which ${element.type} does not have; its content goes in "children".`
+      });
+    }
+  }
   for (const [key, element] of Object.entries(spec.elements)) {
     const schema = propsSchemaOf(catalog2, element.type);
     if (!schema) continue;
@@ -1569,6 +1780,12 @@ function checkAgainstCatalog(spec, catalog2) {
         }
         continue;
       }
+      for (const at of closedExpressionPaths(propSchema, value)) {
+        problems.push({
+          elementKey: key,
+          message: `${element.type}.${name}.${at.map(String).join(".")} is one of a fixed set of names, so it must be written as a literal, never as an expression.`
+        });
+      }
       const parsed = propSchema.safeParse(value);
       const issues = parsed.success ? [] : parsed.error.issues.filter(
         (issue) => !issue.path.some((_, n) => isExpression(valueAt(value, issue.path.slice(0, n + 1))))
@@ -1852,26 +2069,35 @@ function seedLine(seed) {
   return `CREATIVE SEED (derive your direction from it; never reveal it): ${seed}`;
 }
 var REPAIR_ATTEMPTS = 2;
-function layoutCheckProblems(spec, { frame, descriptor }) {
+function layoutCheck(spec, { frame, descriptor }) {
+  const refused = (line) => ({ problems: [line], checksFailed: false });
   if (!FRAMES.includes(frame)) {
-    return [
+    return refused(
       `the layout names the frame ${JSON.stringify(frame)}, which is none of ${FRAMES.join(", ")}`
-    ];
-  }
-  if (typeof descriptor !== "object" || descriptor === null) {
-    return ["the layout has no descriptor to be checked against"];
+    );
   }
+  const misshapen = descriptorMalformation(descriptor);
+  if (misshapen !== void 0) return refused(misshapen);
+  const malformed = specMalformation(spec);
+  if (malformed !== void 0) return refused(malformedLine(malformed));
   try {
-    const verdict = validateAgainstCatalog(spec, frameCatalog(frame));
-    const invalid = verdict.ok ? [] : formatProblems(verdict.problems).split("\n");
+    const catalogs = catalogCheck(spec, frameCatalog(frame));
+    const invalid = catalogs.verdict.ok ? [] : formatProblems(catalogs.verdict.problems).split("\n");
     const runless = frame !== "result" && descriptor.inputs && !pressRuns(spec) ? [
       "the layout has no control that runs the method: bind `run` under a control's `on.press`"
     ] : [];
-    return [...invalid, ...runless, ...layoutProblems(descriptor, spec)];
+    const fit = fitCheck(descriptor, spec);
+    return {
+      problems: [...invalid, ...runless, ...fit.problems],
+      checksFailed: catalogs.checksFailed || fit.checksFailed
+    };
   } catch (error) {
-    return [`the layout is not a well-formed spec: ${String(error)}`];
+    return { problems: [checksFailedLine(error)], checksFailed: true };
   }
 }
+function layoutCheckProblems(spec, check) {
+  return layoutCheck(spec, check).problems;
+}
 function pressRuns(spec) {
   const isRun = (binding) => typeof binding === "object" && binding !== null && binding.action === "run";
   if (typeof spec !== "object" || spec === null) return false;
@@ -2136,7 +2362,7 @@ function jsonlLines(jsonl) {
 }
 
 // src/generative/state.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function payloadToState(field, payload) {
@@ -2148,12 +2374,12 @@ function payloadToState(field, payload) {
       return content ? formatDateContent(content) : payload;
     }
     case "list": {
-      const items = Array.isArray(payload) ? payload : isRecord(payload) && Array.isArray(payload.items) ? payload.items : void 0;
+      const items = Array.isArray(payload) ? payload : isRecord2(payload) && Array.isArray(payload.items) ? payload.items : void 0;
       if (!items) return payload;
       return items.map((item) => payloadToState(field.item, item));
     }
     case "object": {
-      if (!isRecord(payload)) return payload;
+      if (!isRecord2(payload)) return payload;
       const out = { ...payload };
       for (const child of field.fields) {
         if (hasOwnProp(payload, child.name)) {
@@ -2216,6 +2442,6 @@ function findFixture(fixtures, pipeRef, id) {
   return found;
 }
 
-export { COMPONENT_NAMES, COMPONENT_RENDERINGS, COMPOSER_COMPONENTS, CUSTOM_COMPONENTS, DESIGNER_BRIEF_CONCEPT, DESIGNER_CATALOG_CONCEPT, FRAMES, FRAME_COMPONENTS, ICON_NAMES, INPUTS_ROOT, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, REPAIR_ATTEMPTS, RESULT_COMPONENTS, RESULT_ROOT, absoluteHatchPath, baseCatalog, catalog, componentNamesFor, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, frameCatalog, frameComponents, inputBrief, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutCheckProblems, layoutFits, layoutProblems, payloadToState, promptHashSubject, repeatBasePathOf, resultBrief, resultFieldAtPath, seedLine, segmentsUnder, specFromJsonl, specToJsonl, validateAgainstCatalog };
-//# sourceMappingURL=chunk-VBXFGUCG.js.map
-//# sourceMappingURL=chunk-VBXFGUCG.js.map
+export { COMPONENT_NAMES, COMPONENT_RENDERINGS, COMPOSER_COMPONENTS, CUSTOM_COMPONENTS, DESIGNER_BRIEF_CONCEPT, DESIGNER_CATALOG_CONCEPT, FRAMES, FRAME_COMPONENTS, ICON_NAMES, INPUTS_ROOT, METRIC_FORMATS, PICKED_SHADCN, PRODUCT_COMPONENTS, PROMPT_HASH, REPAIR_ATTEMPTS, RESULT_COMPONENTS, RESULT_ROOT, absoluteHatchPath, baseCatalog, catalog, componentNamesFor, definitionChain, designerCatalog, fieldAtSegments, findFixture, fixtureId, fixtureLabel, formatProblems, frameCatalog, frameComponents, inputBrief, inputFieldAtPath, isDelegatedInput, isDelegatedResult, joinPath, jsonlLines, layoutCheck, layoutCheckProblems, layoutFits, layoutProblems, payloadToState, promptHashSubject, repeatBasePathOf, resultBrief, resultFieldAtPath, seedLine, segmentsUnder, shareAmount, specFromJsonl, specToJsonl, unwrapped, validateAgainstCatalog };
+//# sourceMappingURL=chunk-4SRSGZWM.js.map
+//# sourceMappingURL=chunk-4SRSGZWM.js.map