@getrheo/flow-runtime 1.0.0

package/dist/agentPrompt/index.js

@@ -0,0 +1,739 @@
+import { ButtonActionSchema, MANIFEST_SCHEMA_VERSION, LAYER_KINDS, INPUT_LAYER_KINDS, migrateLegacyManifest, FlowManifestSchema, screenBackgroundPlaybackId, BUTTON_LAYER_VARIANTS, OS_PERMISSION_KEYS, TEXT_INPUT_TYPES, FIELD_CLASSIFICATIONS, OAUTH_LOGIN_PRESETS, EMAIL_PASSWORD_AUTH_MODES, ICON_FAMILIES, NORMALIZED_SURFACE_OUTCOMES, isScreenBackgroundPlaybackId } from '@getrheo/contracts';
+import { minimalLayerExamples, LAYER_KINDS as LAYER_KINDS$1, INPUT_LAYER_KINDS as INPUT_LAYER_KINDS$1, isInputLayer, OS_PERMISSION_OUTCOME_END, OS_PERMISSION_OUTCOME_CONTINUE } from '@getrheo/contracts/layers';
+import { minimalDecisionNodeExample, minimalExternalSurfaceExample } from '@getrheo/contracts/__fixtures__/agentGraphExamples';
+import '@getrheo/contracts/localized';
+import { collectCanvasGateViolations } from '@getrheo/contracts/canvasEditorGates';
+import '@getrheo/contracts/decisions';
+
+// src/agentPrompt/capabilitySurface.ts
+var buttonActionKinds = () => ButtonActionSchema.options.map((option) => option.shape.kind.value);
+var list = (values) => values.map((value) => `\`${value}\``).join(", ");
+var bullets = (values) => values.map((value) => `- \`${value}\``).join("\n");
+var buildCapabilitySurfaceFragment = () => [
+  `Manifest schema version: ${MANIFEST_SCHEMA_VERSION}`,
+  "",
+  "Valid layer kinds (only these; typos fail parse):",
+  LAYER_KINDS.join(", "),
+  "",
+  `Input layers (at most one per screen): ${INPUT_LAYER_KINDS.join(", ")}`,
+  "",
+  "Valid button action.kind values:",
+  bullets(buttonActionKinds()),
+  "",
+  "- go_to_step requires screenId.",
+  "- go_back_one_screen accepts optional fallbackScreenId.",
+  "- request_os_permission requires permissionKey and outcomes (granted/denied/blocked).",
+  "- play_media requires targetLayerIds (\u22651) pointing at Lottie/video layers on the same screen.",
+  "- request_app_review is allowed; requires screen.next.default. Do not emit unless the user asks.",
+  "- back_button takes no action (back navigation is built in).",
+  "",
+  `Button/back_button variants: ${list(BUTTON_LAYER_VARIANTS)}.`,
+  "",
+  "OS permission keys for request_os_permission:",
+  bullets(OS_PERMISSION_KEYS),
+  "",
+  `- text_input types: ${list(TEXT_INPUT_TYPES)}.`,
+  `- text_input classification: ${list(FIELD_CLASSIFICATIONS)}.`,
+  `- oauth_login preset providers: ${list(OAUTH_LOGIN_PRESETS)}.`,
+  `- email_password_auth modes: ${list(EMAIL_PASSWORD_AUTH_MODES)}.`,
+  `- icon families: ${list(ICON_FAMILIES)}.`,
+  "",
+  `External surface outcome keys: ${list(NORMALIZED_SURFACE_OUTCOMES)}. Every external surface needs fallback.`
+].join("\n");
+var buildLayerExamplesFragment = () => {
+  const byKind = minimalLayerExamples();
+  const lines = LAYER_KINDS$1.map((kind) => {
+    const json = JSON.stringify(byKind[kind]);
+    return `- ${kind}: ${json}`;
+  });
+  return ["Minimal valid layer JSON per kind (from schema fixtures):", ...lines].join("\n");
+};
+var buildScreenStructuralRules = (screenLeadIn) => `Screen object (Zod ScreenSchema \u2014 invalid shapes are rejected):
+${screenLeadIn}
+- id: /^scr_[a-z0-9_]+$/i (new id; never reuse ids from the anchor or manifest list you are given).
+- name: 1\u201380 chars.
+- regions: { body: StackLayer required; header?: StackLayer; footer?: StackLayer }.
+- regions.body MUST be kind "stack" with direction ("vertical"|"horizontal"), gap (0\u2013200 int), children: Layer[].
+- Stack layout: direction + gap live on the stack node. style on stacks is padding/margin/background/border/etc. only \u2014 not direction/gap.
+- Child spacing (gap) defaults: body/content stacks gap 12; choice (single_choice/multiple_choice) and identity (oauth_login/email_password_auth) containers gap 8. Omit gap only when you want the standard spacing; otherwise set it explicitly.
+- Explicit sizing: ALWAYS set style.width and style.height on every layer (no implicit/omitted sizing). Width values: "full" (fill parent), "auto" (hug content), a fraction ("1/2"|"1/3"|"2/3"|"1/4"|"3/4"), or a pixel number. Height values: "fill", "auto", or a pixel number (no fractions). Use these per-kind defaults unless the design needs otherwise:
+  - stack, text_input, scale_input, oauth_login, email_password_auth, email_password_field, progress, loader \u2192 width "full", height "fill"
+  - button, back_button, oauth_provider, email_password_submit, checkbox, single_choice, multiple_choice \u2192 width "full", height "auto"
+  - text, counter, icon, hyperlink \u2192 width "auto", height "auto"
+  - image, lottie, video \u2192 width "full", height a pixel number (e.g. 160)
+  - carousel \u2192 no style sizing on the outer layer
+- next: { "default": null } for inserted screens (server rewires the default path).
+- animations / stagger / transition / containerStyle: omit unless you are sure; invalid clip targets fail manifest validation. When setting shell chrome, use containerStyle.backgroundFill: { kind: "color"|"image"|"video", ... } (not legacy background).
+
+Layer discriminant "kind" MUST be one of these strings exactly (case-sensitive; any other string fails parse):
+${LAYER_KINDS$1.join(", ")}
+
+FORBIDDEN kind aliases (models often hallucinate these \u2014 they are NOT valid):
+- NEVER "selection", "radio", "picker", "form", "input", "choices". For pick-one UI use kind "single_choice"; for pick-many use "multiple_choice".
+
+Per-screen manifest rules (enforced after Zod \u2014 violations cause retry):
+- **At most ONE input layer per screen**, counting only: ${INPUT_LAYER_KINDS$1.map((k) => `"${k}"`).join(", ")}. You cannot stack a text_input and a single_choice on the same screen, and you cannot output two choice layers. If the user asks for "every layer" or a "showcase", pick **one** input primitive OR none; use non-input layers (text, button, image, \u2026) for the rest.
+- Do **not** combine identity capture with other inputs on the same screen: if you include "oauth_login" or "email_password_auth", omit single_choice, multiple_choice, text_input, and scale_input on that screen (product/editor rule).
+- fieldKey on input layers and checkbox: /^[a-z][a-z0-9_]*$/ (snake_case, starts with letter). Each fieldKey must be unique in the merged flow when that layer captures data.
+
+Representative shapes (read carefully \u2014 nested kinds must match):
+
+- **text**: id, kind "text", text: LocalizedText { default: string, translations?: { \u2026 } }. style.fontWeight is a NUMBER (400, 700). Text align is style.align: "left"|"center"|"right" \u2014 never textAlign.
+
+- **button**: kind "button", variant "primary"|"secondary"|"ghost"|"destructive", action (discriminated on action.kind): continue | skip | end_flow | go_back_one_screen (optional fallbackScreenId scr_*) | go_to_step { screenId } | request_os_permission { permissionKey, outcomes: { granted, denied, blocked } each a scr_* id, "continue", or "end" } | play_media { targetLayerIds } | request_app_review | none. children: Layer[] \u2014 label is always nested text layer(s), never a bare string on the button.
+
+- **back_button**: kind "back_button", variant, children (same button chrome pattern as button; used for back affordance).
+
+- **hyperlink**: kind "hyperlink", href (https: or mailto: URL string), children min 1 (link label lives in nested layers, usually text).
+
+- **image** / **lottie** / **video**: kind, optional media ref; lottie and video optional loop, autoPlay, triggerLayerId, onComplete; video optional audioEnabled; button action play_media with targetLayerIds.
+
+- **icon**: kind "icon", family "ionicons", iconName non-empty (Ionicons kebab-case, e.g. "star-outline").
+
+- **progress**: kind "progress"; optional height (bar thickness in px, defaults to 6), trackColor, fillColor.
+
+- **loader**: kind "loader"; optional variant "linear"|"circular", align "start"|"center"|"end", timing fields, onComplete discriminated { mode: "none"|"next"|"screen", screenId? }.
+
+- **counter**: kind "counter", startValue and endValue required numbers; optional displayKind "number"|"time", timeFormat if time.
+
+- **checkbox**: kind "checkbox", fieldKey, optional blocking and glyph styles.
+
+- **single_choice** / **multiple_choice**: kind, fieldKey, children: **array of stack layers, minimum 2** (one stack per option). optionBindings: same length as children; each entry { optionId: string, rootLayerId: <that option stack's id> }. Option stacks may use style (default) and selectedStyle (selected). branching: { enabled: boolean, conditions: [{ choiceId, goTo }] }; use enabled:false and conditions:[] unless you emit real branch targets that exist in the flow (for a brand-new inserted screen, default false/empty is safest).
+
+- **text_input**: kind, fieldKey, classification "safe"|"sensitive", optional placeholder / inputType ("plain"|"email"|"phone"|"url"|"multiline") / required / lengths, optional children.
+
+- **scale_input**: kind, fieldKey, classification, numeric min and max (max > min), optional step, defaultValue, labels, optional children.
+
+- **oauth_login**: kind, children: one or more **oauth_provider** layers only. Each oauth_provider is either variant "preset" with provider "google"|"github"|"apple" and optional label LocalizedText, OR variant "custom" with rowId (UUID string), buttonVariant, and children (icon/text like a button).
+
+- **email_password_auth**: kind, mode "sign_in"|"sign_up", fieldKey, children mixing **email_password_field** (slot "email"|"password"|"confirm" \u2014 sign_up needs confirm, sign_in must not include confirm slot) and exactly one **email_password_submit** (buttonVariant + children with nested text).
+
+- **carousel**: kind, slides: array of stack layers (min 1 slide).
+
+When the user wants a dense demo: prefer a vertical body stack with decorative layers + **at most one** of: a choice layer, text_input, scale_input, oauth_login, or email_password_auth \u2014 not several of those capture types together.`;
+
+// src/agentPrompt/screenSchemaRules.ts
+var buildCanvasScreenSchemaRules = (opts) => {
+  const envelope = opts?.envelope ?? "screen";
+  const screenLeadIn = envelope === "flowGenStep" ? '- Each screen in { "done": false, "screen": <Screen> } follows ScreenSchema.' : 'JSON envelope (exactly one top-level key): { "screen": <Screen> }';
+  return [
+    buildScreenStructuralRules(screenLeadIn),
+    "",
+    buildLayerExamplesFragment(),
+    "",
+    buildCapabilitySurfaceFragment()
+  ].join("\n");
+};
+var buildFlowManifestPatchRules = () => {
+  const screenRules = buildScreenStructuralRules("Each screen object follows ScreenSchema:");
+  return `You edit a Rheo flow manifest via natural language. The server holds the authoritative draft and merges your output onto it.
+
+Output format (strict):
+1. A short confirmation in plain language \u2014 written as if the changes are already live on the canvas. The user only sees this text AFTER the server applies your manifest patch, so use past tense ("I updated\u2026", "Added\u2026") and briefly summarize what changed.
+2. On its own line: ---MANIFEST---
+3. One JSON object \u2014 prefer the PATCH envelope below.
+
+PATCH envelope (default \u2014 emit ONLY what changed):
+{ "mode": "patch", "patch": { "screens": [ /* only new or edited screens */ ] } }
+
+Patch rules:
+- Include in patch.screens ONLY the screens you create or modify; never re-emit unchanged screens.
+- patch.removeScreenIds: array of scr_* ids to delete.
+- patch.decisionNodes / patch.externalSurfaceNodes: include ONLY nodes you add or change (upserted by id). Omit to leave them unchanged.
+- patch.entryScreenId: include only when the flow entry changes.
+- patch.sdkAttributeKeys: include only when adding/removing keys (replaces the full list).
+- Include a screen's next links only when that screen's wiring changed; otherwise leave the screen out of the patch.
+- Never emit builderMeta, flowId, defaultLocale, locales, theme, or version \u2014 the server owns these.
+
+FULL envelope (fallback \u2014 only when restructuring the entire flow, or after a patch fails validation twice):
+{ "manifest": <FlowManifest without builderMeta> }
+- Include every screen, decision node, external surface, and graph wiring the draft needs after your edit.
+- Keep manifest.flowId, defaultLocale, locales, theme, and version unchanged from the current draft.
+- entryScreenId must reference an existing screen id when set.
+
+Screen rules (each screen in patch.screens[] or manifest.screens[]):
+${screenRules}
+- You MAY change screen.next links when the user asks to wire flows; otherwise preserve existing next wiring.
+- New screens need unique scr_* ids; new layers need unique lyr_* ids across the entire manifest.`;
+};
+var buildDecisionSurfaceRules = () => {
+  const decision = JSON.stringify(minimalDecisionNodeExample(), null, 2);
+  const surface = JSON.stringify(minimalExternalSurfaceExample(), null, 2);
+  return `Decision nodes and external surfaces (patch.decisionNodes / patch.externalSurfaceNodes):
+
+Decision node ids: dec_* (e.g. dec_platform). Cases branch on builtin (locale, platform), sdk.* keys, or field keys. Non-reserved sdk.* keys used in decisions must appear in sdkAttributeKeys.
+
+Minimal decision node example:
+${decision}
+
+External surface ids: surf_* (e.g. surf_paywall). config.provider is revenuecat or unspecified. outcomes map normalized keys to jump targets; fallback is required.
+
+Minimal external surface example:
+${surface}`;
+};
+var buildRheoAgentSchemaRules = () => [
+  buildFlowManifestPatchRules(),
+  "",
+  buildDecisionSurfaceRules()
+].join("\n");
+var walkLayers = (root, fn) => {
+  const visit = (l, depth) => {
+    fn(l, depth);
+    if (l.kind === "stack") l.children.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "carousel") l.slides.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "button") l.children.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "back_button") l.children.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "hyperlink") l.children.forEach((c) => visit(c, depth + 1));
+    else if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "text_input" || l.kind === "scale_input") {
+      l.children?.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "oauth_login") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "oauth_provider" && l.variant === "custom") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "email_password_auth") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "email_password_field") {
+      l.children?.forEach((c) => visit(c, depth + 1));
+    } else if (l.kind === "email_password_submit") {
+      l.children.forEach((c) => visit(c, depth + 1));
+    }
+  };
+  visit(root, 0);
+};
+var walkScreen = (screen, fn) => {
+  if (screen.regions.header) walkLayers(screen.regions.header, fn);
+  walkLayers(screen.regions.body, fn);
+  if (screen.regions.footer) walkLayers(screen.regions.footer, fn);
+};
+var findLayerById = (screen, id) => {
+  let found = null;
+  walkScreen(screen, (l) => {
+    if (!found && l.id === id) found = l;
+  });
+  return found;
+};
+
+// src/flowBuilderRules.ts
+var BUILDER_RULES_AGENT_BULLETS = [
+  "Connect flow entry on the canvas before publishing (entryScreenId must exist when screens are present).",
+  "Every text and icon layer needs explicit style.color (including nested button label text \u2014 native does not inherit colors).",
+  'Screens with text_input, multiple_choice, or scale_input need a button with action.kind "continue".',
+  "At most one input layer per screen (single_choice, multiple_choice, text_input, scale_input).",
+  "Do not combine oauth_login or email_password_auth with other input layers on the same screen.",
+  "Only one oauth_login and one email_password_auth per screen; never both on the same screen.",
+  "fieldKey values must be unique snake_case across the flow.",
+  "Choice branch goTo and go_to_step screenId must reference existing screen ids.",
+  "request_app_review buttons require screen.next.default wired to a valid target.",
+  'request_os_permission outcomes must target existing screens, "continue", or "end".',
+  'Lottie/video with autoPlay false needs a button with action.kind "play_media" targeting that layer (or screen background video id).',
+  "play_media targetLayerIds must reference Lottie/video layers on the same screen or the screen background video playback id."
+];
+var FIELD_KEY_RE = /^[a-z][a-z0-9_]*$/;
+var styleBucketHasColor = (s) => s !== void 0 && s.color !== void 0;
+var textLayerHasAuthoringColor = (l) => {
+  if (styleBucketHasColor(l.style)) return true;
+  const bp = l.styleBreakpoints;
+  if (!bp) return false;
+  return styleBucketHasColor(bp.sm) || styleBucketHasColor(bp.md) || styleBucketHasColor(bp.lg) || styleBucketHasColor(bp.xl) || styleBucketHasColor(bp["2xl"]);
+};
+var iconLayerHasAuthoringColor = (l) => {
+  if (styleBucketHasColor(l.style)) return true;
+  const bp = l.styleBreakpoints;
+  if (!bp) return false;
+  return styleBucketHasColor(bp.sm) || styleBucketHasColor(bp.md) || styleBucketHasColor(bp.lg) || styleBucketHasColor(bp.xl) || styleBucketHasColor(bp["2xl"]);
+};
+var collectFlowBuilderIssues = (manifest) => {
+  const issues = [];
+  const fieldKeyOwners = /* @__PURE__ */ new Map();
+  const screenIds = new Set(manifest.screens.map((s) => s.id));
+  const jumpTargetIds = /* @__PURE__ */ new Set([
+    ...screenIds,
+    ...manifest.decisionNodes.map((d) => d.id),
+    ...(manifest.externalSurfaceNodes ?? []).map((n) => n.id)
+  ]);
+  if (manifest.entryScreenId == null) {
+    if (manifest.screens.length > 0) {
+      issues.push(
+        "Connect the flow entry node on the canvas to where the flow starts (a screen, decision, or integration step)."
+      );
+    }
+  } else if (!jumpTargetIds.has(manifest.entryScreenId)) {
+    issues.push(`Flow entry target "${manifest.entryScreenId}" does not exist.`);
+  }
+  for (const screen of manifest.screens) {
+    let inputCount = 0;
+    let oauthLoginLayerCount = 0;
+    let emailPasswordAuthLayerCount = 0;
+    let needsManualSubmit = false;
+    let hasContinueButton = false;
+    const screenLabel = screen.name || screen.id;
+    const mediaLayerIds = /* @__PURE__ */ new Set();
+    const buttonLayerIds = /* @__PURE__ */ new Set();
+    const shellPlaybackId = screenBackgroundPlaybackId(screen.id);
+    const shellFill = screen.containerStyle?.backgroundFill;
+    const shellVideoFill = shellFill?.kind === "video" ? shellFill : void 0;
+    walkScreen(screen, (l) => {
+      if (l.kind === "button") buttonLayerIds.add(l.id);
+    });
+    if (shellFill?.kind === "image" || shellFill?.kind === "video") {
+      if (!shellFill.media?.mediaAssetId) {
+        issues.push(
+          `Screen "${screenLabel}" ${shellFill.kind} background needs a media asset.`
+        );
+      }
+    }
+    if (shellVideoFill) {
+      if (shellVideoFill.autoPlay === false) {
+        const triggerId = shellVideoFill.triggerLayerId?.trim();
+        if (!triggerId) {
+          issues.push(
+            `Screen "${screenLabel}" background video needs a trigger button when auto-play is off.`
+          );
+        } else if (!buttonLayerIds.has(triggerId)) {
+          issues.push(
+            `Screen "${screenLabel}" background video references a missing trigger button "${triggerId}".`
+          );
+        } else {
+          const btn = findLayerById(screen, triggerId);
+          if (!btn || btn.kind !== "button") {
+            issues.push(
+              `Screen "${screenLabel}" background video trigger must be a button layer.`
+            );
+          } else if (btn.action.kind !== "play_media") {
+            issues.push(
+              `Screen "${screenLabel}" background video trigger button must use On Tap \u2192 Play media.`
+            );
+          } else if (!btn.action.targetLayerIds.includes(shellPlaybackId)) {
+            issues.push(
+              `Screen "${screenLabel}" background video is not listed on trigger button "${triggerId}".`
+            );
+          }
+        }
+      } else if (shellVideoFill.triggerLayerId) {
+        const btn = findLayerById(screen, shellVideoFill.triggerLayerId);
+        if (btn?.kind === "button" && btn.action.kind === "play_media" && !btn.action.targetLayerIds.includes(shellPlaybackId)) {
+          issues.push(
+            `Screen "${screenLabel}" background video trigger button does not target the screen background.`
+          );
+        }
+      }
+    }
+    walkScreen(screen, (l) => {
+      if (l.kind === "lottie" || l.kind === "video") mediaLayerIds.add(l.id);
+      if (l.kind === "oauth_login") {
+        oauthLoginLayerCount += 1;
+      }
+      if (l.kind === "email_password_auth") {
+        emailPasswordAuthLayerCount += 1;
+      }
+      if (l.kind === "button" && l.action.kind === "continue") {
+        hasContinueButton = true;
+      }
+      if (isInputLayer(l)) {
+        inputCount += 1;
+        if (l.kind === "multiple_choice" || l.kind === "text_input" || l.kind === "scale_input") {
+          needsManualSubmit = true;
+        }
+        const key = l.fieldKey;
+        const label = screen.name || screen.id;
+        if (!key || key.length === 0) {
+          issues.push(`Screen "${label}" is missing a variable name (fieldKey).`);
+        } else if (!FIELD_KEY_RE.test(key)) {
+          issues.push(
+            `Screen "${label}" has an invalid variable name "${key}" \u2014 use snake_case (a\u2013z, 0\u20139, _).`
+          );
+        } else {
+          const owners = fieldKeyOwners.get(key) ?? [];
+          owners.push(label);
+          fieldKeyOwners.set(key, owners);
+        }
+        if (l.kind === "single_choice" || l.kind === "multiple_choice") {
+          for (const cond of l.branching.conditions) {
+            if (!screenIds.has(cond.goTo)) {
+              issues.push(
+                `Screen "${label}" branches choice "${cond.choiceId}" to a missing screen "${cond.goTo}".`
+              );
+            }
+          }
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "go_to_step") {
+        if (!screenIds.has(l.action.screenId)) {
+          issues.push(
+            `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" targets a missing screen "${l.action.screenId}".`
+          );
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "request_app_review") {
+        const def = screen.next?.default;
+        if (def == null) {
+          issues.push(
+            `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" requests app review but the screen has no default next step.`
+          );
+        } else if (!screenIds.has(def) && !manifest.decisionNodes?.some((d) => d.id === def)) {
+          issues.push(
+            `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" requests app review but default next "${def}" is missing.`
+          );
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "request_os_permission") {
+        const o = l.action.outcomes;
+        for (const slot of ["granted", "denied", "blocked"]) {
+          const sid = o[slot];
+          if (sid === OS_PERMISSION_OUTCOME_END) {
+            continue;
+          }
+          if (sid === OS_PERMISSION_OUTCOME_CONTINUE) {
+            const def = screen.next?.default;
+            if (def == null) {
+              continue;
+            }
+            if (!screenIds.has(def) && !manifest.decisionNodes?.some((d) => d.id === def)) {
+              issues.push(
+                `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" (${slot}) continues to missing target "${def}".`
+              );
+            }
+            continue;
+          }
+          if (!screenIds.has(sid)) {
+            issues.push(
+              `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" (${slot}) targets a missing screen "${sid}".`
+            );
+          }
+        }
+      }
+      if (l.kind === "back_button" && l.fallbackScreenId && !screenIds.has(l.fallbackScreenId)) {
+        issues.push(
+          `Back button "${l.name || l.id}" on screen "${screen.name || screen.id}" uses a missing fallback screen "${l.fallbackScreenId}".`
+        );
+      }
+      if (l.kind === "button" && l.action.kind === "go_back_one_screen" && l.action.fallbackScreenId) {
+        if (!screenIds.has(l.action.fallbackScreenId)) {
+          issues.push(
+            `Button "${l.name || l.id}" on screen "${screen.name || screen.id}" uses a missing fallback screen "${l.action.fallbackScreenId}".`
+          );
+        }
+      }
+      if (l.kind === "lottie" || l.kind === "video") {
+        const media = l;
+        if (media.autoPlay === false) {
+          const triggerId = media.triggerLayerId?.trim();
+          if (!triggerId) {
+            issues.push(
+              `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" needs a trigger button when auto-play is off.`
+            );
+          } else if (!buttonLayerIds.has(triggerId)) {
+            issues.push(
+              `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" references a missing trigger button "${triggerId}".`
+            );
+          } else {
+            const btn = findLayerById(screen, triggerId);
+            if (!btn || btn.kind !== "button") {
+              issues.push(
+                `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" trigger must be a button layer.`
+              );
+            } else if (btn.action.kind !== "play_media") {
+              issues.push(
+                `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" trigger button must use On Tap \u2192 Play media (or pick the trigger again from this screen).`
+              );
+            } else if (!btn.action.targetLayerIds.includes(media.id)) {
+              issues.push(
+                `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" is not listed on trigger button "${triggerId}".`
+              );
+            }
+          }
+        } else if (media.triggerLayerId) {
+          const btn = findLayerById(screen, media.triggerLayerId);
+          if (btn?.kind === "button" && btn.action.kind === "play_media" && !btn.action.targetLayerIds.includes(media.id)) {
+            issues.push(
+              `${media.kind === "video" ? "Video" : "Lottie"} "${media.name || media.id}" on screen "${screenLabel}" trigger button does not target this layer.`
+            );
+          }
+        }
+      }
+      if (l.kind === "button" && l.action.kind === "play_media") {
+        for (const targetId of l.action.targetLayerIds) {
+          if (targetId === shellPlaybackId) {
+            if (!shellVideoFill) {
+              issues.push(
+                `Button "${l.name || l.id}" on screen "${screenLabel}" targets screen background video, but this screen has no video background.`
+              );
+            }
+            continue;
+          }
+          if (isScreenBackgroundPlaybackId(targetId)) {
+            issues.push(
+              `Button "${l.name || l.id}" on screen "${screenLabel}" play-media target "${targetId}" is not valid for this screen.`
+            );
+            continue;
+          }
+          if (!mediaLayerIds.has(targetId)) {
+            issues.push(
+              `Button "${l.name || l.id}" on screen "${screenLabel}" play-media target "${targetId}" must be a Lottie or video layer on this screen, or screen background video.`
+            );
+          }
+        }
+      }
+    });
+    if (oauthLoginLayerCount > 0 && inputCount > 0) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" cannot combine OAuth Login with input layers (${inputCount}). Split them onto separate screens.`
+      );
+    }
+    if (emailPasswordAuthLayerCount > 0 && inputCount > 0) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" cannot combine Email / password login with input layers (${inputCount}). Split them onto separate screens.`
+      );
+    }
+    if (oauthLoginLayerCount > 0 && emailPasswordAuthLayerCount > 0) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" cannot combine OAuth Login with Email / password login. Use one login block per screen.`
+      );
+    }
+    if (emailPasswordAuthLayerCount > 1) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" has ${emailPasswordAuthLayerCount} Email / password login layers; only one is allowed per screen.`
+      );
+    }
+    if (oauthLoginLayerCount > 1) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" has ${oauthLoginLayerCount} OAuth Login layers; only one is allowed per screen.`
+      );
+    }
+    if (inputCount > 1) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" has ${inputCount} input layers; only one is allowed.`
+      );
+    }
+    if (needsManualSubmit && !hasContinueButton) {
+      issues.push(
+        `Screen "${screen.name || screen.id}" has a multiple_choice, text_input, or scale_input but no Button with action "continue". Add a Continue button so users can submit.`
+      );
+    }
+  }
+  for (const [key, owners] of fieldKeyOwners) {
+    if (owners.length > 1) {
+      issues.push(`Variable name "${key}" is used by multiple screens: ${owners.join(", ")}.`);
+    }
+  }
+  for (const screen of manifest.screens) {
+    walkScreen(screen, (l) => {
+      const screenLabel = screen.name || screen.id;
+      if (l.kind === "text" && !textLayerHasAuthoringColor(l)) {
+        issues.push(
+          `Screen "${screenLabel}": text layer "${l.id}" must set style.color for light and dark (CSS inheritance does not apply on native).`
+        );
+      }
+      if (l.kind === "icon" && !iconLayerHasAuthoringColor(l)) {
+        issues.push(
+          `Screen "${screenLabel}": icon layer "${l.id}" must set style.color for light and dark.`
+        );
+      }
+    });
+  }
+  return issues;
+};
+
+// src/agentPrompt/builderRulesFragment.ts
+var buildBuilderRulesFragment = () => [
+  "Builder publish rules (enforced on merge \u2014 fix violations before retry):",
+  ...BUILDER_RULES_AGENT_BULLETS.map((b) => `- ${b}`)
+].join("\n");
+
+// src/agentPrompt/layerStyling.ts
+var buildLayerStylingRules = () => `Colors and custom styling (required when the user asks for specific colors, contrast, or different light vs dark appearance):
+- Layers may include a "style" object. For fills and foregrounds use schema keys "background" and "color" only \u2014 never backgroundColor, borderColor, or CSS kebab-case.
+- Values: hex strings (e.g. "#2563eb", "#ffffff") or per-appearance objects: { "light": "#...", "dark": "#..." } with at least one key. When the user wants different colors in light vs dark mode, prefer the object form for "background" and "color".
+- Example solid blue CTA on a button layer: "variant":"primary","style":{"background":"#2563eb","color":"#ffffff"} (variant still required; style overrides the preset fill/label colors in the sim).
+- Buttons: always set "variant" (primary|secondary|ghost|destructive). Preset variants are monochrome; when the user names a color (e.g. blue), add "style": { "background": "<hex or {light,dark}>", "color": "<readable contrast>" } on the button. You may instead set "color" on the nested text child inside button "children" for label tint.
+- Text / stack / icon: "style".background, "style".color, "style".border, "style".radius work the same (ThemedColor for colored fields).
+- Text alignment stays "align": left|center|right \u2014 never textAlign.`;
+
+// src/agentPrompt/flowGenWorkflow.ts
+var buildFlowGenWorkflowRules = () => `You are an expert mobile onboarding flow designer for Rheo.
+Reply with ONE JSON object only (no markdown, no prose). Shape: { "done": boolean, "screen"?: <Screen> }
+If done=true, omit "screen". If done=false, include a complete "screen".
+
+Preferred pattern: one regions.body stack (vertical), padding only in body.style (CommonStyle), gap/direction on the stack itself.
+Minimal valid screen (IDs are examples \u2014 use unique scr_/lyr_ ids):
+{"id":"scr_intro","name":"Intro","regions":{"body":{"id":"lyr_body","kind":"stack","direction":"vertical","gap":16,"style":{"width":"full","height":"fill","padding":{"t":24,"r":20,"b":24,"l":20}},"children":[
+ {"id":"lyr_title","kind":"text","text":{"default":"Welcome"},"style":{"width":"auto","height":"auto","fontSize":24,"fontWeight":700,"align":"center","color":"#0f172a"}},
+ {"id":"lyr_sub","kind":"text","text":{"default":"Short subtitle."},"style":{"width":"auto","height":"auto","fontSize":16,"fontWeight":400,"align":"center","color":"#64748b"}},
+ {"id":"lyr_next","kind":"button","variant":"primary","action":{"kind":"continue"},"direction":"horizontal","align":"center","distribution":"center","style":{"width":"full","height":"auto"},"children":[
+   {"id":"lyr_next_t","kind":"text","text":{"default":"Continue"},"style":{"width":"auto","height":"auto","color":"#ffffff"}}
+ ]}
+]}},"next":{"default":null}}
+
+Workflow rules:
+- Mirror the user's language in default copy.
+- Never change manifest.flowId, defaultLocale, locales, theme, version from the prompt payload.
+- Screen/layer ids: /^scr_[a-z0-9_]+$/i and /^lyr_[a-z0-9_]+$/i only (letters, numbers, underscores).
+- regions.body is required and must be kind "stack". Omit header/footer unless you need them.
+- screen.next.default must be null \u2014 the server chains screens on the default path.
+- Avoid carousel and branching choices unless necessary \u2014 they are easier to get wrong.
+
+Placeholder scr_blank still present \u2192 done=false with first real screen replacing it.
+User flow complete on default path \u2192 done=true.
+
+Never done=true until a real screen exists (not before replacing scr_blank).`;
+
+// src/agentPrompt/manifestContext.ts
+var themeSummary = (manifest) => {
+  const t = manifest.theme;
+  if (!t) return "theme: (default)";
+  const parts = [];
+  if (t.primary) parts.push(`primary=${t.primary}`);
+  if (t.background) parts.push(`background=${t.background}`);
+  if (t.foreground) parts.push(`foreground=${t.foreground}`);
+  if (t.fontFamily) parts.push(`fontFamily=${t.fontFamily}`);
+  return parts.length > 0 ? `theme: ${parts.join(", ")}` : "theme: (partial/default)";
+};
+var graphSummary = (manifest) => {
+  const screenLines = manifest.screens.map((s) => `- ${s.id}: ${s.name}${s.next.default ? ` \u2192 ${s.next.default}` : " \u2192 (end)"}`).join("\n");
+  const decisionIds = (manifest.decisionNodes ?? []).map((n) => n.id);
+  const surfaceIds = (manifest.externalSurfaceNodes ?? []).map((n) => n.id);
+  const sdkKeys = manifest.sdkAttributeKeys ?? [];
+  return [
+    `schemaVersion: ${manifest.schemaVersion ?? "(unset)"}`,
+    `defaultLocale: ${manifest.defaultLocale}`,
+    themeSummary(manifest),
+    `sdkAttributeKeys: ${sdkKeys.length ? sdkKeys.join(", ") : "(none)"}`,
+    `entryScreenId: ${manifest.entryScreenId ?? "(unset)"}`,
+    `screens:
+${screenLines || "(none)"}`,
+    `decisionNodes: ${decisionIds.length ? decisionIds.join(", ") : "(none)"}`,
+    `externalSurfaceNodes: ${surfaceIds.length ? surfaceIds.join(", ") : "(none)"}`
+  ].join("\n");
+};
+var focusedDecisionIds = (selection) => {
+  if (selection.decisionIds?.length) return selection.decisionIds;
+  if (selection.decisionId) return [selection.decisionId];
+  return [];
+};
+var focusedScreenIds = (selection) => {
+  if (selection.screenIds?.length) return selection.screenIds;
+  if (selection.screenId) return [selection.screenId];
+  return [];
+};
+var screensJson = (manifest, ids) => manifest.screens.filter((s) => ids.includes(s.id));
+var slimManifestForRheoAgentPrompt = (manifest, selection) => {
+  const summary = graphSummary(manifest);
+  if (!selection) {
+    return `Flow graph summary (server holds the full draft \u2014 emit patch entries only for what you change):
+${summary}`;
+  }
+  const screenIds = focusedScreenIds(selection);
+  if (screenIds.length > 0) {
+    const focused = screensJson(manifest, screenIds);
+    return `Focused screens (full JSON for the canvas selection):
+${JSON.stringify(focused)}
+
+Rest of the flow (graph summary \u2014 emit patch entries only for screens/nodes you change):
+${summary}`;
+  }
+  const decisionIds = focusedDecisionIds(selection);
+  if (decisionIds.length > 0) {
+    const focused = (manifest.decisionNodes ?? []).filter((n) => decisionIds.includes(n.id));
+    return `Focused decision nodes (full JSON):
+${JSON.stringify(focused)}
+
+Rest of the flow (graph summary):
+${summary}`;
+  }
+  if (selection.externalSurfaceId) {
+    const node = (manifest.externalSurfaceNodes ?? []).find(
+      (n) => n.id === selection.externalSurfaceId
+    );
+    return `Focused external surface node (full JSON):
+${JSON.stringify(node ?? null)}
+
+Rest of the flow (graph summary):
+${summary}`;
+  }
+  return `Flow graph summary (server holds the full draft \u2014 emit patch entries only for what you change):
+${summary}`;
+};
+var buildRheoAgentSystemPrompt = (draftManifest, selection, parts) => {
+  const gatesBlock = parts.canvasGatesLine ? `
+App-specific canvas editor policy (must comply):
+${parts.canvasGatesLine}
+` : "";
+  return `You are Rheo Agent \u2014 an in-builder assistant that edits mobile onboarding flow manifests.
+
+${parts.schemaRules}
+
+${parts.builderRules}
+
+${parts.layerStyling}
+${gatesBlock}
+Current draft (builderMeta omitted \u2014 do not invent builderMeta):
+${slimManifestForRheoAgentPrompt(draftManifest, selection)}
+
+${parts.selectionBlock}
+
+When the user attaches screenshot(s), treat them as visual reference for layout, copy, colors, and styling.`;
+};
+var validateManifest = (data) => {
+  const migrated = migrateLegacyManifest(data);
+  const result = FlowManifestSchema.safeParse(migrated);
+  if (result.success) return { ok: true, manifest: result.data };
+  return {
+    ok: false,
+    issues: result.error.issues.map((i) => {
+      const screenIdx = i.path[1];
+      const screenId = typeof screenIdx === "number" && Array.isArray(data?.screens) ? data.screens[screenIdx]?.id : void 0;
+      return {
+        stepId: screenId ?? null,
+        path: [...i.path],
+        message: i.message,
+        code: i.code
+      };
+    })
+  };
+};
+
+// src/agentPrompt/validate.ts
+var validateAgentManifestOutput = (data, opts) => {
+  const validated = validateManifest(data);
+  if (!validated.ok) {
+    return { ok: false, issues: validated.issues };
+  }
+  const issues = [];
+  if (opts?.includeBuilderRules !== false) {
+    for (const message of collectFlowBuilderIssues(validated.manifest)) {
+      issues.push({
+        path: [],
+        message,
+        code: "builder.rule",
+        stepId: null
+      });
+    }
+  }
+  if (opts?.canvasGates) {
+    for (const message of collectCanvasGateViolations(validated.manifest, opts.canvasGates)) {
+      issues.push({
+        path: [],
+        message,
+        code: "canvas.gate",
+        stepId: null
+      });
+    }
+  }
+  if (issues.length > 0) {
+    return { ok: false, issues };
+  }
+  return { ok: true, manifest: validated.manifest };
+};
+var formatAgentManifestIssues = (issues, max = 18) => JSON.stringify(
+  issues.slice(0, max).map((i) => ({
+    path: i.path.join("."),
+    message: i.message,
+    code: i.code
+  }))
+);
+
+export { BUILDER_RULES_AGENT_BULLETS, buildBuilderRulesFragment, buildCanvasScreenSchemaRules, buildCapabilitySurfaceFragment, buildDecisionSurfaceRules, buildFlowGenWorkflowRules, buildFlowManifestPatchRules, buildLayerExamplesFragment, buildLayerStylingRules, buildRheoAgentSchemaRules, buildRheoAgentSystemPrompt, buttonActionKinds, formatAgentManifestIssues, slimManifestForRheoAgentPrompt, validateAgentManifestOutput };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map