@pipelex/mthds-form 0.32.0 → 0.34.0

package/dist/{chunk-VBXFGUCG.js → chunk-XYS5KCXB.js}

@@ -1,5 +1,6 @@
 import { isNativeValueNode, readDateContent, formatDateContent, isNativeHtmlNode, isNativeDateNode, isNativeCompositeNode } from './chunk-QQK6Y55E.js';
-import { APP_STYLES } from './chunk-3GO65HWP.js';
+import { APP_STYLES } from './chunk-PNNWNRPG.js';
+import { isFilled } from './chunk-TF4RTKLH.js';
 import { hasOwnProp } from './chunk-V3OV2XQT.js';
 import { defineSchema, defineCatalog, validateSpec, compileSpecStream } from '@json-render/core';
 import { z } from 'zod';
@@ -778,59 +779,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 +936,121 @@ ${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
+var DECIMAL = /^[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]?\d+)?$/i;
+function shareAmount(raw) {
+  if (typeof raw === "number") return raw;
+  if (typeof raw === "string" && DECIMAL.test(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 (spec.root !== void 0 && typeof spec.root !== "string") {
+    return `its "root" is ${shown(spec.root)}, not an element's key`;
+  }
+  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`;
+    const child = Array.isArray(children) ? firstNotAKey(children) : void 0;
+    if (child)
+      return `the element ${at} has a child that is ${shown(child.entry)}, not an element's key`;
+    if (slots != null && (!isRecord(slots) || !Object.values(slots).every(Array.isArray))) {
+      return `the element ${at} has "slots" that are not lists`;
+    }
+    const slotted = isRecord(slots) ? firstNotAKey(Object.values(slots).flatMap((entries) => entries)) : void 0;
+    if (slotted) {
+      return `the element ${at} has a slot entry that is ${shown(slotted.entry)}, not an element's key`;
+    }
+    if (repeat !== void 0 && !repeatsOver(repeat)) {
+      return `the element ${at} has a "repeat" that names no "statePath"`;
+    }
+  }
+  return void 0;
+}
+function firstNotAKey(entries) {
+  for (const entry of entries) if (typeof entry !== "string") return { entry };
+  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 +1139,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 +1218,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 +1260,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 +1329,124 @@ 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 amountPathRefusal = (path) => {
+      const field = isUnder(root, path) ? fieldAt(path) : void 0;
+      if (field && field.kind !== "number" && field.kind !== "unknown") {
+        return `reads ${path}, which holds ${kindWords(field.kind)}, not a number`;
+      }
+      return void 0;
+    };
+    const amountRefusal = (amount) => {
+      if (Number.isFinite(shareAmount(amount)) || readsIndex(amount)) return void 0;
+      const path = readPath(amount);
+      if (path === void 0) {
+        const shown2 = isExpression(amount) ? "an expression that reads no number" : String(JSON.stringify(amount ?? null));
+        return `is ${shown2}, not a number`;
+      }
+      return amountPathRefusal(path);
+    };
+    if (element.type === "ProportionBar") {
+      const props = element.props ?? {};
+      for (const prop of ["total", "of"]) {
+        const refusals = outcomes(props[prop]).filter((outcome) => outcome !== null && outcome !== void 0).map(
+          (outcome) => readsIndex(outcome) ? "is the repeat's index, not an amount" : amountRefusal(outcome)
+        ).filter((refusal) => refusal !== void 0);
+        for (const refusal of new Set(refusals)) {
+          problems.push(
+            `${key}: ProportionBar's ${prop} ${refusal}; a total or a ceiling is a number, or reads a path that holds one with { "$state" }`
+          );
+        }
+      }
+    }
     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 templateAmount = (amount) => {
+        if (expressionForm(amount) !== "$template") return void 0;
+        const text = amount.$template;
+        const sole = /^\s*(\$\{[^}]+\})\s*$/.exec(text)?.[1];
+        if (sole !== void 0) {
+          const [path] = interpolatedPaths(sole, itemPath);
+          return path === void 0 ? "more" : { path };
+        }
+        return interpolatedPaths(text, itemPath).length > 0 ? "more" : { text };
+      };
+      const inlineAmountRefusal = (amount) => {
+        if (expressionForm(amount) === "$computed") {
+          return "is a $computed, which a page has no function to resolve, not a number";
+        }
+        const written = templateAmount(amount);
+        if (written === void 0) return amountRefusal(amount);
+        if (written === "more") {
+          return "is a template that writes text beside its value, not a number";
+        }
+        if ("path" in written) return amountPathRefusal(written.path);
+        return Number.isFinite(shareAmount(written.text)) ? void 0 : `is a template that writes ${JSON.stringify(written.text)} out, not a number`;
+      };
+      const amountRefused = (part, amount) => {
+        const refusal = inlineAmountRefusal(amount);
+        if (refusal === void 0) return false;
+        problems.push(`${part}'s ${JSON.stringify(valueKey)} ${refusal}; ${how}`);
+        return true;
+      };
+      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) => {
@@ -1257,6 +1469,7 @@ function nonScalarReads(spec, parents, root, fieldAt) {
       }
     };
     for (const [prop, value] of Object.entries(element.props ?? {})) {
+      if (element.type === "ProportionBar" && (prop === "total" || prop === "of")) continue;
       const items = listy?.get(prop);
       if (items === void 0 || Array.isArray(value)) {
         walk(prop, prop === "items" && Array.isArray(value) ? inlineShares(value) : value);
@@ -1316,18 +1529,113 @@ function isOffered(path, offered) {
   if (offered.bound.has(path) || offered.repeated.has(path)) return true;
   return offered.delegated.some((at) => path === at || path.startsWith(`${at}/`));
 }
-function uncoveredUnder(field, path, offered) {
+function uncoveredUnder(field, path, offered, seeded) {
   if (isOffered(path, offered)) return [];
   if (field.kind === "object") {
-    return field.fields.filter((child) => child.required).flatMap((child) => uncoveredUnder(child, joinPath(path, child.name), offered));
+    const seededBelow = seeded && field.required && field.defaultValue === void 0;
+    const under = (child) => uncoveredUnder(child, joinPath(path, child.name), offered, seededBelow);
+    const required = field.fields.filter((child) => child.required);
+    if (required.length > 0) return required.flatMap(under);
+    return field.fields.some(
+      (child) => seededBelow && isFilled(child.defaultValue) || under(child).length === 0
+    ) ? [] : [path];
   }
   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";
+  }
+  try {
+    const budget = { fields: 0 };
+    const { inputs, result } = descriptor;
+    if (inputs != null && !Array.isArray(inputs)) {
+      return `the descriptor's "inputs" is not a list of fields`;
+    }
+    for (const [index, input] of (inputs ?? []).entries()) {
+      const problem = fieldMalformation(input, `input ${index + 1}`, /* @__PURE__ */ new Set(), budget);
+      if (problem !== void 0) return `the descriptor's ${problem}`;
+    }
+    if (result != null) {
+      if (!isField(result)) return `the descriptor's "result" is not a field`;
+      const problem = fieldMalformation(result, '"result"', /* @__PURE__ */ new Set(), budget);
+      if (problem !== void 0) return `the descriptor's ${problem}`;
+    }
+    return void 0;
+  } catch (error) {
+    let said;
+    try {
+      said = String(error);
+    } catch {
+      said = "an error that cannot be written out";
+    }
+    return `the descriptor cannot be read (${said})`;
+  }
+}
+var MAX_FIELD_DEPTH = 64;
+var MAX_DESCRIPTOR_FIELDS = 1e4;
+function isField(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.kind === "string" && typeof value.name === "string";
+}
+function fieldMalformation(value, subject, ancestors, budget) {
+  if (++budget.fields > MAX_DESCRIPTOR_FIELDS) {
+    return `fields number more than ${MAX_DESCRIPTOR_FIELDS}, counted at each place one is held`;
+  }
+  if (!isField(value)) return `${subject} is not a field`;
+  const named = `${subject} (${JSON.stringify(value.name)})`;
+  if (ancestors.has(value)) return `${named} contains itself`;
+  if (ancestors.size >= MAX_FIELD_DEPTH) {
+    return `${named} is nested more than ${MAX_FIELD_DEPTH} fields deep`;
+  }
+  ancestors.add(value);
+  try {
+    if (value.kind === "object") {
+      const { fields } = value;
+      if (!Array.isArray(fields)) return `${named} has no list of member "fields"`;
+      for (const [index, member] of fields.entries()) {
+        const problem = fieldMalformation(
+          member,
+          `${named} member ${index + 1}`,
+          ancestors,
+          budget
+        );
+        if (problem !== void 0) return problem;
+      }
+    }
+    if (value.kind === "list") {
+      const problem = fieldMalformation(
+        value.item,
+        `${named} item`,
+        ancestors,
+        budget
+      );
+      if (problem !== void 0) return problem;
+    }
+    return void 0;
+  } finally {
+    ancestors.delete(value);
+  }
+}
+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 +1647,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 +1665,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`);
       }
     }
   }
@@ -1397,7 +1705,7 @@ function collectLayoutProblems(descriptor, spec) {
   };
   for (const field of inputs) {
     if (!field.required) continue;
-    for (const path of uncoveredUnder(field, joinPath(INPUTS_ROOT, field.name), offered)) {
+    for (const path of uncoveredUnder(field, joinPath(INPUTS_ROOT, field.name), offered, true)) {
       problems.push(`${path} is required, and the layout offers nowhere to enter it`);
     }
   }
@@ -1418,26 +1726,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 +1798,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 +1862,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 +1904,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 +2193,38 @@ 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 [
-      `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"];
+    return {
+      problems: [
+        `the layout is checked against the frame ${JSON.stringify(frame)}, which is none of ${FRAMES.join(", ")}`
+      ],
+      checksFailed: true
+    };
   }
+  const misshapen = descriptorMalformation(descriptor);
+  if (misshapen !== void 0) return { problems: [misshapen], checksFailed: true };
+  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 +2489,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 +2501,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 +2569,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-XYS5KCXB.js.map
+//# sourceMappingURL=chunk-XYS5KCXB.js.map