@json-render/yaml 0.13.0

package/dist/index.mjs

@@ -0,0 +1,801 @@
+// src/diff.ts
+import { diffToPatches } from "@json-render/core";
+
+// src/merge.ts
+import { deepMergeSpec } from "@json-render/core";
+
+// src/parser.ts
+import { parse } from "yaml";
+function createYamlStreamCompiler(initial) {
+  let accumulated = "";
+  let snapshot = initial ? { ...initial } : {};
+  let result = { ...snapshot };
+  const allPatches = [];
+  function tryParse() {
+    const newPatches = [];
+    try {
+      const parsed = parse(accumulated);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const patches = diffToPatches(
+          snapshot,
+          parsed
+        );
+        if (patches.length > 0) {
+          snapshot = structuredClone(parsed);
+          result = { ...snapshot };
+          allPatches.push(...patches);
+          newPatches.push(...patches);
+        }
+      }
+    } catch {
+    }
+    return { result, newPatches };
+  }
+  return {
+    push(chunk) {
+      accumulated += chunk;
+      if (chunk.includes("\n")) {
+        return tryParse();
+      }
+      return { result, newPatches: [] };
+    },
+    flush() {
+      return tryParse();
+    },
+    getResult() {
+      return result;
+    },
+    getPatches() {
+      return [...allPatches];
+    },
+    reset(newInitial) {
+      accumulated = "";
+      snapshot = newInitial ? { ...newInitial } : {};
+      result = { ...snapshot };
+      allPatches.length = 0;
+    }
+  };
+}
+
+// src/transform.ts
+import { parse as parse2, stringify } from "yaml";
+import { applyPatch as applyUnifiedDiff } from "diff";
+import {
+  SPEC_DATA_PART_TYPE,
+  deepMergeSpec as deepMergeSpec2,
+  diffToPatches as diffToPatches2
+} from "@json-render/core";
+var YAML_SPEC_FENCE = "```yaml-spec";
+var YAML_EDIT_FENCE = "```yaml-edit";
+var YAML_PATCH_FENCE = "```yaml-patch";
+var DIFF_FENCE = "```diff";
+var FENCE_CLOSE = "```";
+function createYamlTransform(options) {
+  let currentTextId = "";
+  let inTextBlock = false;
+  let textIdCounter = 0;
+  let lineBuffer = "";
+  let buffering = false;
+  let fenceMode = null;
+  let yamlAccumulated = "";
+  let diffAccumulated = "";
+  let compiler = createYamlStreamCompiler();
+  let currentSpec = options?.previousSpec ? structuredClone(
+    options.previousSpec
+  ) : {};
+  function closeTextBlock(controller) {
+    if (inTextBlock) {
+      controller.enqueue({ type: "text-end", id: currentTextId });
+      inTextBlock = false;
+    }
+  }
+  function ensureTextBlock(controller) {
+    if (!inTextBlock) {
+      textIdCounter++;
+      currentTextId = String(textIdCounter);
+      controller.enqueue({ type: "text-start", id: currentTextId });
+      inTextBlock = true;
+    }
+  }
+  function emitTextDelta(delta, controller) {
+    ensureTextBlock(controller);
+    controller.enqueue({ type: "text-delta", id: currentTextId, delta });
+  }
+  function emitPatch(patch, controller) {
+    closeTextBlock(controller);
+    controller.enqueue({
+      type: SPEC_DATA_PART_TYPE,
+      data: { type: "patch", patch }
+    });
+  }
+  function emitPatches(patches, controller) {
+    for (const patch of patches) {
+      emitPatch(patch, controller);
+    }
+  }
+  function feedYamlSpec(line, controller) {
+    yamlAccumulated += line + "\n";
+    const { newPatches } = compiler.push(line + "\n");
+    if (newPatches.length > 0) {
+      emitPatches(newPatches, controller);
+    }
+  }
+  function feedYamlEdit(line) {
+    yamlAccumulated += line + "\n";
+  }
+  function finaliseYamlEdit(controller) {
+    try {
+      const editObj = parse2(yamlAccumulated);
+      if (editObj && typeof editObj === "object" && !Array.isArray(editObj)) {
+        const merged = deepMergeSpec2(
+          currentSpec,
+          editObj
+        );
+        const patches = diffToPatches2(currentSpec, merged);
+        if (patches.length > 0) {
+          currentSpec = merged;
+          emitPatches(patches, controller);
+        }
+      }
+    } catch {
+    }
+  }
+  function finaliseYamlSpec(controller) {
+    const { newPatches } = compiler.flush();
+    if (newPatches.length > 0) {
+      emitPatches(newPatches, controller);
+    }
+    currentSpec = structuredClone(
+      compiler.getResult()
+    );
+  }
+  function finaliseYamlPatch(controller) {
+    for (const line of yamlAccumulated.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const patch = JSON.parse(trimmed);
+        if (patch.op) {
+          emitPatch(patch, controller);
+          if (patch.op === "add" || patch.op === "replace") {
+            const parts = patch.path.split("/").filter(Boolean);
+            let target = currentSpec;
+            for (let i = 0; i < parts.length - 1; i++) {
+              const key = parts[i];
+              if (typeof target[key] !== "object" || target[key] === null) {
+                target[key] = {};
+              }
+              target = target[key];
+            }
+            const lastKey = parts[parts.length - 1];
+            if (lastKey) target[lastKey] = patch.value;
+          } else if (patch.op === "remove") {
+            const parts = patch.path.split("/").filter(Boolean);
+            let target = currentSpec;
+            for (let i = 0; i < parts.length - 1; i++) {
+              const key = parts[i];
+              if (typeof target[key] !== "object" || target[key] === null)
+                break;
+              target = target[key];
+            }
+            const lastKey = parts[parts.length - 1];
+            if (lastKey) delete target[lastKey];
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  function finaliseDiff(controller) {
+    try {
+      const currentYaml = stringify(currentSpec, { indent: 2 });
+      const patched = applyUnifiedDiff(currentYaml, diffAccumulated);
+      if (patched === false) return;
+      const newSpec = parse2(patched);
+      if (newSpec && typeof newSpec === "object" && !Array.isArray(newSpec)) {
+        const patches = diffToPatches2(
+          currentSpec,
+          newSpec
+        );
+        if (patches.length > 0) {
+          currentSpec = newSpec;
+          emitPatches(patches, controller);
+        }
+      }
+    } catch {
+    }
+  }
+  function processCompleteLine(line, controller) {
+    const trimmed = line.trim();
+    if (fenceMode === null) {
+      if (trimmed.startsWith(YAML_SPEC_FENCE)) {
+        fenceMode = "yaml-spec";
+        yamlAccumulated = "";
+        compiler.reset(currentSpec);
+        return;
+      }
+      if (trimmed.startsWith(YAML_EDIT_FENCE)) {
+        fenceMode = "yaml-edit";
+        yamlAccumulated = "";
+        return;
+      }
+      if (trimmed.startsWith(YAML_PATCH_FENCE)) {
+        fenceMode = "yaml-patch";
+        yamlAccumulated = "";
+        return;
+      }
+      if (trimmed.startsWith(DIFF_FENCE)) {
+        fenceMode = "diff";
+        diffAccumulated = "";
+        return;
+      }
+    }
+    if (fenceMode !== null && trimmed === FENCE_CLOSE) {
+      if (fenceMode === "yaml-spec") {
+        finaliseYamlSpec(controller);
+      } else if (fenceMode === "yaml-edit") {
+        finaliseYamlEdit(controller);
+      } else if (fenceMode === "yaml-patch") {
+        finaliseYamlPatch(controller);
+      } else if (fenceMode === "diff") {
+        finaliseDiff(controller);
+      }
+      fenceMode = null;
+      return;
+    }
+    if (fenceMode === "yaml-spec") {
+      feedYamlSpec(line, controller);
+      return;
+    }
+    if (fenceMode === "yaml-edit") {
+      feedYamlEdit(line);
+      return;
+    }
+    if (fenceMode === "yaml-patch") {
+      yamlAccumulated += line + "\n";
+      return;
+    }
+    if (fenceMode === "diff") {
+      diffAccumulated += line + "\n";
+      return;
+    }
+    if (!trimmed) {
+      emitTextDelta("\n", controller);
+      return;
+    }
+    emitTextDelta(line + "\n", controller);
+  }
+  function flushBuffer(controller) {
+    if (!lineBuffer) return;
+    if (fenceMode !== null) {
+      processCompleteLine(lineBuffer, controller);
+    } else {
+      emitTextDelta(lineBuffer, controller);
+    }
+    lineBuffer = "";
+    buffering = false;
+  }
+  return new TransformStream({
+    transform(chunk, controller) {
+      switch (chunk.type) {
+        case "text-start": {
+          const id = chunk.id;
+          const idNum = parseInt(id, 10);
+          if (!isNaN(idNum) && idNum >= textIdCounter) {
+            textIdCounter = idNum;
+          }
+          currentTextId = id;
+          inTextBlock = true;
+          controller.enqueue(chunk);
+          break;
+        }
+        case "text-delta": {
+          const delta = chunk;
+          const text = delta.delta;
+          for (let i = 0; i < text.length; i++) {
+            const ch = text.charAt(i);
+            if (ch === "\n") {
+              if (buffering) {
+                processCompleteLine(lineBuffer, controller);
+                lineBuffer = "";
+                buffering = false;
+              } else if (fenceMode === null) {
+                emitTextDelta("\n", controller);
+              }
+            } else if (lineBuffer.length === 0 && !buffering) {
+              if (fenceMode !== null || ch === "`") {
+                buffering = true;
+                lineBuffer += ch;
+              } else {
+                emitTextDelta(ch, controller);
+              }
+            } else if (buffering) {
+              lineBuffer += ch;
+            } else {
+              emitTextDelta(ch, controller);
+            }
+          }
+          break;
+        }
+        case "text-end": {
+          flushBuffer(controller);
+          if (inTextBlock) {
+            controller.enqueue({ type: "text-end", id: currentTextId });
+            inTextBlock = false;
+          }
+          break;
+        }
+        default: {
+          controller.enqueue(chunk);
+          break;
+        }
+      }
+    },
+    flush(controller) {
+      flushBuffer(controller);
+      if (fenceMode === "yaml-spec") {
+        finaliseYamlSpec(controller);
+      } else if (fenceMode === "yaml-edit") {
+        finaliseYamlEdit(controller);
+      } else if (fenceMode === "yaml-patch") {
+        finaliseYamlPatch(controller);
+      } else if (fenceMode === "diff") {
+        finaliseDiff(controller);
+      }
+      closeTextBlock(controller);
+    }
+  });
+}
+function pipeYamlRender(stream, options) {
+  return stream.pipeThrough(
+    createYamlTransform(options)
+  );
+}
+
+// src/prompt.ts
+import { stringify as stringify2 } from "yaml";
+import { buildEditInstructions } from "@json-render/core";
+function getZodTypeName(schema) {
+  if (!schema?._def) return "";
+  const def = schema._def;
+  return def.typeName ?? (typeof def.type === "string" ? def.type : "") ?? "";
+}
+function formatZodType(schema) {
+  if (!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 = typeof def.element === "object" ? def.element : typeof def.type === "object" ? def.type : void 0;
+      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 getExampleProps(def) {
+  if (def.example && Object.keys(def.example).length > 0) return def.example;
+  if (!def.props?._def) return {};
+  const zodDef = def.props._def;
+  const typeName = getZodTypeName(def.props);
+  if (typeName !== "ZodObject" && typeName !== "object") return {};
+  const shape = typeof zodDef.shape === "function" ? zodDef.shape() : zodDef.shape;
+  if (!shape) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(shape)) {
+    const inner = getZodTypeName(value);
+    if (inner === "ZodOptional" || inner === "optional" || inner === "ZodNullable" || inner === "nullable")
+      continue;
+    result[key] = exampleValue(value);
+  }
+  return result;
+}
+function exampleValue(schema) {
+  if (!schema?._def) return "...";
+  const def = schema._def;
+  const t = getZodTypeName(schema);
+  switch (t) {
+    case "ZodString":
+    case "string":
+      return "example";
+    case "ZodNumber":
+    case "number":
+      return 0;
+    case "ZodBoolean":
+    case "boolean":
+      return true;
+    case "ZodLiteral":
+    case "literal":
+      return def.value;
+    case "ZodEnum":
+    case "enum": {
+      if (Array.isArray(def.values) && def.values.length > 0)
+        return def.values[0];
+      if (def.entries && typeof def.entries === "object") {
+        const vals = Object.values(def.entries);
+        return vals.length > 0 ? vals[0] : "example";
+      }
+      return "example";
+    }
+    case "ZodOptional":
+    case "optional":
+    case "ZodNullable":
+    case "nullable":
+    case "ZodDefault":
+    case "default": {
+      const inner = def.innerType ?? def.wrapped;
+      return inner ? exampleValue(inner) : null;
+    }
+    case "ZodArray":
+    case "array":
+      return [];
+    case "ZodObject":
+    case "object":
+      return getExampleProps({ props: schema });
+    case "ZodUnion":
+    case "union": {
+      const options = def.options;
+      return options && options.length > 0 ? exampleValue(options[0]) : "...";
+    }
+    default:
+      return "...";
+  }
+}
+function toYaml(value) {
+  return stringify2(value, { indent: 2 }).trimEnd();
+}
+function yamlPrompt(catalog, options) {
+  const {
+    system = "You are a UI generator that outputs YAML.",
+    mode = "standalone",
+    customRules = [],
+    editModes = ["merge"]
+  } = options ?? {};
+  const lines = [];
+  lines.push(system);
+  lines.push("");
+  if (mode === "inline") {
+    lines.push("OUTPUT FORMAT (text + YAML):");
+    lines.push(
+      "You respond conversationally. When generating UI, first write a brief explanation (1-3 sentences), then output the YAML spec wrapped in a ```yaml-spec code fence."
+    );
+    lines.push(
+      "If the user's message does not require a UI (e.g. a greeting or clarifying question), respond with text only \u2014 no YAML."
+    );
+  } else {
+    lines.push("OUTPUT FORMAT (YAML):");
+    lines.push(
+      "Output a YAML document that describes a UI tree. Wrap it in a ```yaml-spec code fence."
+    );
+  }
+  lines.push("");
+  lines.push(
+    "The YAML document has three top-level keys: root, elements, and state (optional)."
+  );
+  lines.push(
+    "Stream progressively \u2014 output elements one at a time so the UI fills in as you write."
+  );
+  lines.push("");
+  const allComponents = catalog.data.components;
+  const cn = catalog.componentNames;
+  const comp1 = cn[0] || "Component";
+  const comp2 = cn.length > 1 ? cn[1] : comp1;
+  const comp1Def = allComponents?.[comp1];
+  const comp2Def = allComponents?.[comp2];
+  const comp1Props = comp1Def ? getExampleProps(comp1Def) : {};
+  const comp2Props = comp2Def ? getExampleProps(comp2Def) : {};
+  const exampleSpec = {
+    root: "main",
+    elements: {
+      main: {
+        type: comp1,
+        props: comp1Props,
+        children: ["child-1", "list"]
+      },
+      "child-1": {
+        type: comp2,
+        props: comp2Props,
+        children: []
+      },
+      list: {
+        type: comp1,
+        props: comp1Props,
+        repeat: { statePath: "/items", key: "id" },
+        children: ["item"]
+      },
+      item: {
+        type: comp2,
+        props: { ...comp2Props },
+        children: []
+      }
+    },
+    state: {
+      items: [
+        { id: "1", title: "First Item" },
+        { id: "2", title: "Second Item" }
+      ]
+    }
+  };
+  lines.push("Example:");
+  lines.push("");
+  lines.push("```yaml-spec");
+  lines.push(toYaml(exampleSpec));
+  lines.push("```");
+  lines.push("");
+  lines.push(buildEditInstructions({ modes: editModes }, "yaml"));
+  lines.push("INITIAL STATE:");
+  lines.push(
+    "The spec includes a top-level `state` key to seed the state model. Components using $state, $bindState, $bindItem, $item, or $index read from this state."
+  );
+  lines.push(
+    "CRITICAL: You MUST include state whenever your UI displays data via these expressions or uses repeat to iterate over arrays."
+  );
+  lines.push(
+    "Include realistic sample data. For lists: 3-5 items with relevant fields. Never leave arrays empty."
+  );
+  lines.push(
+    'When content comes from the state model, use { "$state": "/some/path" } dynamic props instead of hardcoding values.'
+  );
+  lines.push(
+    'State paths use RFC 6901 JSON Pointer syntax (e.g. "/todos/0/title"). Do NOT use dot notation.'
+  );
+  lines.push("");
+  lines.push("DYNAMIC LISTS (repeat field):");
+  lines.push(
+    "Any element can have a top-level `repeat` field to render its children once per item in a state array."
+  );
+  lines.push("Example:");
+  lines.push("");
+  lines.push(
+    toYaml({
+      list: {
+        type: comp1,
+        props: comp1Props,
+        repeat: { statePath: "/todos", key: "id" },
+        children: ["todo-item"]
+      }
+    })
+  );
+  lines.push("");
+  lines.push(
+    'Inside repeated children, use { "$item": "field" } for item data and { "$index": true } for the array index.'
+  );
+  lines.push(
+    "ALWAYS use repeat for lists backed by state arrays. NEVER hardcode individual elements per item."
+  );
+  lines.push(
+    "IMPORTANT: `repeat` is a top-level field on the element (sibling of type/props/children), NOT inside props."
+  );
+  lines.push("");
+  lines.push("ARRAY STATE ACTIONS:");
+  lines.push(
+    'Use "pushState" to append items to arrays. Use "removeState" to remove items by index.'
+  );
+  lines.push('Use "$id" inside pushState values to auto-generate a unique ID.');
+  lines.push("");
+  if (allComponents) {
+    lines.push(`AVAILABLE COMPONENTS (${catalog.componentNames.length}):`);
+    lines.push("");
+    for (const [name, def] of Object.entries(allComponents)) {
+      const propsStr = def.props ? formatZodType(def.props) : "{}";
+      const hasChildren = def.slots && def.slots.length > 0;
+      const childrenStr = hasChildren ? " [accepts children]" : "";
+      const eventsStr = def.events && def.events.length > 0 ? ` [events: ${def.events.join(", ")}]` : "";
+      const descStr = def.description ? ` - ${def.description}` : "";
+      lines.push(`- ${name}: ${propsStr}${descStr}${childrenStr}${eventsStr}`);
+    }
+    lines.push("");
+  }
+  const actions = catalog.data.actions;
+  const builtInActions = catalog.schema.builtInActions ?? [];
+  const hasCustomActions = actions && catalog.actionNames.length > 0;
+  const hasBuiltInActions = builtInActions.length > 0;
+  if (hasCustomActions || hasBuiltInActions) {
+    lines.push("AVAILABLE ACTIONS:");
+    lines.push("");
+    for (const action of builtInActions) {
+      lines.push(`- ${action.name}: ${action.description} [built-in]`);
+    }
+    if (hasCustomActions) {
+      for (const [name, def] of Object.entries(actions)) {
+        lines.push(`- ${name}${def.description ? `: ${def.description}` : ""}`);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("EVENTS (the `on` field):");
+  lines.push(
+    "Elements can have an optional `on` field to bind events to actions. It is a top-level field (sibling of type/props/children), NOT inside props."
+  );
+  lines.push("Example:");
+  lines.push("");
+  lines.push(
+    toYaml({
+      "save-btn": {
+        type: comp1,
+        props: comp1Props,
+        on: {
+          press: {
+            action: "setState",
+            params: { statePath: "/saved", value: true }
+          }
+        },
+        children: []
+      }
+    })
+  );
+  lines.push("");
+  lines.push(
+    'Action params can use dynamic references: { "$state": "/statePath" }.'
+  );
+  lines.push(
+    "IMPORTANT: Do NOT put action/actionParams inside props. Always use the `on` field."
+  );
+  lines.push("");
+  lines.push("VISIBILITY CONDITIONS:");
+  lines.push(
+    "Elements can have an optional `visible` field to conditionally show/hide based on state. It is a top-level field (sibling of type/props/children)."
+  );
+  lines.push("Conditions:");
+  lines.push('- { "$state": "/path" } \u2014 visible when truthy');
+  lines.push('- { "$state": "/path", "not": true } \u2014 visible when falsy');
+  lines.push('- { "$state": "/path", "eq": "value" } \u2014 visible when equal');
+  lines.push(
+    '- { "$state": "/path", "neq": "value" } \u2014 visible when not equal'
+  );
+  lines.push(
+    '- { "$state": "/path", "gt": N } / gte / lt / lte \u2014 numeric comparisons'
+  );
+  lines.push("- Use ONE operator per condition. Do not combine multiple.");
+  lines.push('- Add "not": true to any condition to invert it.');
+  lines.push("- [cond, cond] \u2014 implicit AND (all must be true)");
+  lines.push('- { "$and": [...] } \u2014 explicit AND');
+  lines.push('- { "$or": [...] } \u2014 at least one must be true');
+  lines.push("- true / false \u2014 always visible/hidden");
+  lines.push("");
+  lines.push("DYNAMIC PROPS:");
+  lines.push("Any prop value can be a dynamic expression:");
+  lines.push(
+    '1. Read-only: { "$state": "/path" } \u2014 resolves to the value at that state path.'
+  );
+  lines.push(
+    '2. Two-way binding: { "$bindState": "/path" } \u2014 read + write. Use on form inputs.'
+  );
+  lines.push(
+    '   Inside repeat scopes: { "$bindItem": "field" } for item-level binding.'
+  );
+  lines.push(
+    '3. Conditional: { "$cond": <condition>, "$then": <val>, "$else": <val> }'
+  );
+  lines.push(
+    '4. Template: { "$template": "Hello, ${/name}!" } \u2014 interpolates state references.'
+  );
+  lines.push("");
+  const catalogFunctions = catalog.data.functions;
+  if (catalogFunctions && Object.keys(catalogFunctions).length > 0) {
+    lines.push(
+      '5. Computed: { "$computed": "<fn>", "args": { "key": <expr> } }'
+    );
+    lines.push("   Available functions:");
+    for (const name of Object.keys(
+      catalogFunctions
+    )) {
+      lines.push(`   - ${name}`);
+    }
+    lines.push("");
+  }
+  const hasChecks = allComponents ? Object.values(allComponents).some((def) => {
+    if (!def.props) return false;
+    return formatZodType(def.props).includes("checks");
+  }) : false;
+  if (hasChecks) {
+    lines.push("VALIDATION:");
+    lines.push(
+      "Form components with a `checks` prop support client-side validation."
+    );
+    lines.push(
+      "Built-in types: required, email, minLength, maxLength, pattern, min, max, numeric, url, matches, equalTo, lessThan, greaterThan, requiredIf."
+    );
+    lines.push(
+      "IMPORTANT: Components with checks must also use $bindState or $bindItem for two-way binding."
+    );
+    lines.push("");
+  }
+  if (hasCustomActions || hasBuiltInActions) {
+    lines.push("STATE WATCHERS:");
+    lines.push(
+      "Elements can have an optional `watch` field to trigger actions when state changes. Top-level field, NOT inside props."
+    );
+    lines.push(
+      "Maps state paths to action bindings. Fires when the watched value changes (not on initial render)."
+    );
+    lines.push("");
+  }
+  lines.push("RULES:");
+  const baseRules = mode === "inline" ? [
+    "When generating UI, wrap the YAML in a ```yaml-spec code fence",
+    "Write a brief conversational response before the YAML",
+    "When editing existing UI, use a ```yaml-edit fence with only the changed parts",
+    "The document must have: root (string), elements (map of elements), and optionally state",
+    "Each element must have: type, props, children (list of child keys)",
+    "ONLY use components listed above",
+    "Use unique, descriptive keys for elements (e.g. 'header', 'metric-1', 'chart-revenue')",
+    "Include state whenever using $state, $bindState, $bindItem, $item, $index, or repeat"
+  ] : [
+    "Output ONLY the YAML spec inside a ```yaml-spec fence \u2014 no prose, no extra markdown",
+    "When editing existing UI, use a ```yaml-edit fence with only the changed parts",
+    "The document must have: root (string), elements (map of elements), and optionally state",
+    "Each element must have: type, props, children (list of child keys)",
+    "ONLY use components listed above",
+    "Use unique, descriptive keys for elements (e.g. 'header', 'metric-1', 'chart-revenue')",
+    "Include state whenever using $state, $bindState, $bindItem, $item, $index, or repeat"
+  ];
+  const schemaRules = catalog.schema.defaultRules ?? [];
+  const allRules = [...baseRules, ...schemaRules, ...customRules];
+  allRules.forEach((rule, i) => {
+    lines.push(`${i + 1}. ${rule}`);
+  });
+  return lines.join("\n");
+}
+export {
+  DIFF_FENCE,
+  FENCE_CLOSE,
+  YAML_EDIT_FENCE,
+  YAML_PATCH_FENCE,
+  YAML_SPEC_FENCE,
+  createYamlStreamCompiler,
+  createYamlTransform,
+  deepMergeSpec,
+  diffToPatches,
+  pipeYamlRender,
+  yamlPrompt
+};
+//# sourceMappingURL=index.mjs.map