mlola-ui 1.11.0 → 1.12.2

package/registry/render.js

@@ -55,6 +55,11 @@ const quote = (value) => {
 const escapeSegment = (segment) => String(segment).replaceAll("~", "~0").replaceAll("/", "~1");
 const pointer = (base, ...segments) => segments.reduce((path, segment) => `${path}/${escapeSegment(segment)}`, base);
 const list = (values) => values.map((value) => quote(value)).join(", ");
+/** A noun as its owner and as more than one: a column's, columns; a series', series. */
+const owned = (noun) => (noun.endsWith("s") ? `${noun}'` : `${noun}'s`);
+const many = (noun) => (noun.endsWith("s") ? noun : `${noun}s`);
+/** What one entry of a "columns" prop takes beside its key and label: named values, or true and false. */
+const entryFields = (prop) => ({ ...(prop.align ? { align: prop.align } : {}), ...prop.fields });
 
 /**
  * Reads what an agent or a file holds: one message, an array of messages,
@@ -467,9 +472,14 @@ function checkProp(rules, surfaceId, type, name, prop, value, at, issues) {
     case "options":
       return checkOptions(rules, surfaceId, type, prop, value, at, issues);
     case "columns":
-      return checkColumns(rules, surfaceId, prop, value, at, issues);
+      return checkColumns(rules, surfaceId, type, name, prop, value, at, issues);
     case "rows":
-      return checkRows(rules, surfaceId, value, at, issues);
+      return checkRows(rules, surfaceId, name, prop, value, at, issues);
+    case "key":
+      if (typeof value === "string" && COLUMN_KEY.test(value) && !UNSAFE_SEGMENTS.has(value)) return;
+      return issues.errors.push(failure(surfaceId, at, `${type} ${quote(name)} names a field of each row: letters, digits, _ or -, like "month"; got ${quote(value)}.`));
+    case "numbers":
+      return checkNumbers(rules, surfaceId, type, name, prop, value, at, issues);
     default:
       return issues.errors.push(failure(surfaceId, at, `${type} ${quote(name)} has a kind this validator does not know (${prop.kind}).`));
   }
@@ -618,45 +628,57 @@ function checkOptions(rules, surfaceId, type, prop, value, at, issues) {
   }
 }
 
-function checkColumns(rules, surfaceId, prop, value, at, issues) {
+function checkColumns(rules, surfaceId, type, name, prop, value, at, issues) {
+  const item = prop.item ?? "column";
+  const fields = entryFields(prop);
   if (!Array.isArray(value) || value.length < (prop.minItems ?? 1)) {
-    issues.errors.push(failure(surfaceId, at, `"columns" is a non-empty array of {"key", "label", "align"?}.`));
+    issues.errors.push(failure(surfaceId, at, `${quote(name)} is a non-empty array of {"key", "label"${Object.keys(fields).map((field) => `, ${quote(field)}?`).join("")}}.`));
     return;
   }
-  if (value.length > rules.limits.columns) {
-    issues.errors.push(failure(surfaceId, at, `A table shows at most ${rules.limits.columns} columns; more cannot be read on a phone.`));
+  const max = prop.maxItems ?? rules.limits.columns;
+  if (value.length > max) {
+    issues.errors.push(failure(surfaceId, at, prop.maxItems ? `${type} takes at most ${max} ${many(item)}; this is ${value.length}.` : `A table shows at most ${max} columns; more cannot be read on a phone.`));
     return;
   }
   const seen = new Set();
   for (const [index, column] of value.entries()) {
     const columnAt = pointer(at, index);
     if (!isObject(column)) {
-      issues.errors.push(failure(surfaceId, columnAt, `A column is {"key": "…", "label": "…"}; got ${typeName(column)}.`));
+      issues.errors.push(failure(surfaceId, columnAt, `A ${item} is {"key": "…", "label": "…"}; got ${typeName(column)}.`));
       continue;
     }
-    onlyKeys(column, ["key", "label", "align"], columnAt, surfaceId, issues, "A column");
-    if (typeof column.key !== "string" || !COLUMN_KEY.test(column.key) || UNSAFE_SEGMENTS.has(column.key)) issues.errors.push(failure(surfaceId, pointer(columnAt, "key"), `A column's "key" names the row field it shows: letters, digits, _ or -, like "order".`));
-    else if (seen.has(column.key)) issues.errors.push(failure(surfaceId, pointer(columnAt, "key"), `Two columns have the key ${quote(column.key)}.`));
+    onlyKeys(column, ["key", "label", ...Object.keys(fields)], columnAt, surfaceId, issues, `A ${item}`);
+    if (typeof column.key !== "string" || !COLUMN_KEY.test(column.key) || UNSAFE_SEGMENTS.has(column.key)) issues.errors.push(failure(surfaceId, pointer(columnAt, "key"), `A ${owned(item)} "key" names the row field it shows: letters, digits, _ or -, like "order".`));
+    else if (seen.has(column.key)) issues.errors.push(failure(surfaceId, pointer(columnAt, "key"), `Two ${many(item)} have the key ${quote(column.key)}.`));
     else seen.add(column.key);
-    checkText(rules, surfaceId, column.label, pointer(columnAt, "label"), { maxLength: rules.limits.labelLength }, true, issues, `The column's "label"`);
-    if (column.align !== undefined && !prop.align.values.includes(column.align)) issues.errors.push(failure(surfaceId, pointer(columnAt, "align"), `"align" is ${list(prop.align.values)}.`));
+    checkText(rules, surfaceId, column.label, pointer(columnAt, "label"), { maxLength: rules.limits.labelLength }, true, issues, `The ${owned(item)} "label"`);
+    for (const [field, spec] of Object.entries(fields)) {
+      const given = column[field];
+      if (given === undefined || (spec.values ? spec.values.includes(given) : typeof given === "boolean")) continue;
+      issues.errors.push(failure(surfaceId, pointer(columnAt, field), spec.values ? `${quote(field)} is ${list(spec.values)}.` : `${quote(field)} is true or false.`));
+    }
   }
 }
 
-function checkRows(rules, surfaceId, value, at, issues) {
+function checkRows(rules, surfaceId, name, prop, value, at, issues) {
   if (binding(rules, surfaceId, value, at, issues)) return;
   if (!Array.isArray(value)) {
-    issues.errors.push(failure(surfaceId, at, `"rows" is an array of objects, or {"path": "/…"} to one in the data model; got ${typeName(value)}.`));
+    issues.errors.push(failure(surfaceId, at, `${quote(name)} is an array of objects, or {"path": "/…"} to one in the data model; got ${typeName(value)}.`));
+    return;
+  }
+  if (value.length < (prop.minItems ?? 0)) {
+    issues.errors.push(failure(surfaceId, at, `${quote(name)} needs at least ${prop.minItems} ${prop.minItems === 1 ? "row" : "rows"}.`));
     return;
   }
-  if (value.length > rules.limits.rows) {
-    issues.errors.push(failure(surfaceId, at, `A table holds at most ${rules.limits.rows} rows; page through the rest.`));
+  const max = Math.min(prop.maxItems ?? rules.limits.rows, rules.limits.rows);
+  if (value.length > max) {
+    issues.errors.push(failure(surfaceId, at, `${quote(name)} holds at most ${max} rows; ${prop.maxItems ? "keep the ones that matter" : "page through the rest"}.`));
     return;
   }
   for (const [index, row] of value.entries()) {
     const rowAt = pointer(at, index);
     if (!isObject(row)) {
-      issues.errors.push(failure(surfaceId, rowAt, `A row is an object keyed by column key; got ${typeName(row)}.`));
+      issues.errors.push(failure(surfaceId, rowAt, `A row is an object of its fields, like {"name": "…"}; got ${typeName(row)}.`));
       continue;
     }
     for (const [key, cell] of Object.entries(row)) {
@@ -667,6 +689,52 @@ function checkRows(rules, surfaceId, value, at, issues) {
   }
 }
 
+function checkNumbers(rules, surfaceId, type, name, prop, value, at, issues) {
+  if (binding(rules, surfaceId, value, at, issues)) return;
+  const label = `${type} ${quote(name)}`;
+  if (!Array.isArray(value)) {
+    issues.errors.push(failure(surfaceId, at, `${label} is an array of numbers, or {"path": "/…"} to one in the data model; got ${typeName(value)}.`));
+    return;
+  }
+  if (value.length < (prop.minItems ?? 0) || value.length > rules.limits.rows) {
+    issues.errors.push(failure(surfaceId, at, `${label} holds ${prop.minItems ?? 0} to ${rules.limits.rows} numbers; this is ${value.length}.`));
+    return;
+  }
+  const odd = value.findIndex((entry) => typeof entry !== "number" || !Number.isFinite(entry));
+  if (odd !== -1) issues.errors.push(failure(surfaceId, pointer(at, odd), `${label} holds numbers only; this one is ${quote(value[odd])}.`));
+}
+
+/**
+ * What a prop reads from the rows beside it (`rows` names that prop): a name
+ * in every row, a number wherever one is drawn, and somewhere to write when
+ * a person may edit. Rows in the data model are the renderer's to read with
+ * care; rows written into the component are held here.
+ */
+function checkRowsRead(surfaceId, type, definition, component, at, issues) {
+  for (const [name, prop] of Object.entries(definition.props)) {
+    const given = component[name];
+    if (!prop.rows || given === undefined) continue;
+    const rows = component[prop.rows];
+    const entries = Array.isArray(given) ? given.filter(isObject) : [];
+    const writes = Object.entries(prop.fields ?? {}).filter(([, field]) => field.writes).map(([field]) => field);
+    const written = Array.isArray(given) && !(isObject(rows) && "path" in rows) ? given.findIndex((entry) => isObject(entry) && writes.some((field) => entry[field] === true)) : -1;
+    if (written >= 0) issues.errors.push(failure(surfaceId, pointer(at, name, written), `What a person enters here is written to ${quote(prop.rows)}, so bind it to the data model: {"path": "/…"}, with the rows in updateDataModel.`));
+    // A key names each row or holds its number; a list of them is read only where it is drawn as numbers.
+    if (!Array.isArray(rows) || (prop.kind !== "key" && !prop.numeric)) continue;
+    for (const key of prop.kind === "key" ? [given] : entries.map((entry) => entry.key)) {
+      // A key that is no field name was reported where it was written.
+      if (typeof key !== "string" || !COLUMN_KEY.test(key) || UNSAFE_SEGMENTS.has(key)) continue;
+      const fits = (value) => (prop.numeric ? value === undefined || value === null || (typeof value === "number" && Number.isFinite(value) && value >= (prop.minimum ?? -Infinity)) : (typeof value === "string" && value.trim() !== "") || typeof value === "number");
+      const odd = rows.findIndex((row) => isObject(row) && !fits(own(row, key)));
+      if (odd === -1) continue;
+      const value = own(rows[odd], key);
+      issues.errors.push(failure(surfaceId, value === undefined ? pointer(at, prop.rows, odd) : pointer(at, prop.rows, odd, key), prop.numeric
+        ? `${type} draws ${quote(key)} as a number${prop.minimum === undefined ? "" : ` of at least ${prop.minimum}`}; this row has ${quote(value)}. Write the number itself, or leave it out for a gap.`
+        : `${type} names each row by its ${quote(key)}; this row has ${value === undefined ? "none" : quote(value)}.`));
+    }
+  }
+}
+
 /** Rules between props of one component: a range that holds its value, a value among the options. */
 function checkValues(rules, surfaceId, type, definition, component, at, issues) {
   const literal = (name) => (typeof component[name] === "number" ? component[name] : definition.props[name]?.default);
@@ -693,6 +761,7 @@ function checkValues(rules, surfaceId, type, definition, component, at, issues)
     const values = component.options.filter(isObject).map((option) => option.value);
     if (!values.includes(component.value)) issues.errors.push(failure(surfaceId, pointer(at, "value"), `${type} "value" ${quote(component.value)} is not one of its options (${list(values)}).`));
   }
+  checkRowsRead(surfaceId, type, definition, component, at, issues);
 }
 
 /* The tree ---------------------------------------------------------------- */
@@ -883,8 +952,13 @@ export { childIds, getAt, isObject, setAt, unescapeSegment };
 
 /* For people and agents --------------------------------------------------- */
 
-/** The catalog as a guide an agent reads before composing a surface. */
-export function renderCatalogGuide(rules) {
+/**
+ * The catalog as a guide an agent reads before composing a surface. With
+ * `themes: false` it leaves themes out, for a surface that takes the theme
+ * of the page it is shown on (a renderer's `theme: "inherit"`).
+ */
+export function renderCatalogGuide(rules, { themes = true } = {}) {
+  const look = themes ? `, "theme": {"name": ${quote(rules.defaultTheme)}, "mode": "system"}` : "";
   const lines = [
     `# ${rules.title}`,
     "",
@@ -892,13 +966,13 @@ export function renderCatalogGuide(rules) {
     "",
     `Compose a surface as A2UI messages (version ${list(rules.protocolVersions)}):`,
     "",
-    `1. {"version": "v0.9.1", "createSurface": {"surfaceId": "…", "catalogId": ${quote(rules.catalogId)}, "theme": {"name": ${quote(rules.defaultTheme)}, "mode": "system"}}}`,
+    `1. {"version": "v0.9.1", "createSurface": {"surfaceId": "…", "catalogId": ${quote(rules.catalogId)}${look}}}`,
     `2. {"version": "v0.9.1", "updateComponents": {"surfaceId": "…", "components": [{"id": "root", "component": "Stack", "children": […]}, …]}}`,
     `3. {"version": "v0.9.1", "updateDataModel": {"surfaceId": "…", "path": "/form", "value": {…}}} for the values inputs bind to.`,
     "",
     "Components are a flat list; containers name their children by id, and exactly one component has the id \"root\". Never set a color, size, class or style: pick the named values below.",
     "",
-    `Themes: ${rules.themes.join(", ")} (default ${rules.defaultTheme}); modes: ${rules.modes.join(", ")}.`,
+    themes ? `Themes: ${rules.themes.join(", ")} (default ${rules.defaultTheme}); modes: ${rules.modes.join(", ")}.` : `Leave "theme" out of createSurface: the surface takes the theme of the page it is shown on.`,
     "",
     "## Data and actions",
     "",
@@ -928,7 +1002,7 @@ export function renderCatalogGuide(rules) {
   if (rules.examples?.length) {
     lines.push("## Examples", "");
     for (const example of rules.examples) {
-      lines.push(`### ${example.title}`, "", example.description, "", "```json", "[", example.messages.map((message) => `  ${JSON.stringify(message)}`).join(",\n"), "]", "```", "");
+      lines.push(`### ${example.title}`, "", example.description, "", "```json", "[", example.messages.map((message) => `  ${JSON.stringify(themes ? message : unthemed(message))}`).join(",\n"), "]", "```", "");
     }
   }
   lines.push(
@@ -945,6 +1019,12 @@ export function renderCatalogGuide(rules) {
   return `${lines.join("\n")}\n`;
 }
 
+/** A message as it reads when the page gives the theme: createSurface without one. */
+function unthemed(message) {
+  if (!isObject(message) || !isObject(message.createSurface) || !("theme" in message.createSurface)) return message;
+  return { ...message, createSurface: Object.fromEntries(Object.entries(message.createSurface).filter(([key]) => key !== "theme")) };
+}
+
 function describeKind(spec) {
   switch (spec.kind) {
     case "enum":
@@ -965,10 +1045,16 @@ function describeKind(spec) {
       return `{"event": {"name", "context"}}`;
     case "options":
       return `an array of {"label", "value"}, or {"path"}${spec.minItems ? `, at least ${spec.minItems}` : ""}`;
-    case "columns":
-      return `an array of {"key", "label", "align"?}; align is ${list(spec.align.values)}`;
+    case "columns": {
+      const fields = Object.entries(entryFields(spec));
+      return `an array of {"key", "label"${fields.map(([field]) => `, ${quote(field)}?`).join("")}}${spec.maxItems ? `, at most ${spec.maxItems}` : ""}${fields.map(([field, entry]) => `; ${field} is ${entry.values ? list(entry.values) : "true or false"}`).join("")}`;
+    }
     case "rows":
-      return `an array of objects keyed by column key, or {"path"}`;
+      return `an array of objects, or {"path"}${spec.minItems ? `, at least ${spec.minItems}` : ""}${spec.maxItems ? `, at most ${spec.maxItems}` : ""}`;
+    case "key":
+      return `the name of a field in each row, like "month"`;
+    case "numbers":
+      return `an array of numbers, or {"path"}${spec.minItems ? `, at least ${spec.minItems}` : ""}`;
     default:
       return spec.kind;
   }

package/registry/source/packages/components/render-surface/render-surface.tsx

@@ -49,6 +49,23 @@ const LABELS: RenderSurfaceLabels = {
   no: "No",
 };
 
+/** What a component of your own is given to draw one instance of itself. */
+export interface RenderDrawProps {
+  /** An id for its element, unique on the page. */
+  id: string;
+  /** The component as the agent sent it. Every prop has passed the check; one bound to the data model is still `{"path"}`, so read it. */
+  props: Readonly<Record<string, unknown>>;
+  /** A prop's value now: the literal, or what its binding holds. */
+  read: (value: unknown) => unknown;
+  /** Writes what a person entered to where a prop is bound. False for a prop that is not bound. */
+  write: (binding: unknown, value: unknown) => boolean;
+  /** The component's children, drawn. */
+  children: React.ReactNode;
+}
+
+/** Components for the types of a catalog that extends Mlola's, by type. */
+export type RenderComponents = Readonly<Record<string, React.ComponentType<RenderDrawProps>>>;
+
 export interface RenderSurfaceProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onError"> {
   /**
    * A2UI messages for the Mlola Render catalog. Pass the same array with more
@@ -73,6 +90,8 @@ export interface RenderSurfaceProps extends Omit<React.HTMLAttributes<HTMLDivEle
   labels?: Partial<RenderSurfaceLabels>;
   /** The catalog to draw from. The Mlola Render catalog when left out. */
   rules?: RenderRules;
+  /** Draws the components a catalog adds to Mlola's (`rules`), each by its type. Mlola's own are always drawn by this component. */
+  components?: RenderComponents;
   /** Today's date for date fields, for server rendering. */
   today?: string;
 }
@@ -84,6 +103,7 @@ interface Drawing {
   base: string;
   labels: RenderSurfaceLabels;
   today?: string;
+  components?: RenderComponents;
   press: (componentId: string, scope: string) => void;
 }
 
@@ -102,7 +122,7 @@ const domId = (base: string, key: string) => `${base}-${Array.from(key, (charact
  * the surface's theme. Fields write to the surface's data model, and a
  * pressed Button answers with A2UI's action through `onAction`.
  */
-export function RenderSurface({ messages, streaming = false, host: givenHost, surfaceId, onAction, onError, theme = "surface", fallback = null, labels, rules = catalogRules, today, className, ...props }: RenderSurfaceProps) {
+export function RenderSurface({ messages, streaming = false, host: givenHost, surfaceId, onAction, onError, theme = "surface", fallback = null, labels, rules = catalogRules, components, today, className, ...props }: RenderSurfaceProps) {
   // The first messages are drawn in the first render, so a surface rendered on the server arrives whole.
   const [ownHost] = React.useState(() => {
     const made = createRenderHost(rules);
@@ -151,7 +171,7 @@ export function RenderSurface({ messages, streaming = false, host: givenHost, su
         ? shown.map((id) => {
             const surface = host.surface(id);
             if (!surface) return null;
-            const drawing: Drawing = { host, surfaceId: id, base: `${base}-${id}`, labels: words, today, press: press(id) };
+            const drawing: Drawing = { host, surfaceId: id, base: `${base}-${id}`, labels: words, today, components, press: press(id) };
             const themed = theme === "surface" ? surface.theme : null;
             return (
               // audit-allow: attr.reserved — the engine's own meaning: the surface is a region in the theme and mode its agent named
@@ -468,8 +488,16 @@ function Node({ drawing, instance }: { drawing: Drawing; instance: RenderInstanc
         </Table>
       );
     }
-    default:
-      return null;
+    default: {
+      // A type the catalog in `rules` adds: drawn by the component given for it, or not at all.
+      const Added = drawing.components && Object.hasOwn(drawing.components, node.type) ? drawing.components[node.type] : undefined;
+      if (!Added) return null;
+      return (
+        <Added id={fieldId} props={props} read={read} write={(binding, value) => host.write(surfaceId, binding, value, scope)}>
+          {inside}
+        </Added>
+      );
+    }
   }
 }
 

package/registry/source-manifest.json

@@ -48,7 +48,7 @@
   "packages/components/progress/progress.tsx": "sha256-oDxj1Ccl1pKV4+e6A7aaJL1FThW8qs9r4Gb0hEmExeM=",
   "packages/components/radio-group/radio-group.tsx": "sha256-jhnSEBLkdpe8dv5us/Q1sMsQF4sKGRgDXWGKm2JSFew=",
   "packages/components/rating/rating.tsx": "sha256-prhfNzlCqLRWqURtq0MrX6MLdtuDpIOf5fA1Ie26L54=",
-  "packages/components/render-surface/render-surface.tsx": "sha256-3L4CcYBHjwb1QyKGCygC4NEPL4TajSZiNcMzy4Uf0IM=",
+  "packages/components/render-surface/render-surface.tsx": "sha256-nW48kYLXoa3eeGZQ7gXMD/bTNH9MDeJlWyl1zzrvDwo=",
   "packages/components/resizable/resizable.tsx": "sha256-RFBpg/a2O82mmx+O5wT+um+y3y2w0rUMJJdBzRu9ONU=",
   "packages/components/segmented-control/segmented-control.tsx": "sha256-MCBG5XHFWCwbACctsYKbqe8mvSSR6pf60tyRgdCDKDA=",
   "packages/components/select/select.tsx": "sha256-7u1sshW6KAQgjgwQ1siN1P5GkBxboOiOJOdgLanForE=",

package/src/cli.js

@@ -17,6 +17,7 @@ import { catalogStylesheets, clearCredentials, fetchProItems, GUIDE_FILENAME, ho
 import { serveMcp } from "./mcp.js";
 import { renderCatalog, renderRules } from "./knowledge.js";
 import { formatRenderReport, renderCatalogGuide, validateRender } from "../registry/render.js";
+import { renderSystemPrompt } from "../registry/render-ai.js";
 import { pullTheme } from "./theme-pull.js";
 import { buildTheme } from "./theme-build.js";
 
@@ -38,6 +39,7 @@ Usage:
   mlola-ui theme build [--file mlola.theme.json]
   mlola-ui render check <file | -> [--json]
   mlola-ui render catalog [--schema]
+  mlola-ui render prompt [--tool] [--page-theme]
 
 Examples:
   npx mlola-ui init                   (also tells your coding agents about Mlola)
@@ -323,7 +325,12 @@ export async function run(argv, options = {}) {
       if (result.unchanged.length) {
         output.log(`• ${result.unchanged.length} file(s) already match the registry`);
       }
+      // The stylesheet from init imports the engine, so it is always needed.
+      const engines = new Map([[config.engine.engine ?? "@mlola-ui/engine", `^${CLI_VERSION}`], ...collectEngineDependencies(items)]);
       if (result.conflicts.length) {
+        // The files beside a refused one are written, and they need their packages now: a project
+        // left with new code on old packages does not build, and running this again would stop here again.
+        ensurePackages(cwd, engines, install);
         output.error(
           `✗ Refused to replace ${result.conflicts.length} modified file(s):\n  ${result.conflicts.join(
             "\n  ",
@@ -335,8 +342,6 @@ export async function run(argv, options = {}) {
       if (styleResult.index) output.log(`Pro styles are gathered in ${styleResult.index}; import it once, after the engine stylesheet.`);
       if (guideResult.status === "written") output.log(`Coding agents: point your AGENTS.md at ${GUIDE_FILENAME}, which lists every Pro class and attribute.`);
 
-      // The stylesheet from init imports the engine, so it is always needed.
-      const engines = new Map([[config.engine.engine ?? "@mlola-ui/engine", `^${CLI_VERSION}`], ...collectEngineDependencies(items)]);
       return ensurePackages(cwd, engines, install);
     }
 
@@ -373,7 +378,12 @@ export async function run(argv, options = {}) {
         output.log(hasFlag(args, "--schema") ? JSON.stringify(renderCatalog(), null, 2) : renderCatalogGuide(rules));
         return 0;
       }
-      if (subcommand !== "check") throw new Error(`Unknown render command "${subcommand ?? ""}". Try: mlola-ui render check <file>, or mlola-ui render catalog`);
+      if (subcommand === "prompt") {
+        // The system prompt for a model someone calls themselves, for a server that is not JavaScript too.
+        output.log(renderSystemPrompt(rules, { output: hasFlag(args, "--tool") ? "tool" : "lines", theme: hasFlag(args, "--page-theme") ? "page" : "surface" }));
+        return 0;
+      }
+      if (subcommand !== "check") throw new Error(`Unknown render command "${subcommand ?? ""}". Try: mlola-ui render check <file>, mlola-ui render catalog, or mlola-ui render prompt`);
       if (!file) throw new Error("Name the file of A2UI messages to check, or - to read them from stdin: mlola-ui render check ui.json");
       const source = file === "-" ? (options.stdin ?? fs.readFileSync(0, "utf8")) : fs.readFileSync(path.resolve(cwd, file), "utf8");
       const result = validateRender(source, rules);