@ggui-ai/ui-gen 0.28.0 → 0.29.0

package/dist/llm-evaluator-PN3WFCS4.js

@@ -0,0 +1,653 @@
+import { createAgent } from './chunk-O2YC6XDC.js';
+import './chunk-QLXXPGTV.js';
+import './chunk-JDH5EGNZ.js';
+import './chunk-OVLH5ICV.js';
+import './chunk-7QE3AHLE.js';
+import './chunk-5AGTY555.js';
+import { buildStylingProfileJudgeBlock } from './chunk-NF6JUZWF.js';
+import { LLM_EVAL_STATIC_CRITERIA, getCriterionById } from './chunk-PUH4CXGZ.js';
+import { DEFAULT_DESIGN_MODE } from './chunk-3T2HMTON.js';
+import './chunk-G3PMV62Z.js';
+
+// src/evaluation/llm-evaluator.ts
+function coerceStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => typeof v === "string" && v.length > 1);
+  }
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((v) => typeof v === "string" && v.length > 1);
+      }
+    } catch {
+      if (value.length > 1) return [value];
+    }
+  }
+  return [];
+}
+var FREE_STYLING_RULES = `## Styling Rules (important for evaluation)
+- Color: every color must be a bare \`var(--ggui-color-*)\` token \u2014 a hardcoded #hex, rgb()/hsl() or CSS named color is a fail, and so is a literal fallback inside \`var(--ggui-*, \u2026)\`.
+- Accent text (eyebrow, tagline, link, label) painted with a bare \`var(--ggui-color-primary-300\u2026600)\` is a readability fail \u2014 the accent ink is \`var(--ggui-color-link)\`; a tint as text on a primary fill and a deep stop (700\u2013900) on a light tint are fine
+- Spacing, typography, radius, shadow geometry and layout values MAY be literals (\`padding: '20px'\`, \`fontSize: 18\`, \`borderRadius: 12\`) \u2014 NEVER flag them.
+- Raw HTML elements with inline styles or \`<style>\` blocks are a first-class choice \u2014 never flag "not using the design system" or reward using it.
+- When \`@ggui-ai/design\` primitives ARE used, their enum/scale props (\`variant="primary"\`, \`size="lg"\`, \`gap="md"\`, \`tone="muted"\`, \`surface="accent"\`) are valid.
+- One \`export default function Component\` \u2014 helper components as named functions above it are fine`;
+var CONSTRAINED_STYLING_RULES = `## Design System Rules (important for evaluation)
+- Spacing props (\`gap\`, \`padding\`, \`margin\`) take a t-shirt-scale name: \`gap="md"\`, \`padding="lg"\` (\`none|xs|sm|md|lg|xl|2xl\`). **These ARE design tokens** \u2014 each resolves to a \`--ggui-spacing-*\` variable. A raw \`var(--ggui-spacing-*)\` string is an accepted escape hatch. NEVER flag a scale name as "hardcoded". Only a numeric prop (\`padding={24}\`) or a raw CSS length (\`gap="13px"\`) bypasses the scale and should be warned.
+- All colors must use CSS variables: \`color="var(--ggui-color-onContainer)"\` \u2014 hardcoded #hex or rgb() is a fail
+- Accent text (eyebrow, tagline, link, label) painted with a bare \`primary-300\u2026600\` stop is a readability fail \u2014 the accent ink is \`var(--ggui-color-link)\` (or \`tone="emphasized"\`); tints as text on a primary fill and deep stops on a light tint are fine
+- Component props that take enum/scale values \u2014 \`variant="primary"\`, \`size="lg"\`, \`gap="md"\`, \`padding="lg"\`, \`shadow="md"\`, \`radius="lg"\`, \`tone="muted"\`, \`surface="accent"\` \u2014 are all design system tokens and are always valid
+- One \`export default function Component\` \u2014 helper components as named functions above it are fine`;
+var CONSTRAINED_VISUAL_REFERENCE = `**visual**: Design system consistency.
+- Uses CSS variables (var(--ggui-*)) for colors, not hardcoded values
+- Consistent use of spacing tokens
+- Proper use of component variants (primary, outline, ghost)
+- Shadow, border-radius from design system tokens`;
+var FREE_VISUAL_REFERENCE = `**visual**: Visual composition.
+- Clear hierarchy (one focal point, headings distinct from body), consistent spacing rhythm
+- Coherent palette drawn from the theme color tokens
+- Fit to the canvas: fluid width, nothing cramped or stretched
+- No reward or penalty for using (or not using) the design-system primitives`;
+var CONSTRAINED_RAW_CLICK_TARGET_GAP = `- A raw \`<div>\` / \`<span>\` used as a click target without \`as={Clickable}\`
+  (no role, no keyboard) \u2014 or any hand-rolled interactive element.`;
+var FREE_RAW_CLICK_TARGET_GAP = `- A raw \`<div>\` / \`<span>\` used as a click target with no \`role="button"\`,
+  \`tabIndex\` and keyboard handler \u2014 a real \`<button>\` / \`<a href>\` is the
+  correct raw element and is never a gap.`;
+function buildMotherPrompt(ctx) {
+  const parts = [];
+  const designMode = ctx.designMode ?? DEFAULT_DESIGN_MODE;
+  const free = designMode === "free";
+  parts.push(
+    free ? `You are evaluating a generated React component. It was composed freely \u2014 raw HTML elements, inline styles and <style> blocks are allowed and the ggui design package is optional \u2014 against a data contract and a theme-token color rule.
+The code has already passed automated checks (compilation, security, imports, color tokens).
+Your job is to evaluate ONE specific quality criterion per call.` : `You are evaluating a generated React component built with the ggui design system.
+The code has already passed automated checks (compilation, security, imports, design tokens).
+Your job is to evaluate ONE specific quality criterion per call.`
+  );
+  parts.push(`## About This Prompt
+This system prompt has 2 sections:
+1. **Context** \u2014 the original user request and data contract
+2. **Criteria Reference** \u2014 definitions for all 7 evaluation criteria (your call will focus on one)
+
+## Input Messages
+You will receive ONE user message per call containing:
+1. Which criterion to evaluate (e.g., "Evaluate FUNCTIONALITY")
+2. The source code with line numbers
+3. Example outputs showing the expected tool response format
+
+Respond with a single tool call (evaluate_{criterion}). Report ALL issues you find for that criterion, not just the first one. Each issue should be an actionable fix instruction.
+
+## Issue-array discipline (applies to EVERY criterion)
+The "issues" array is for confirmed defects ONLY. Before adding an entry, it must be something you are CERTAIN is missing or broken. NEVER add:
+- a self-negating note ("\u2026actually this is fine", "so no issue here", "no actual crash scenarios are present");
+- a speculative / conditional note ("if the data is shaped X then\u2026", "this may break when\u2026");
+- a "should be verified" / "double-check that\u2026" note.
+If you are not certain something is broken, it is a PASS \u2014 omit it entirely. An entry you describe as acceptable still counts against the score, so describing a non-issue is worse than saying nothing.`);
+  parts.push(`## Original Request
+${ctx.originalPrompt}`);
+  if (ctx.contract) {
+    parts.push(`## Data Contract (JSON Schema \u2192 TypeScript types)
+
+The component's boilerplate was generated from this contract. All types are compiler-enforced:
+- \`props\` \u2192 \`interface Props\` \u2014 every field must be rendered in the UI
+- \`actionSpec\` (flat map keyed by action name) \u2192 \`useAction<Payload>(name)\` hooks \u2014 each must be wired to a UI element (button, form, etc.)
+- \`actionSpec[name].nextStep\` (optional) \u2014 names an agent-side MCP tool the agent SHOULD invoke on its
+  next turn after the action fires. Surfaces as advisory event metadata; the component does NOT call
+  the named tool. Use it to judge whether button labels/icons match the underlying action's intent.
+- \`streamSpec\` (flat map keyed by channel name) \u2192 \`useStream<T>(name)\` hooks \u2014 each must be consumed with null guard (\`.latest && ...\`)
+- \`agentCapabilities.tools\` is a READ-ONLY catalog \u2014 the AGENT invokes these. The component never calls them.
+  References surface only via \`actionSpec[*].nextStep\` and \`streamSpec[*].source.tool\`. Do NOT flag
+  missing component-side calls for these.
+- \`clientCapabilities.gadgets\` \u2192 a map keyed by npm PACKAGE name; each package maps export
+  names to a descriptor. Two kinds, both contract features that MUST be used:
+  \u2022 Built-in browser capabilities (\`useGeolocation\`, \`useCamera\`, \`useClipboardWrite\`,
+    \`useMicrophone\`, \`useFilePicker\`, \`useClipboardPaste\`, \`useNotifications\`) \u2014 imported
+    from \`@ggui-ai/gadgets\`.
+  \u2022 Registered third-party gadgets \u2014 hooks or components \u2014 imported from their OWN package
+    (e.g. \`import { useChartTheme } from '@ggui-samples/gadget-chart'\`). The boilerplate
+    emits that import. Any export listed under \`clientCapabilities.gadgets\` IS part of the
+    contract \u2014 NEVER flag it as "not part of the contract".
+
+\`\`\`json
+${JSON.stringify(ctx.contract).slice(0, 6e3)}
+\`\`\``);
+  }
+  if (ctx.designSystemSummary) {
+    parts.push(`## Design System
+${ctx.designSystemSummary}`);
+  }
+  parts.push(`${free ? FREE_STYLING_RULES : CONSTRAINED_STYLING_RULES}
+
+## Evaluation Criteria Reference
+
+### Tier 1 \u2014 Critical (blocks delivery)
+
+**functionality**: Does the component implement ALL features in the original request?
+- Check every noun/verb in the request against the rendered output
+- Missing feature = fail, even if other features work perfectly
+- Partial implementation = fail (e.g., search UI exists but doesn't filter)
+
+**crash**: Are there runtime crash scenarios?
+- Uninitialized state used in render (e.g., items.map when items could be undefined)
+- Missing event handlers referenced in JSX
+- Destructuring undefined objects
+- Array access without bounds checking
+- Missing null/undefined guards before .map(), .filter(), .length
+
+### Tier 2 \u2014 Quality (fail if severe, warn if improvement)
+
+**interactivity**: Does it have interactive elements appropriate for its purpose?
+- Forms should have submit buttons
+- Lists should be navigable
+- Editable fields should have save/cancel
+- Interactive components should have hover/focus feedback
+
+**accessibility**: Semantic HTML, labels, alt text, keyboard navigation, ARIA state.
+- Form inputs must have associated labels (label prop or aria-label)
+- Images need alt text
+- Interactive elements need keyboard support
+- Interactive controls expose their state (aria-checked / aria-selected / aria-expanded / aria-pressed), never styling alone
+- Proper heading hierarchy (h1 > h2 > h3)
+
+**layout**: Spacing, alignment, visual grouping.
+- Consistent spacing between sections
+- Related items grouped visually
+- No overlapping or cramped elements
+- Proper use of containers and cards for grouping
+
+**loading**: Loading/error/empty states for dynamic data.
+- Components receiving async data should show loading state
+- Error boundaries or error messages for failure cases
+- Empty states ("No items found") when data arrays could be empty
+
+${free ? FREE_VISUAL_REFERENCE : CONSTRAINED_VISUAL_REFERENCE}
+
+## Primitive Accessibility (built-in \u2014 do NOT flag as missing)
+
+ggui design-system primitives ship their own ARIA. The code you are
+reading imports them from \`@ggui-ai/design\`; the source does NOT show
+their internal markup. NEVER report a primitive below as missing a
+role, aria-*, label, or keyboard support \u2014 it is already there:
+
+- \`Input\` / \`Select\` / \`TextArea\` \u2014 render a real \`<label htmlFor>\` from
+  the \`label\` prop, plus \`aria-invalid\` + \`aria-describedby\` + an error
+  \`role="alert"\`. A primitive that has a \`label\` prop IS labelled.
+- \`RadioGroup\` \u2014 \`role="radiogroup"\` + \`aria-labelledby\` from its \`label\`.
+- \`Checkbox\` \u2014 wrapped in its own \`<label>\`.
+- \`Toggle\` \u2014 \`role="switch"\` + \`aria-checked\` + \`aria-label\`.
+- \`Progress\` \u2014 \`role="progressbar"\` + \`aria-valuenow/min/max\` + \`aria-label\`.
+- \`Slider\` \u2014 full \`aria-valuenow/min/max\` slider semantics.
+- \`Spinner\` \u2014 \`role="status"\` + \`aria-label="Loading"\`.
+- \`Skeleton\` \u2014 \`aria-hidden\` (correctly decorative).
+- \`Tabs\` \u2014 full \`role="tablist"/"tab"/"tabpanel"\` + \`aria-selected/controls\`.
+- \`Stepper\` \u2014 \`<nav aria-label="Progress">\` + \`aria-current="step"\` on the
+  active step; steps become real buttons when \`onStepClick\` is passed. It is
+  display-only by design \u2014 the component owning the step index in its own
+  \`useState\` is CORRECT, never a gap.
+- \`Accordion\` \u2014 \`aria-expanded\` + \`aria-controls\` + \`role="region"\`.
+- \`Alert\` \u2014 \`role="alert"\`; \`Toast\` \u2014 \`role="alert"\` + \`aria-live\`.
+- \`Tooltip\` \u2014 \`role="tooltip"\`.
+- \`Clickable\` (trait, applied via \`as={Clickable}\`) \u2014 \`role="button"\` +
+  \`tabIndex={0}\` + Enter/Space keyboard activation.
+- \`Icon\` \u2014 decorative by default (\`aria-hidden\`); exposes \`role="img"\` +
+  the label ONLY when an \`aria-label\` prop is passed. A bare \`<Icon>\` next
+  to text is CORRECTLY silent \u2014 never ask for \`aria-hidden\`, it is there.
+
+REAL accessibility gaps worth flagging:
+${free ? FREE_RAW_CLICK_TARGET_GAP : CONSTRAINED_RAW_CLICK_TARGET_GAP}
+- A hand-rolled control whose state (checked / selected / expanded /
+  pressed) is conveyed ONLY by styling \u2014 e.g. a styled-div "checkbox"
+  with a check icon + strikethrough label but no \`role="checkbox"\` /
+  \`aria-checked\`. Note \`as={Clickable}\` adds button + keyboard
+  semantics but NOT state \u2014 \`aria-checked\` / \`aria-pressed\` /
+  \`aria-selected\` / \`aria-expanded\` must be passed explicitly.
+- An \`<img>\` / \`<Image>\` with no alt text.
+- \`<Input>\` / \`<Select>\` / \`<TextArea>\` used with NO \`label\` prop.
+- An icon-only \`<Button>\` (no text child) with no \`aria-label\`.
+- Live or streaming data (stream \`.latest\`, counters, real-time clocks)
+  rendered in a plain element with no \`aria-live\` / \`role="status"\`.
+- Inverted or skipped heading levels (an \`<Heading level={3}>\` rendered
+  before the page's \`<Heading level={1}>\`).`);
+  const profileBlock = buildStylingProfileJudgeBlock(ctx.profile);
+  if (profileBlock.length > 0) parts.push(profileBlock);
+  return parts.join("\n\n");
+}
+function makeTier1Tool(criterion) {
+  return {
+    name: `evaluate_${criterion}`,
+    description: `Submit evaluation result for ${criterion}`,
+    parameters: {
+      type: "object",
+      required: ["pass"],
+      properties: {
+        pass: { type: "boolean" },
+        issues: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of specific issues found"
+        }
+      }
+    }
+  };
+}
+function makeTier2Tool(criterion) {
+  return {
+    name: `evaluate_${criterion}`,
+    description: `Submit evaluation result for ${criterion}`,
+    parameters: {
+      type: "object",
+      required: ["result"],
+      properties: {
+        result: {
+          type: "string",
+          enum: ["fail", "warn", "pass"]
+        },
+        issues: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of specific issues found"
+        }
+      }
+    }
+  };
+}
+function getCriterionPrompt(criterion, numberedSource, designMode) {
+  const sourceBlock = `
+Source code (with line numbers):
+\`\`\`tsx
+${numberedSource}
+\`\`\``;
+  const criterionDef = getCriterionById(criterion, designMode);
+  if (criterionDef && criterionDef.tier > 0) {
+    return `${criterionDef.evalInstruction}
+${sourceBlock}
+
+Return your evaluation using the evaluate_${criterion} tool.`;
+  }
+  switch (criterion) {
+    case "functionality":
+      return `Evaluate FUNCTIONALITY: Does this component implement ALL features from the request AND the data contract?
+
+Check against BOTH sources:
+1. **Original request** \u2014 each feature must be coded AND rendered in JSX
+2. **Data contract** (if present in the context above) \u2014 verify:
+   - ALL Props fields are rendered somewhere in the UI (not just accepted as params)
+   - ALL useAction hooks are wired to clickable UI elements (buttons, forms, cards)
+   - ALL useStream hooks have their \`.latest\` data rendered (with null guard)
+   - ALL clientCapabilities hooks (useGeolocation / useCamera / etc.) are called in the component body and their values either render directly or thread into a context / action payload
+
+A contract hook that is declared but never used in JSX is a MISSING feature.
+
+**CRITICAL RULE:** The "issues" array must ONLY contain MISSING or BROKEN features. Do NOT list features that ARE implemented.
+
+Design token usage (hardcoded colors, numeric spacing) is NOT a functionality issue \u2014 ignore it here.
+${sourceBlock}
+
+Return your evaluation using the evaluate_functionality tool.
+
+Example outputs:
+- All features present: {"pass": true}
+- Missing features: {"pass": false, "issues": ["Add Task form is not rendered \u2014 only state logic exists", "useAction('refresh') is declared but never wired to any button"]}
+
+Only missing or broken features go in the issues array. Nothing else.`;
+    case "crash":
+      return `Evaluate CRASH SAFETY: Are there ACTUAL runtime crash scenarios in this component?
+
+**CRITICAL RULE:** The "issues" array must ONLY contain code that WILL crash. Do NOT include safe code in the issues array \u2014 not even to explain why it's safe. If you checked a line and it has a guard, do not mention it at all.
+
+**These WILL crash (include in issues):**
+- .map() / .filter() / .length on a variable that is never initialized
+- Accessing a property of a value that could be undefined without a guard
+- Calling a function that is never defined
+- useStream().latest.field WITHOUT null guard \u2014 .latest is T | null
+- Optional Props field (has \`?\` in interface) accessed as props.field.x without guard \u2014 WILL crash if undefined
+- Array item field that could be undefined: items.map(item => item.priority.toUpperCase()) when priority is optional
+
+**These are SAFE (do NOT include in issues):**
+- Optional chaining: props.items?.map() \u2014 SAFE, skip it
+- Fallback values: items || [] \u2014 SAFE, skip it
+- Default parameters: (items = []) \u2014 SAFE, skip it
+- useState initializer: useState([]) \u2014 SAFE, skip it
+- Null check: items && items.map() \u2014 SAFE, skip it
+- stream.latest && stream.latest.field \u2014 SAFE, guarded
+- stream.all.map(...) \u2014 SAFE, .all is always an array (never null)
+- stream.all.length \u2014 SAFE, always a number
+- toolResult.data && toolResult.data.field \u2014 SAFE, guarded
+
+If everything is safe, return {"pass": true} with no issues array.
+${sourceBlock}
+
+Return your evaluation using the evaluate_crash tool.
+
+Example outputs:
+- Everything safe: {"pass": true}
+- Has crash: {"pass": false, "issues": ["Line 41: selectedItem.name \u2014 selectedItem comes from .find() which returns undefined when no match, no guard"]}
+
+Only unguarded crash risks go in the issues array. Nothing else.`;
+    case "interactivity":
+      return `Evaluate INTERACTIVITY: Does this component have sufficient interactive elements for its purpose?
+
+Consider: forms need submit buttons, lists need selection/navigation, editable content needs save/cancel, interactive elements need hover/focus feedback.
+
+**Contract actions** (if present): every useAction hook from the data contract should be triggered by a visible, clickable UI element. A declared action with no triggering button/link/form is a missing interaction.
+
+**Only list MISSING interactive elements in the issues array.** Do not list interactions that are present and working.
+${sourceBlock}
+
+Return your evaluation using the evaluate_interactivity tool.
+
+Example outputs:
+- Sufficient: {"result": "pass"}
+- Minor gap: {"result": "warn", "issues": ["No hover feedback on list items \u2014 users can't tell items are clickable"]}
+- Severe gap: {"result": "fail", "issues": ["Form has no submit button \u2014 users cannot complete the workflow"]}
+
+Use 'fail' only for issues that block the component's core purpose.`;
+    case "accessibility":
+      return `Evaluate ACCESSIBILITY: Check for missing labels, alt text, semantic HTML, keyboard navigation.
+
+Look for: form inputs without labels, images without alt text, non-semantic elements used for interactive purposes, missing aria attributes, heading hierarchy issues.
+
+**Only list MISSING accessibility features in the issues array.** Do not list things that are already accessible.
+${sourceBlock}
+
+Return your evaluation using the evaluate_accessibility tool.
+
+Example outputs:
+- Clean: {"result": "pass"}
+- Minor issues: {"result": "warn", "issues": ["Email input missing label prop", "Task edit uses double-click with no keyboard alternative"]}
+- Severe: {"result": "fail", "issues": ["No form inputs have labels \u2014 entire form is inaccessible to screen readers"]}
+
+Use 'fail' only if the issue blocks delivery. Use 'warn' for improvements.`;
+    case "layout":
+      return `Evaluate LAYOUT: Check spacing, alignment, visual grouping, and overall composition.
+
+Look for: inconsistent spacing, cramped elements, missing visual grouping (cards/sections), overlapping concerns in single containers, poor responsive patterns.
+
+**Only list ACTUAL layout problems in the issues array.** Do not list layout aspects that are working correctly.
+${sourceBlock}
+
+Return your evaluation using the evaluate_layout tool.
+
+Example outputs:
+- Clean: {"result": "pass"}
+- Minor issues: {"result": "warn", "issues": ["Header and content area have no visual separation", "Button group lacks consistent spacing"]}
+- Severe: {"result": "fail", "issues": ["All content rendered in a flat list with no visual structure \u2014 needs cards or sections"]}
+
+Use 'fail' only for layouts that are fundamentally broken.`;
+    case "loading":
+      return `Evaluate LOADING/EMPTY/ERROR STATES: Does the component handle async data, empty collections, and error cases?
+
+Look for: arrays that could be empty but have no empty state message, missing error handling for operations that can fail.
+
+**Contract-specific checks** (if present):
+- useStream hooks deliver data over time \u2014 consider showing a "waiting for data" state before .latest arrives
+- clientCapabilities hooks (e.g. useGeolocation) may return permission denials or undefined values \u2014 defensive null guards expected before threading into JSX
+
+**Only list MISSING states in the issues array.** Do not list states that are already handled. Components that receive all data via props (no streams, no async capabilities) do NOT need loading states \u2014 return pass.
+${sourceBlock}
+
+Return your evaluation using the evaluate_loading tool.
+
+Example outputs:
+- Not applicable (props-driven): {"result": "pass"}
+- Missing states: {"result": "warn", "issues": ["No empty state when items array is empty \u2014 should show 'No items found'"]}
+- Severe: {"result": "fail", "issues": ["Component shows blank screen when data hasn't loaded yet \u2014 needs loading spinner"]}`;
+    case "visual":
+      return `Evaluate VISUAL CONSISTENCY: Is the component using the design system correctly?
+
+Look for: hardcoded colors instead of CSS variables, numeric/raw-CSS spacing props that bypass the t-shirt scale, style objects that bypass the design system.
+
+**Only list ACTUAL design system violations in the issues array.** Do not list correct token usage. A t-shirt-scale spacing name (\`gap="md"\`, \`padding="lg"\`) IS correct token usage \u2014 never flag it as hardcoded; only numeric (\`padding={16}\`) or raw-CSS-length (\`gap="13px"\`) spacing is a violation. Note: intentional custom colors (e.g., status indicators, category colors) are acceptable when no semantic token fits.
+${sourceBlock}
+
+Return your evaluation using the evaluate_visual tool.
+
+Example outputs:
+- Clean: {"result": "pass"}
+- Minor issues: {"result": "warn", "issues": ["Line 45: hardcoded '#f3f4f6' should use var(--ggui-color-sunken)", "Line 80: numeric padding={16} should use a scale name like padding='md'"]}
+- Severe: {"result": "fail", "issues": ["Component uses entirely custom styling with no design system tokens"]}
+
+Use 'fail' only for pervasive design system violations. Use 'warn' for isolated cases.`;
+    default:
+      return `Evaluate ${criterion.toUpperCase()}.${sourceBlock}
+
+Return your evaluation using the evaluate_${criterion} tool.`;
+  }
+}
+function getDefaultEvalModel(provider) {
+  switch (provider) {
+    case "claude":
+      return "claude-haiku-5-5";
+    case "openai":
+      return "gpt-5.6-luna";
+    case "google":
+      return "gemini-3.5-flash-lite";
+    default:
+      return "claude-haiku-5-5";
+  }
+}
+function callTokens(response) {
+  return {
+    in: response.inputTokens,
+    out: response.outputTokens,
+    ...response.cacheReadTokens !== void 0 ? { cacheRead: response.cacheReadTokens } : {},
+    ...response.cacheCreationTokens !== void 0 ? { cacheCreation: response.cacheCreationTokens } : {}
+  };
+}
+var TIER_1_CRITERIA = LLM_EVAL_STATIC_CRITERIA.filter((c) => c.tier === 1).map((c) => c.criterion);
+var TIER_2_CRITERIA = LLM_EVAL_STATIC_CRITERIA.filter((c) => c.tier === 2).map((c) => c.criterion);
+async function evalCriterion(criterion, tier, motherPrompt, numberedSource, agent, model, designMode) {
+  const start = Date.now();
+  const tool = tier === 1 ? makeTier1Tool(criterion) : makeTier2Tool(criterion);
+  const userPrompt = getCriterionPrompt(criterion, numberedSource, designMode);
+  try {
+    const response = await agent.callTools(
+      model,
+      motherPrompt,
+      userPrompt,
+      [tool],
+      "required"
+    );
+    const call = response.toolCalls[0];
+    const durationMs = Date.now() - start;
+    if (!call) {
+      console.warn(`[eval] ${criterion}: no tool call returned`);
+      return {
+        criterion,
+        tier,
+        issues: [],
+        pass: true,
+        coverage: "skipped",
+        skipReason: "no tool call returned",
+        tokens: callTokens(response),
+        durationMs
+      };
+    }
+    const raw = call.input;
+    const issues = [];
+    let pass;
+    if (tier === 1) {
+      pass = raw.pass === true;
+      const rawIssues = coerceStringArray(raw.issues);
+      for (const desc of rawIssues) {
+        issues.push({
+          tier: 1,
+          result: "fail",
+          category: criterion,
+          severity: "critical",
+          description: desc,
+          fix: desc
+          // The issue description often includes the fix for tier 1
+        });
+      }
+      if (!pass && issues.length === 0) {
+        issues.push({
+          tier: 1,
+          result: "fail",
+          category: criterion,
+          severity: "critical",
+          description: `${criterion} check failed`,
+          fix: `Fix ${criterion} issues`
+        });
+      }
+    } else {
+      const result = raw.result ?? "pass";
+      pass = result === "pass";
+      const rawIssues = coerceStringArray(raw.issues);
+      const outcome = result === "fail" ? "fail" : "warn";
+      for (const desc of rawIssues) {
+        issues.push({
+          tier: 2,
+          result: outcome,
+          category: criterion,
+          severity: result === "fail" ? "critical" : "major",
+          description: desc,
+          fix: desc
+        });
+      }
+    }
+    return {
+      criterion,
+      tier,
+      issues,
+      pass,
+      coverage: "ran",
+      tokens: callTokens(response),
+      durationMs
+    };
+  } catch (e) {
+    const durationMs = Date.now() - start;
+    const message = e instanceof Error ? e.message : String(e);
+    console.error(`[eval] ${criterion}: error \u2014 ${message}`);
+    return {
+      criterion,
+      tier,
+      issues: [],
+      pass: true,
+      coverage: "skipped",
+      skipReason: message,
+      tokens: { in: 0, out: 0 },
+      durationMs
+    };
+  }
+}
+async function preWarmEval(context, _config) {
+  const motherPrompt = buildMotherPrompt({
+    originalPrompt: context.originalPrompt,
+    contract: context.contract,
+    designSystemSummary: context.designContext,
+    designMode: context.designMode,
+    profile: context.profile
+  });
+  return { motherPrompt, dynamicCriteria: [] };
+}
+var TIER_1_CATEGORIES = /* @__PURE__ */ new Set(["functionality", "crash"]);
+var TIER_2_CATEGORIES = /* @__PURE__ */ new Set([
+  "interactivity",
+  "accessibility",
+  "layout",
+  "loading",
+  "visual"
+]);
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  ...TIER_1_CATEGORIES,
+  ...TIER_2_CATEGORIES
+]);
+function parseEvalResponse(raw) {
+  const rawIssues = raw.issues ?? [];
+  const rawPass = raw.pass ?? [];
+  const issues = rawIssues.filter((i) => {
+    const cat = i.category;
+    return VALID_CATEGORIES.has(cat);
+  }).map((i) => {
+    const category = i.category;
+    const isTier1 = TIER_1_CATEGORIES.has(category);
+    const tier = isTier1 ? 1 : 2;
+    const result = isTier1 ? "fail" : i.result === "fail" ? "fail" : "warn";
+    return {
+      tier,
+      result,
+      category,
+      severity: i.severity || (isTier1 ? "critical" : "major"),
+      description: i.description || "",
+      fix: i.fix || ""
+    };
+  });
+  return {
+    issues,
+    pass: rawPass
+  };
+}
+async function runLLMEvaluation(context, config, preWarmedContext) {
+  const providerName = config.provider;
+  const model = config.model || getDefaultEvalModel(providerName);
+  const routerProvider = providerName === "claude" ? "anthropic" : providerName;
+  const designMode = context.designMode ?? DEFAULT_DESIGN_MODE;
+  const motherPrompt = preWarmedContext?.motherPrompt ?? buildMotherPrompt({
+    originalPrompt: context.originalPrompt,
+    contract: context.contract,
+    designSystemSummary: context.designContext,
+    designMode,
+    profile: context.profile
+  });
+  const numberedSource = context.sourceCode.split("\n").map((line, i) => `${String(i + 1).padStart(4)} | ${line}`).join("\n");
+  const agent = createAgent({
+    provider: routerProvider,
+    model,
+    routeOverride: config.routeOverride,
+    onRetry: config.onRetry
+  });
+  const evalStart = Date.now();
+  const totalCriteriaCount = TIER_1_CRITERIA.length + TIER_2_CRITERIA.length;
+  const results = await Promise.all([
+    ...TIER_1_CRITERIA.map((c) => evalCriterion(c, 1, motherPrompt, numberedSource, agent, model, designMode)),
+    ...TIER_2_CRITERIA.map((c) => evalCriterion(c, 2, motherPrompt, numberedSource, agent, model, designMode))
+  ]);
+  const allIssues = [];
+  const passCategories = [];
+  let totalIn = 0;
+  let totalOut = 0;
+  let cacheRead;
+  let cacheCreation;
+  for (const r of results) {
+    allIssues.push(...r.issues);
+    if (r.pass) {
+      passCategories.push(r.criterion);
+    }
+    totalIn += r.tokens.in;
+    totalOut += r.tokens.out;
+    if (r.tokens.cacheRead !== void 0) cacheRead = (cacheRead ?? 0) + r.tokens.cacheRead;
+    if (r.tokens.cacheCreation !== void 0) cacheCreation = (cacheCreation ?? 0) + r.tokens.cacheCreation;
+  }
+  const wallMs = Date.now() - evalStart;
+  const criteriaCoverage = results.map((r) => ({
+    criterion: r.criterion,
+    tier: r.tier,
+    status: r.coverage,
+    ...r.skipReason !== void 0 ? { reason: r.skipReason } : {}
+  }));
+  const skippedCount = criteriaCoverage.filter((c) => c.status === "skipped").length;
+  for (const r of results) {
+    const issueCount = r.issues.length;
+    const status = r.coverage === "skipped" ? "SKIPPED" : r.pass ? "PASS" : r.tier === 1 ? "FAIL" : r.issues.some((i) => i.result === "fail") ? "FAIL" : "WARN";
+    const issueLabel = issueCount > 0 ? ` (${issueCount} issue${issueCount > 1 ? "s" : ""})` : "";
+    console.log(`[eval] ${r.criterion}: ${status}${issueLabel} ${(r.durationMs / 1e3).toFixed(1)}s`);
+  }
+  console.log(
+    `[eval] total: ${(wallMs / 1e3).toFixed(1)}s wall (${totalCriteriaCount} parallel) | in=${totalIn} out=${totalOut} cacheRead=${cacheRead ?? "unreported"} cacheWrite=${cacheCreation ?? "unreported"} | issues=${allIssues.length} pass=${passCategories.length}` + (skippedCount > 0 ? ` skipped=${skippedCount}` : "")
+  );
+  return {
+    issues: allIssues,
+    pass: passCategories,
+    criteriaCoverage,
+    inputTokens: totalIn,
+    outputTokens: totalOut,
+    ...cacheRead !== void 0 ? { cacheReadTokens: cacheRead } : {},
+    ...cacheCreation !== void 0 ? { cacheCreationTokens: cacheCreation } : {}
+  };
+}
+
+export { buildMotherPrompt, parseEvalResponse, preWarmEval, runLLMEvaluation };
+//# sourceMappingURL=llm-evaluator-PN3WFCS4.js.map
+//# sourceMappingURL=llm-evaluator-PN3WFCS4.js.map