@json-render/core 0.2.0 → 0.4.0

package/dist/index.js

@@ -33,15 +33,23 @@ __export(index_exports, {
   ValidationConfigSchema: () => ValidationConfigSchema,
   VisibilityConditionSchema: () => VisibilityConditionSchema,
   action: () => action,
+  applySpecStreamPatch: () => applySpecStreamPatch,
   builtInValidationFunctions: () => builtInValidationFunctions,
   check: () => check,
+  compileSpecStream: () => compileSpecStream,
   createCatalog: () => createCatalog,
+  createSpecStreamCompiler: () => createSpecStreamCompiler,
+  defineCatalog: () => defineCatalog,
+  defineSchema: () => defineSchema,
   evaluateLogicExpression: () => evaluateLogicExpression,
   evaluateVisibility: () => evaluateVisibility,
   executeAction: () => executeAction,
+  findFormValue: () => findFormValue,
   generateCatalogPrompt: () => generateCatalogPrompt,
+  generateSystemPrompt: () => generateSystemPrompt,
   getByPath: () => getByPath,
   interpolateString: () => interpolateString,
+  parseSpecStreamLine: () => parseSpecStreamLine,
   resolveAction: () => resolveAction,
   resolveDynamicValue: () => resolveDynamicValue,
   runValidation: () => runValidation,
@@ -99,19 +107,154 @@ function getByPath(obj, path) {
   }
   return current;
 }
+function isNumericIndex(str) {
+  return /^\d+$/.test(str);
+}
 function setByPath(obj, path, value) {
   const segments = path.startsWith("/") ? path.slice(1).split("/") : path.split("/");
   if (segments.length === 0) return;
   let current = obj;
   for (let i = 0; i < segments.length - 1; i++) {
     const segment = segments[i];
-    if (!(segment in current) || typeof current[segment] !== "object") {
-      current[segment] = {};
+    const nextSegment = segments[i + 1];
+    const nextIsNumeric = nextSegment !== void 0 && isNumericIndex(nextSegment);
+    if (Array.isArray(current)) {
+      const index = parseInt(segment, 10);
+      if (current[index] === void 0 || typeof current[index] !== "object") {
+        current[index] = nextIsNumeric ? [] : {};
+      }
+      current = current[index];
+    } else {
+      if (!(segment in current) || typeof current[segment] !== "object") {
+        current[segment] = nextIsNumeric ? [] : {};
+      }
+      current = current[segment];
     }
-    current = current[segment];
   }
   const lastSegment = segments[segments.length - 1];
-  current[lastSegment] = value;
+  if (Array.isArray(current)) {
+    const index = parseInt(lastSegment, 10);
+    current[index] = value;
+  } else {
+    current[lastSegment] = value;
+  }
+}
+function findFormValue(fieldName, params, data) {
+  if (params?.[fieldName] !== void 0) {
+    const val = params[fieldName];
+    if (typeof val !== "string" || !val.includes(".")) {
+      return val;
+    }
+  }
+  if (params) {
+    for (const key of Object.keys(params)) {
+      if (key.endsWith(`.${fieldName}`)) {
+        const val = params[key];
+        if (typeof val !== "string" || !val.includes(".")) {
+          return val;
+        }
+      }
+    }
+  }
+  if (data) {
+    for (const key of Object.keys(data)) {
+      if (key === fieldName || key.endsWith(`.${fieldName}`)) {
+        return data[key];
+      }
+    }
+    const prefixes = ["form", "newCustomer", "customer", ""];
+    for (const prefix of prefixes) {
+      const path = prefix ? `${prefix}/${fieldName}` : fieldName;
+      const val = getByPath(data, path);
+      if (val !== void 0) {
+        return val;
+      }
+    }
+  }
+  return void 0;
+}
+function parseSpecStreamLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || !trimmed.startsWith("{")) return null;
+  try {
+    const patch = JSON.parse(trimmed);
+    if (patch.op && patch.path !== void 0) {
+      return patch;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function applySpecStreamPatch(obj, patch) {
+  if (patch.op === "set" || patch.op === "add" || patch.op === "replace") {
+    setByPath(obj, patch.path, patch.value);
+  } else if (patch.op === "remove") {
+    setByPath(obj, patch.path, void 0);
+  }
+  return obj;
+}
+function compileSpecStream(stream, initial = {}) {
+  const lines = stream.split("\n");
+  const result = { ...initial };
+  for (const line of lines) {
+    const patch = parseSpecStreamLine(line);
+    if (patch) {
+      applySpecStreamPatch(result, patch);
+    }
+  }
+  return result;
+}
+function createSpecStreamCompiler(initial = {}) {
+  let result = { ...initial };
+  let buffer = "";
+  const appliedPatches = [];
+  const processedLines = /* @__PURE__ */ new Set();
+  return {
+    push(chunk) {
+      buffer += chunk;
+      const newPatches = [];
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || processedLines.has(trimmed)) continue;
+        processedLines.add(trimmed);
+        const patch = parseSpecStreamLine(trimmed);
+        if (patch) {
+          applySpecStreamPatch(result, patch);
+          appliedPatches.push(patch);
+          newPatches.push(patch);
+        }
+      }
+      if (newPatches.length > 0) {
+        result = { ...result };
+      }
+      return { result, newPatches };
+    },
+    getResult() {
+      if (buffer.trim()) {
+        const patch = parseSpecStreamLine(buffer);
+        if (patch && !processedLines.has(buffer.trim())) {
+          processedLines.add(buffer.trim());
+          applySpecStreamPatch(result, patch);
+          appliedPatches.push(patch);
+          result = { ...result };
+        }
+        buffer = "";
+      }
+      return result;
+    },
+    getPatches() {
+      return [...appliedPatches];
+    },
+    reset(newInitial = {}) {
+      result = { ...newInitial };
+      buffer = "";
+      appliedPatches.length = 0;
+      processedLines.clear();
+    }
+  };
 }
 
 // src/visibility.ts
@@ -606,8 +749,367 @@ var check = {
   })
 };
 
-// src/catalog.ts
+// src/schema.ts
 var import_zod5 = require("zod");
+function createBuilder() {
+  return {
+    string: () => ({ kind: "string" }),
+    number: () => ({ kind: "number" }),
+    boolean: () => ({ kind: "boolean" }),
+    array: (item) => ({ kind: "array", inner: item }),
+    object: (shape) => ({ kind: "object", inner: shape }),
+    record: (value) => ({ kind: "record", inner: value }),
+    any: () => ({ kind: "any" }),
+    zod: () => ({ kind: "zod" }),
+    ref: (path) => ({ kind: "ref", inner: path }),
+    propsOf: (path) => ({ kind: "propsOf", inner: path }),
+    map: (entryShape) => ({ kind: "map", inner: entryShape }),
+    optional: () => ({ optional: true })
+  };
+}
+function defineSchema(builder, options) {
+  const s = createBuilder();
+  const definition = builder(s);
+  return {
+    definition,
+    promptTemplate: options?.promptTemplate,
+    createCatalog(catalog) {
+      return createCatalogFromSchema(this, catalog);
+    }
+  };
+}
+function createCatalogFromSchema(schema, catalogData) {
+  const components = catalogData.components;
+  const actions = catalogData.actions;
+  const componentNames = components ? Object.keys(components) : [];
+  const actionNames = actions ? Object.keys(actions) : [];
+  const zodSchema = buildZodSchemaFromDefinition(
+    schema.definition,
+    catalogData
+  );
+  return {
+    schema,
+    data: catalogData,
+    componentNames,
+    actionNames,
+    prompt(options = {}) {
+      return generatePrompt(this, options);
+    },
+    jsonSchema() {
+      return zodToJsonSchema(zodSchema);
+    },
+    validate(spec) {
+      const result = zodSchema.safeParse(spec);
+      if (result.success) {
+        return {
+          success: true,
+          data: result.data
+        };
+      }
+      return { success: false, error: result.error };
+    },
+    zodSchema() {
+      return zodSchema;
+    },
+    get _specType() {
+      throw new Error("_specType is only for type inference");
+    }
+  };
+}
+function buildZodSchemaFromDefinition(definition, catalogData) {
+  return buildZodType(definition.spec, catalogData);
+}
+function buildZodType(schemaType, catalogData) {
+  switch (schemaType.kind) {
+    case "string":
+      return import_zod5.z.string();
+    case "number":
+      return import_zod5.z.number();
+    case "boolean":
+      return import_zod5.z.boolean();
+    case "any":
+      return import_zod5.z.any();
+    case "array": {
+      const inner = buildZodType(schemaType.inner, catalogData);
+      return import_zod5.z.array(inner);
+    }
+    case "object": {
+      const shape = schemaType.inner;
+      const zodShape = {};
+      for (const [key, value] of Object.entries(shape)) {
+        let zodType = buildZodType(value, catalogData);
+        if (value.optional) {
+          zodType = zodType.optional();
+        }
+        zodShape[key] = zodType;
+      }
+      return import_zod5.z.object(zodShape);
+    }
+    case "record": {
+      const inner = buildZodType(schemaType.inner, catalogData);
+      return import_zod5.z.record(import_zod5.z.string(), inner);
+    }
+    case "ref": {
+      const path = schemaType.inner;
+      const keys = getKeysFromPath(path, catalogData);
+      if (keys.length === 0) {
+        return import_zod5.z.string();
+      }
+      if (keys.length === 1) {
+        return import_zod5.z.literal(keys[0]);
+      }
+      return import_zod5.z.enum(keys);
+    }
+    case "propsOf": {
+      const path = schemaType.inner;
+      const propsSchemas = getPropsFromPath(path, catalogData);
+      if (propsSchemas.length === 0) {
+        return import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown());
+      }
+      if (propsSchemas.length === 1) {
+        return propsSchemas[0];
+      }
+      return import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown());
+    }
+    default:
+      return import_zod5.z.unknown();
+  }
+}
+function getKeysFromPath(path, catalogData) {
+  const parts = path.split(".");
+  let current = { catalog: catalogData };
+  for (const part of parts) {
+    if (current && typeof current === "object") {
+      current = current[part];
+    } else {
+      return [];
+    }
+  }
+  if (current && typeof current === "object") {
+    return Object.keys(current);
+  }
+  return [];
+}
+function getPropsFromPath(path, catalogData) {
+  const parts = path.split(".");
+  let current = { catalog: catalogData };
+  for (const part of parts) {
+    if (current && typeof current === "object") {
+      current = current[part];
+    } else {
+      return [];
+    }
+  }
+  if (current && typeof current === "object") {
+    return Object.values(current).map((entry) => entry.props).filter((props) => props !== void 0);
+  }
+  return [];
+}
+function generatePrompt(catalog, options) {
+  if (catalog.schema.promptTemplate) {
+    const context = {
+      catalog: catalog.data,
+      componentNames: catalog.componentNames,
+      actionNames: catalog.actionNames,
+      options,
+      formatZodType
+    };
+    return catalog.schema.promptTemplate(context);
+  }
+  const {
+    system = "You are a UI generator that outputs JSON.",
+    customRules = []
+  } = options;
+  const lines = [];
+  lines.push(system);
+  lines.push("");
+  lines.push("OUTPUT FORMAT:");
+  lines.push(
+    "Output JSONL (one JSON object per line) with patches to build a UI tree."
+  );
+  lines.push(
+    "Each line is a JSON patch operation. Start with the root, then add each element."
+  );
+  lines.push("");
+  lines.push("Example output (each line is a separate JSON object):");
+  lines.push("");
+  lines.push(`{"op":"set","path":"/root","value":"card-1"}
+{"op":"set","path":"/elements/card-1","value":{"key":"card-1","type":"Card","props":{"title":"Dashboard"},"children":["metric-1","chart-1"],"parentKey":""}}
+{"op":"set","path":"/elements/metric-1","value":{"key":"metric-1","type":"Metric","props":{"label":"Revenue","valuePath":"analytics.revenue","format":"currency"},"children":[],"parentKey":"card-1"}}
+{"op":"set","path":"/elements/chart-1","value":{"key":"chart-1","type":"Chart","props":{"type":"bar","dataPath":"analytics.salesByRegion"},"children":[],"parentKey":"card-1"}}`);
+  lines.push("");
+  const components = catalog.data.components;
+  if (components) {
+    lines.push(`AVAILABLE COMPONENTS (${catalog.componentNames.length}):`);
+    lines.push("");
+    for (const [name, def] of Object.entries(components)) {
+      const propsStr = def.props ? formatZodType(def.props) : "{}";
+      const hasChildren = def.slots && def.slots.length > 0;
+      const childrenStr = hasChildren ? " [accepts children]" : "";
+      const descStr = def.description ? ` - ${def.description}` : "";
+      lines.push(`- ${name}: ${propsStr}${descStr}${childrenStr}`);
+    }
+    lines.push("");
+  }
+  const actions = catalog.data.actions;
+  if (actions && catalog.actionNames.length > 0) {
+    lines.push("AVAILABLE ACTIONS:");
+    lines.push("");
+    for (const [name, def] of Object.entries(actions)) {
+      lines.push(`- ${name}${def.description ? `: ${def.description}` : ""}`);
+    }
+    lines.push("");
+  }
+  lines.push("RULES:");
+  const baseRules = [
+    "Output ONLY JSONL patches - one JSON object per line, no markdown, no code fences",
+    'First line sets root: {"op":"set","path":"/root","value":"<root-key>"}',
+    'Then add each element: {"op":"set","path":"/elements/<key>","value":{...}}',
+    "ONLY use components listed above",
+    "Each element value needs: key, type, props, children (array of child keys), parentKey",
+    "Use unique keys (e.g., 'header', 'metric-1', 'chart-revenue')",
+    "Root element's parentKey is empty string, children reference their parent's key"
+  ];
+  const allRules = [...baseRules, ...customRules];
+  allRules.forEach((rule, i) => {
+    lines.push(`${i + 1}. ${rule}`);
+  });
+  return lines.join("\n");
+}
+function getZodTypeName(schema) {
+  if (!schema || !schema._def) return "";
+  const def = schema._def;
+  return def.typeName ?? def.type ?? "";
+}
+function formatZodType(schema) {
+  if (!schema || !schema._def) return "unknown";
+  const def = schema._def;
+  const typeName = getZodTypeName(schema);
+  switch (typeName) {
+    case "ZodString":
+    case "string":
+      return "string";
+    case "ZodNumber":
+    case "number":
+      return "number";
+    case "ZodBoolean":
+    case "boolean":
+      return "boolean";
+    case "ZodLiteral":
+    case "literal":
+      return JSON.stringify(def.value);
+    case "ZodEnum":
+    case "enum": {
+      let values;
+      if (Array.isArray(def.values)) {
+        values = def.values;
+      } else if (def.entries && typeof def.entries === "object") {
+        values = Object.values(def.entries);
+      } else {
+        return "enum";
+      }
+      return values.map((v) => `"${v}"`).join(" | ");
+    }
+    case "ZodArray":
+    case "array": {
+      const inner = def.type ?? def.element;
+      return inner ? `Array<${formatZodType(inner)}>` : "Array<unknown>";
+    }
+    case "ZodObject":
+    case "object": {
+      const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+      if (!shape) return "object";
+      const props = Object.entries(shape).map(([key, value]) => {
+        const innerTypeName = getZodTypeName(value);
+        const isOptional = innerTypeName === "ZodOptional" || innerTypeName === "ZodNullable" || innerTypeName === "optional" || innerTypeName === "nullable";
+        return `${key}${isOptional ? "?" : ""}: ${formatZodType(value)}`;
+      }).join(", ");
+      return `{ ${props} }`;
+    }
+    case "ZodOptional":
+    case "optional":
+    case "ZodNullable":
+    case "nullable": {
+      const inner = def.innerType ?? def.wrapped;
+      return inner ? formatZodType(inner) : "unknown";
+    }
+    case "ZodUnion":
+    case "union": {
+      const options = def.options;
+      return options ? options.map((opt) => formatZodType(opt)).join(" | ") : "unknown";
+    }
+    default:
+      return "unknown";
+  }
+}
+function zodToJsonSchema(schema) {
+  const def = schema._def;
+  const typeName = def.typeName ?? "";
+  switch (typeName) {
+    case "ZodString":
+      return { type: "string" };
+    case "ZodNumber":
+      return { type: "number" };
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodLiteral":
+      return { const: def.value };
+    case "ZodEnum":
+      return { enum: def.values };
+    case "ZodArray": {
+      const inner = def.type;
+      return {
+        type: "array",
+        items: inner ? zodToJsonSchema(inner) : {}
+      };
+    }
+    case "ZodObject": {
+      const shape = def.shape?.();
+      if (!shape) return { type: "object" };
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value);
+        const innerDef = value._def;
+        if (innerDef.typeName !== "ZodOptional" && innerDef.typeName !== "ZodNullable") {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0,
+        additionalProperties: false
+      };
+    }
+    case "ZodRecord": {
+      const valueType = def.valueType;
+      return {
+        type: "object",
+        additionalProperties: valueType ? zodToJsonSchema(valueType) : true
+      };
+    }
+    case "ZodOptional":
+    case "ZodNullable": {
+      const inner = def.innerType;
+      return inner ? zodToJsonSchema(inner) : {};
+    }
+    case "ZodUnion": {
+      const options = def.options;
+      return options ? { anyOf: options.map(zodToJsonSchema) } : {};
+    }
+    case "ZodAny":
+      return {};
+    default:
+      return {};
+  }
+}
+function defineCatalog(schema, catalog) {
+  return schema.createCatalog(catalog);
+}
+
+// src/catalog.ts
+var import_zod6 = require("zod");
 function createCatalog(config) {
   const {
     name = "unnamed",
@@ -621,37 +1123,37 @@ function createCatalog(config) {
   const functionNames = Object.keys(functions);
   const componentSchemas = componentNames.map((componentName) => {
     const def = components[componentName];
-    return import_zod5.z.object({
-      key: import_zod5.z.string(),
-      type: import_zod5.z.literal(componentName),
+    return import_zod6.z.object({
+      key: import_zod6.z.string(),
+      type: import_zod6.z.literal(componentName),
       props: def.props,
-      children: import_zod5.z.array(import_zod5.z.string()).optional(),
-      parentKey: import_zod5.z.string().nullable().optional(),
+      children: import_zod6.z.array(import_zod6.z.string()).optional(),
+      parentKey: import_zod6.z.string().nullable().optional(),
       visible: VisibilityConditionSchema.optional()
     });
   });
   let elementSchema;
   if (componentSchemas.length === 0) {
-    elementSchema = import_zod5.z.object({
-      key: import_zod5.z.string(),
-      type: import_zod5.z.string(),
-      props: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()),
-      children: import_zod5.z.array(import_zod5.z.string()).optional(),
-      parentKey: import_zod5.z.string().nullable().optional(),
+    elementSchema = import_zod6.z.object({
+      key: import_zod6.z.string(),
+      type: import_zod6.z.string(),
+      props: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()),
+      children: import_zod6.z.array(import_zod6.z.string()).optional(),
+      parentKey: import_zod6.z.string().nullable().optional(),
       visible: VisibilityConditionSchema.optional()
     });
   } else if (componentSchemas.length === 1) {
     elementSchema = componentSchemas[0];
   } else {
-    elementSchema = import_zod5.z.discriminatedUnion("type", [
+    elementSchema = import_zod6.z.discriminatedUnion("type", [
       componentSchemas[0],
       componentSchemas[1],
       ...componentSchemas.slice(2)
     ]);
   }
-  const treeSchema = import_zod5.z.object({
-    root: import_zod5.z.string(),
-    elements: import_zod5.z.record(import_zod5.z.string(), elementSchema)
+  const specSchema = import_zod6.z.object({
+    root: import_zod6.z.string(),
+    elements: import_zod6.z.record(import_zod6.z.string(), elementSchema)
   });
   return {
     name,
@@ -663,7 +1165,7 @@ function createCatalog(config) {
     actions,
     functions,
     elementSchema,
-    treeSchema,
+    specSchema,
     hasComponent(type) {
       return type in components;
     },
@@ -680,8 +1182,8 @@ function createCatalog(config) {
       }
       return { success: false, error: result.error };
     },
-    validateTree(tree) {
-      const result = treeSchema.safeParse(tree);
+    validateSpec(spec) {
+      const result = specSchema.safeParse(spec);
       if (result.success) {
         return { success: true, data: result.data };
       }
@@ -737,6 +1239,155 @@ function generateCatalogPrompt(catalog) {
   lines.push("");
   return lines.join("\n");
 }
+function formatZodType2(schema, isOptional = false) {
+  const def = schema._def;
+  const typeName = def.typeName ?? "";
+  let result;
+  switch (typeName) {
+    case "ZodString":
+      result = "string";
+      break;
+    case "ZodNumber":
+      result = "number";
+      break;
+    case "ZodBoolean":
+      result = "boolean";
+      break;
+    case "ZodLiteral":
+      result = JSON.stringify(def.value);
+      break;
+    case "ZodEnum":
+      result = def.values.map((v) => `"${v}"`).join("|");
+      break;
+    case "ZodNativeEnum":
+      result = Object.values(def.values).map((v) => `"${v}"`).join("|");
+      break;
+    case "ZodArray":
+      result = def.type ? `Array<${formatZodType2(def.type)}>` : "Array<unknown>";
+      break;
+    case "ZodObject": {
+      if (!def.shape) {
+        result = "object";
+        break;
+      }
+      const shape = def.shape();
+      const props = Object.entries(shape).map(([key, value]) => {
+        const innerDef = value._def;
+        const innerOptional = innerDef.typeName === "ZodOptional" || innerDef.typeName === "ZodNullable";
+        return `${key}${innerOptional ? "?" : ""}: ${formatZodType2(value)}`;
+      }).join(", ");
+      result = `{ ${props} }`;
+      break;
+    }
+    case "ZodOptional":
+      return def.innerType ? formatZodType2(def.innerType, true) : "unknown?";
+    case "ZodNullable":
+      return def.innerType ? formatZodType2(def.innerType, true) : "unknown?";
+    case "ZodDefault":
+      return def.innerType ? formatZodType2(def.innerType, isOptional) : "unknown";
+    case "ZodUnion":
+      result = def.options ? def.options.map((opt) => formatZodType2(opt)).join("|") : "unknown";
+      break;
+    case "ZodNull":
+      result = "null";
+      break;
+    case "ZodUndefined":
+      result = "undefined";
+      break;
+    case "ZodAny":
+      result = "any";
+      break;
+    case "ZodUnknown":
+      result = "unknown";
+      break;
+    default:
+      result = "unknown";
+  }
+  return isOptional ? `${result}?` : result;
+}
+function extractPropsFromSchema(schema) {
+  const def = schema._def;
+  const typeName = def.typeName ?? "";
+  if (typeName !== "ZodObject" || !def.shape) {
+    return [];
+  }
+  const shape = def.shape();
+  return Object.entries(shape).map(([name, value]) => {
+    const innerDef = value._def;
+    const optional = innerDef.typeName === "ZodOptional" || innerDef.typeName === "ZodNullable";
+    return {
+      name,
+      type: formatZodType2(value),
+      optional
+    };
+  });
+}
+function formatPropsCompact(props) {
+  if (props.length === 0) return "{}";
+  const entries = props.map(
+    (p) => `${p.name}${p.optional ? "?" : ""}: ${p.type}`
+  );
+  return `{ ${entries.join(", ")} }`;
+}
+function generateSystemPrompt(catalog, options = {}) {
+  const {
+    system = "You are a UI generator that outputs JSONL (JSON Lines) patches.",
+    customRules = []
+  } = options;
+  const lines = [];
+  lines.push(system);
+  lines.push("");
+  const componentCount = catalog.componentNames.length;
+  lines.push(`AVAILABLE COMPONENTS (${componentCount}):`);
+  lines.push("");
+  for (const name of catalog.componentNames) {
+    const def = catalog.components[name];
+    const props = extractPropsFromSchema(def.props);
+    const propsStr = formatPropsCompact(props);
+    const hasChildrenStr = def.hasChildren ? " Has children." : "";
+    const descStr = def.description ? ` ${def.description}` : "";
+    lines.push(`- ${String(name)}: ${propsStr}${descStr}${hasChildrenStr}`);
+  }
+  lines.push("");
+  if (catalog.actionNames.length > 0) {
+    lines.push("AVAILABLE ACTIONS:");
+    lines.push("");
+    for (const name of catalog.actionNames) {
+      const def = catalog.actions[name];
+      lines.push(
+        `- ${String(name)}${def.description ? `: ${def.description}` : ""}`
+      );
+    }
+    lines.push("");
+  }
+  lines.push("OUTPUT FORMAT (JSONL):");
+  lines.push('{"op":"set","path":"/root","value":"element-key"}');
+  lines.push(
+    '{"op":"add","path":"/elements/key","value":{"key":"...","type":"...","props":{...},"children":[...]}}'
+  );
+  lines.push("");
+  lines.push("RULES:");
+  const baseRules = [
+    "First line sets /root to root element key",
+    "Add elements with /elements/{key}",
+    "Children array contains string keys, not objects",
+    "Parent first, then children",
+    "Each element needs: key, type, props",
+    "ONLY use props listed above - never invent new props"
+  ];
+  const allRules = [...baseRules, ...customRules];
+  allRules.forEach((rule, i) => {
+    lines.push(`${i + 1}. ${rule}`);
+  });
+  lines.push("");
+  if (catalog.functionNames.length > 0) {
+    lines.push("CUSTOM VALIDATION FUNCTIONS:");
+    lines.push(catalog.functionNames.map(String).join(", "));
+    lines.push("");
+  }
+  lines.push("Generate JSONL:");
+  return lines.join("\n");
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActionConfirmSchema,
@@ -752,15 +1403,23 @@ function generateCatalogPrompt(catalog) {
   ValidationConfigSchema,
   VisibilityConditionSchema,
   action,
+  applySpecStreamPatch,
   builtInValidationFunctions,
   check,
+  compileSpecStream,
   createCatalog,
+  createSpecStreamCompiler,
+  defineCatalog,
+  defineSchema,
   evaluateLogicExpression,
   evaluateVisibility,
   executeAction,
+  findFormValue,
   generateCatalogPrompt,
+  generateSystemPrompt,
   getByPath,
   interpolateString,
+  parseSpecStreamLine,
   resolveAction,
   resolveDynamicValue,
   runValidation,