@ggui-ai/ui-gen 0.28.0 → 0.29.0

package/dist/chunk-GYINWMPR.js

@@ -0,0 +1,2052 @@
+import { CANVAS_VIEWPORTS } from './chunk-3T2HMTON.js';
+import { LUCIDE_ICON_NAMES, maxWidth } from '@ggui-ai/design';
+import { listContractGadgets, HOOK_NAME_RE, STDLIB_GADGETS_PACKAGE } from '@ggui-ai/protocol';
+
+var ID_FIELD_CANDIDATES = ["id", "uuid", "symbol", "key", "slug", "code"];
+function getItemsProperties(p) {
+  return p.items?.properties ?? p.schema?.items?.properties;
+}
+function inferIdField(itemProps) {
+  if (!itemProps) return "id";
+  for (const cand of ID_FIELD_CANDIDATES) {
+    if (cand in itemProps) return cand;
+  }
+  for (const [k, v] of Object.entries(itemProps)) {
+    const vv = v;
+    if (vv?.type === "string" || vv?.schema?.type === "string") return k;
+  }
+  return "id";
+}
+function getRequiredPropNames(contract) {
+  const propsField = contract?.propsSpec;
+  const properties = propsField?.properties ?? {};
+  return Object.entries(properties).filter(([, p]) => p && typeof p === "object" && p.required === true).map(([name]) => name);
+}
+function getActionNames(contract) {
+  return Object.keys(contract?.actionSpec ?? {});
+}
+function getStreamEventNames(contract) {
+  return Object.keys(contract?.streamSpec ?? {});
+}
+function getGadgetNames(contract) {
+  if (!contract) return [];
+  return listContractGadgets(contract).filter((use) => HOOK_NAME_RE.test(use.name)).map(
+    (use) => use.name.length > 3 ? use.name.charAt(3).toLowerCase() + use.name.slice(4) : use.name
+  );
+}
+function getStdlibGadgetNames(contract) {
+  if (!contract) return [];
+  return listContractGadgets(contract).filter(
+    (use) => use.package === STDLIB_GADGETS_PACKAGE && HOOK_NAME_RE.test(use.name)
+  ).map(
+    (use) => use.name.length > 3 ? use.name.charAt(3).toLowerCase() + use.name.slice(4) : use.name
+  );
+}
+function getEntityCollections(contract) {
+  const propsField = contract?.propsSpec;
+  const properties = propsField?.properties ?? {};
+  const entities = [];
+  for (const [name, p] of Object.entries(properties)) {
+    if (!p || typeof p !== "object") continue;
+    const pp = p;
+    const type = pp.type ?? pp.schema?.type;
+    const items = pp.items ?? pp.schema?.items;
+    if (type === "array" && items?.type === "object") {
+      entities.push({ name, idField: inferIdField(getItemsProperties(pp)) });
+    }
+  }
+  return entities;
+}
+function singularize(name) {
+  if (name.endsWith("ies")) return name.slice(0, -3) + "y";
+  if (name.endsWith("ses")) return name.slice(0, -2);
+  if (name.endsWith("s") && !name.endsWith("ss")) return name.slice(0, -1);
+  return name;
+}
+function getMutatedEntityCollections(contract, allEntities) {
+  if (!contract) return allEntities;
+  const actionSpec = contract.actionSpec ?? {};
+  const streamSpec = contract.streamSpec ?? {};
+  const hasStreams = Object.keys(streamSpec).length > 0;
+  const referencedIdKeys = /* @__PURE__ */ new Set();
+  for (const action of Object.values(actionSpec)) {
+    const ex = action.example;
+    if (!ex || typeof ex !== "object" || Array.isArray(ex)) continue;
+    for (const key of Object.keys(ex)) {
+      if (key === "id" || key === "key" || key === "index") {
+        referencedIdKeys.add("id");
+        referencedIdKeys.add("key");
+        referencedIdKeys.add("index");
+      } else if (/Id$/.test(key)) {
+        referencedIdKeys.add(key.slice(0, -2).toLowerCase());
+      }
+    }
+  }
+  const mutated = allEntities.filter(
+    (e) => referencedIdKeys.has(singularize(e.name).toLowerCase())
+  );
+  if (mutated.length === 0 && hasStreams && allEntities.length > 0) {
+    return [allEntities[0]];
+  }
+  return mutated.length > 0 ? mutated : allEntities;
+}
+function countScalarKeys(example) {
+  if (!example || typeof example !== "object" || Array.isArray(example)) return [];
+  const keys = [];
+  for (const [k, v] of Object.entries(example)) {
+    const t = typeof v;
+    if (t === "string" || t === "number" || t === "boolean") keys.push(k);
+  }
+  return keys;
+}
+function getSubmitActions(contract) {
+  const actionSpec = contract?.actionSpec ?? {};
+  const result = [];
+  for (const [name, action] of Object.entries(actionSpec)) {
+    const ex = action.example;
+    const scalarKeys = countScalarKeys(ex);
+    if (scalarKeys.length < 3) continue;
+    const allKeys = ex && typeof ex === "object" && !Array.isArray(ex) ? Object.keys(ex) : scalarKeys;
+    result.push({ name, payloadKeys: allKeys });
+  }
+  return result;
+}
+function getArrStrProps(contract) {
+  const propsField = contract?.propsSpec;
+  const properties = propsField?.properties ?? {};
+  const names = [];
+  for (const [name, p] of Object.entries(properties)) {
+    if (!p || typeof p !== "object") continue;
+    const pp = p;
+    const type = pp.type ?? pp.schema?.type;
+    const items = pp.items ?? pp.schema?.items;
+    if (type === "array" && items?.type === "string") names.push(name);
+  }
+  return names;
+}
+function getInitialValuePropNames(contract) {
+  const propsField = contract?.propsSpec;
+  const properties = propsField?.properties ?? {};
+  const names = [];
+  for (const [name, p] of Object.entries(properties)) {
+    if (!p || typeof p !== "object") continue;
+    const pp = p;
+    const type = pp.type ?? pp.schema?.type;
+    if (type === "object" && /^initial/i.test(name)) names.push(name);
+  }
+  return names;
+}
+function objectLiteralKeysAt(src, open) {
+  if (src[open] !== "{") return void 0;
+  const keys = [];
+  let depth = 0;
+  let expectKey = true;
+  for (let i = open; i < src.length; i++) {
+    const c = src[i];
+    if (c === '"' || c === "'" || c === "`") {
+      let j = i + 1;
+      while (j < src.length && src[j] !== c) j += src[j] === "\\" ? 2 : 1;
+      if (depth === 1 && expectKey && /^\s*:/.test(src.slice(j + 1))) keys.push(src.slice(i + 1, j));
+      i = j;
+      expectKey = false;
+      continue;
+    }
+    if (c === "{" || c === "[" || c === "(") {
+      depth++;
+      if (depth === 1) expectKey = true;
+      continue;
+    }
+    if (c === "}" || c === "]" || c === ")") {
+      depth--;
+      if (depth === 0) return keys;
+      continue;
+    }
+    if (depth !== 1) continue;
+    if (c === ",") {
+      expectKey = true;
+      continue;
+    }
+    if (expectKey && /[A-Za-z_$]/.test(c ?? "")) {
+      const m = /^([A-Za-z_$][\w$]*)\s*(:|,|\})/.exec(src.slice(i));
+      if (m !== null && m[1] !== void 0) keys.push(m[1]);
+      expectKey = false;
+    }
+  }
+  return keys;
+}
+function callArgsAt(src, open) {
+  const args = [];
+  let depth = 0;
+  let start = open + 1;
+  for (let i = open; i < src.length; i++) {
+    const c = src[i];
+    if (c === '"' || c === "'" || c === "`") {
+      let j = i + 1;
+      while (j < src.length && src[j] !== c) j += src[j] === "\\" ? 2 : 1;
+      i = j;
+      continue;
+    }
+    if (c === "(" || c === "{" || c === "[") depth++;
+    else if (c === ")" || c === "}" || c === "]") {
+      depth--;
+      if (depth === 0) {
+        args.push(src.slice(start, i));
+        return args;
+      }
+    } else if (c === "," && depth === 1) {
+      args.push(src.slice(start, i));
+      start = i + 1;
+    }
+  }
+  return args;
+}
+function initialStateKeys(src, argStart, argText) {
+  const lead = argText.length - argText.trimStart().length;
+  let at = argStart + lead;
+  let text = argText.trim();
+  const lazy = /^\(\s*\)\s*=>\s*\(?\s*/.exec(text);
+  if (lazy !== null) {
+    at += lazy[0].length;
+    text = text.slice(lazy[0].length);
+  }
+  if (text.startsWith("{")) return objectLiteralKeysAt(src, at) ?? [];
+  const ident = /^([A-Za-z_$][\w$]*)\s*\)?\s*$/.exec(text);
+  if (ident === null || ident[1] === void 0) return [];
+  const decls = [...src.matchAll(new RegExp(`(?:const|let|var)\\s+${ident[1]}\\s*(?::[^=]{1,200})?=\\s*`, "g"))];
+  const decl = decls.length === 1 ? decls[0] : void 0;
+  if (decl === void 0) return [];
+  return objectLiteralKeysAt(src, (decl.index ?? 0) + decl[0].length) ?? [];
+}
+function collectStateKeys(src) {
+  const keys = /* @__PURE__ */ new Set();
+  const varRe = /const\s*\[\s*(\w+)\s*,\s*(\w+)\s*\]\s*=\s*useState/g;
+  for (const m of src.matchAll(varRe)) keys.add(m[1]);
+  const contextRe = /const\s*\[\s*(\w+)\s*,\s*\w+\s*\]\s*=\s*useGguiContext\s*(?:<[^>]*>)?\s*\(\s*['"`](\w+)['"`]/g;
+  for (const m of src.matchAll(contextRe)) {
+    keys.add(m[1]);
+    keys.add(m[2]);
+  }
+  const objRe = /useState(?:<[^>]*>)?\s*\(\s*\{([\s\S]*?)\}\s*\)/g;
+  for (const m of src.matchAll(objRe)) {
+    const keyRe = /(?:^|,)\s*(\w+)\s*:/g;
+    for (const km of m[1].matchAll(keyRe)) keys.add(km[1]);
+  }
+  const defaultObjRe = /useState(?:<[^>]*>)?\s*\([^)]*\|\|\s*\{([^}]*)\}/g;
+  for (const m of src.matchAll(defaultObjRe)) {
+    const keyRe = /(?:^|,)\s*(\w+)\s*:/g;
+    for (const km of m[1].matchAll(keyRe)) keys.add(km[1]);
+  }
+  for (const m of src.matchAll(/\b(useState|useReducer)\s*(?:<[^>]*>)?\s*\(/g)) {
+    const open = (m.index ?? 0) + m[0].length - 1;
+    const args = callArgsAt(src, open);
+    const which = m[1] === "useReducer" ? 1 : 0;
+    const arg = args[which];
+    if (arg === void 0) continue;
+    let argStart = open + 1;
+    for (let k = 0; k < which; k++) argStart += (args[k]?.length ?? 0) + 1;
+    for (const key of initialStateKeys(src, argStart, arg)) keys.add(key);
+  }
+  return keys;
+}
+function seedsFromProp(src, name) {
+  const propRef = `props\\??\\.${name}\\b`;
+  const inits = useStateInitializers(src);
+  const anyInitReads = (rx) => inits.some((t) => rx.test(t));
+  if (anyInitReads(new RegExp(`\\b${propRef}`))) return true;
+  const locals = /* @__PURE__ */ new Set();
+  for (const m of src.matchAll(new RegExp(`(?:const|let|var)\\s+(\\w+)\\s*(?::[^=]{1,80})?=\\s*[^;]{0,300}?\\b${propRef}`, "g"))) {
+    const id = m[1];
+    if (id !== void 0) locals.add(id);
+  }
+  for (const m of src.matchAll(new RegExp(`(?:const|let|var)\\s*\\{([^}]{1,400})\\}\\s*=\\s*[^;]{0,300}?\\b${propRef}`, "g"))) {
+    for (const part of (m[1] ?? "").split(",")) {
+      const id = part.split(":").pop()?.split("=")[0]?.trim();
+      if (id !== void 0 && /^\w+$/.test(id)) locals.add(id);
+    }
+  }
+  const fromProps = /(?:const|let|var)\s*\{([^}]{1,400})\}\s*(?::[^=]{1,200})?=\s*props\b(?!\s*\??\.)|export\s+default\s+function\s*\w*\s*\(\s*\{([^}]{1,400})\}/g;
+  for (const m of src.matchAll(fromProps)) {
+    for (const part of (m[1] ?? m[2] ?? "").split(",")) {
+      const [key, alias] = part.split(":");
+      if (key?.split("=")[0]?.trim() !== name) continue;
+      const id = (alias ?? key).split("=")[0]?.trim();
+      if (id !== void 0 && /^\w+$/.test(id)) locals.add(id);
+    }
+  }
+  for (const id of locals) if (anyInitReads(new RegExp(`\\b${id}\\b`))) return true;
+  return seedsContextSlotFromProp(src, [new RegExp(`\\b${propRef}`), ...[...locals].map((id) => new RegExp(`\\b${id}\\b`))]);
+}
+function seedsContextSlotFromProp(src, readsProp) {
+  const reads = (text) => readsProp.some((rx) => rx.test(text));
+  const values = [];
+  const setters = [];
+  for (const m of src.matchAll(/(?:const|let|var)\s*\[\s*(\w+)\s*,\s*(\w+)\s*\]\s*=\s*useGguiContext\b/g)) {
+    if (m[1] !== void 0) values.push(m[1]);
+    if (m[2] !== void 0) setters.push(m[2]);
+  }
+  if (values.length === 0) return false;
+  for (const v of values) {
+    for (const m of src.matchAll(new RegExp(`(?<![.\\w$])${v}\\s*\\?\\?\\s*([^;\\n]{1,200})`, "g"))) {
+      if (reads(m[1] ?? "")) return true;
+    }
+  }
+  for (const body of callArguments(src, /\buse(?:Layout)?Effect\b/g)) {
+    for (const setter of setters) {
+      for (const arg of callArguments(body, new RegExp(`\\b${setter}\\b`, "g"))) if (reads(arg)) return true;
+    }
+  }
+  return false;
+}
+function useStateInitializers(src) {
+  return callArguments(src, /\buseState\b/g);
+}
+function callArguments(src, callee) {
+  const out = [];
+  for (const m of src.matchAll(callee)) {
+    let i = (m.index ?? 0) + m[0].length;
+    while (/\s/.test(src[i] ?? "")) i++;
+    if (src[i] === "<") {
+      let depth2 = 0;
+      for (; i < src.length; i++) {
+        if (src[i] === "<") depth2++;
+        else if (src[i] === ">" && src[i - 1] !== "=" && --depth2 === 0) break;
+      }
+      i++;
+      while (/\s/.test(src[i] ?? "")) i++;
+    }
+    if (src[i] !== "(") continue;
+    const start = i + 1;
+    let depth = 0;
+    let quote = "";
+    for (; i < src.length; i++) {
+      const ch = src[i];
+      if (quote !== "") {
+        if (ch === "\\") i++;
+        else if (ch === quote) quote = "";
+      } else if (ch === '"' || ch === "'" || ch === "`") quote = ch;
+      else if (ch === "(") depth++;
+      else if (ch === ")" && --depth === 0) break;
+    }
+    out.push(src.slice(start, i));
+  }
+  return out;
+}
+function mkIssue(subcategory, description, fix, result = "fail") {
+  return { tier: 0, result, category: "mode", priority: "P0", subcategory, description, fix };
+}
+function cap(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function axisCheckTraceEnabled() {
+  return process.env["GGUI_AXIS_CHECK_TRACE"] === "1";
+}
+
+// src/evaluation/axis-checks/checks/universal.ts
+var ALL_RENDER_VALUES = [
+  "static",
+  "list",
+  "grid",
+  "spatial",
+  "timeline",
+  "chart",
+  "master-detail"
+];
+function runPropCoverage(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const requiredProps = getRequiredPropNames(input.contract);
+  const issues = [];
+  for (const name of requiredProps) {
+    const dotAccess = new RegExp(`\\bprops\\.${name}\\b`);
+    const bracketAccess = new RegExp(`\\bprops\\[['"\`]${name}['"\`]\\]`);
+    const destructured = new RegExp(
+      `props[^;]{0,200}\\{[^}]*\\b${name}\\b[^}]*\\}|\\{[^}]*\\b${name}\\b[^}]*\\}[^;]{0,10}=\\s*props`
+    );
+    if (dotAccess.test(src) || bracketAccess.test(src) || destructured.test(src))
+      continue;
+    issues.push(
+      mkIssue(
+        "universal.prop_coverage",
+        `Required prop "${name}" is not referenced anywhere in the component.`,
+        `Render props.${name} \u2014 the data contract marks it required.`
+      )
+    );
+  }
+  return issues;
+}
+function runNoPropMirror(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const issues = [];
+  const re = /const\s*\[\s*(\w+)\s*,\s*(\w+)\s*\]\s*=\s*useState(?:<[^>]*>)?\s*\(\s*props\??\.(\w+)/g;
+  for (const m of src.matchAll(re)) {
+    const [full, stateVar, setter, propName] = m;
+    const idx = m.index ?? 0;
+    const after = src.slice(idx + full.length);
+    if (new RegExp(`\\b${setter}\\s*\\(`).test(after)) continue;
+    issues.push(
+      mkIssue(
+        "universal.no_prop_mirror",
+        `useState(props.${propName}) for "${stateVar}" has no "${setter}" call \u2014 this mirrors a prop without mutation.`,
+        `Read props.${propName} directly in the render; remove the useState for ${stateVar}.`,
+        "warn"
+      )
+    );
+  }
+  return issues;
+}
+function runNoPhantomUseState(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const issues = [];
+  const re = /const\s*\[\s*(\w+)\s*,\s*(\w+)\s*\]\s*=\s*useState/g;
+  for (const m of src.matchAll(re)) {
+    const [full, stateVar, setter] = m;
+    const idx = m.index ?? 0;
+    const after = src.slice(idx + full.length);
+    const stateUsed = new RegExp(`\\b${stateVar}\\b`).test(after);
+    const setterUsed = new RegExp(`\\b${setter}\\b`).test(after);
+    if (stateUsed || setterUsed) continue;
+    issues.push(
+      mkIssue(
+        "universal.no_phantom_useState",
+        `useState for "${stateVar}" is declared but neither "${stateVar}" nor "${setter}" is referenced.`,
+        `Remove the useState for ${stateVar} \u2014 it is dead state.`,
+        "warn"
+      )
+    );
+  }
+  return issues;
+}
+function runPropSeedNoResync(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const issues = [];
+  const re = /const\s*\[\s*(\w+)\s*,\s*(\w+)\s*\]\s*=\s*useState(?:<[^>]*>)?\s*\(\s*props\??\.(\w+)/g;
+  for (const m of src.matchAll(re)) {
+    const [full, stateVar, setter, propName] = m;
+    const idx = m.index ?? 0;
+    const after = src.slice(idx + full.length);
+    if (!new RegExp(`\\b${setter}\\s*\\(`).test(after)) continue;
+    const resync = new RegExp(
+      `\\[[^\\[\\]]*props\\??\\.${propName}\\b[^\\[\\]]*\\]`
+    );
+    if (resync.test(src)) continue;
+    issues.push(
+      mkIssue(
+        "universal.prop_seed_no_resync",
+        `useState(props.${propName}) seeds "${stateVar}" and mutates it, but no effect depends on [props.${propName}] \u2014 a ggui_amend repaint pushes new props that never reach this display (#480).`,
+        `Add \`useEffect(() => ${setter}(props.${propName}), [props.${propName}]);\` so agent repaints re-seed the state, or derive the display directly from props.${propName}.`,
+        "warn"
+      )
+    );
+  }
+  return issues;
+}
+var KNOWN_ICON_KEYS = new Set(
+  LUCIDE_ICON_NAMES.map((n) => n.replace(/[-_]/g, "").toLowerCase())
+);
+function isKnownIconName(name) {
+  return KNOWN_ICON_KEYS.has(name.replace(/[-_]/g, "").toLowerCase());
+}
+var ICON_NAME_LITERAL_RX = /<Icon\b[^>]*?\bname\s*=\s*(?:"([^"]*)"|'([^']*)'|\{\s*"([^"]*)"\s*\}|\{\s*'([^']*)'\s*\})/g;
+function findUnknownIconNames(sourceCode) {
+  const unknown = /* @__PURE__ */ new Set();
+  for (const m of sourceCode.matchAll(ICON_NAME_LITERAL_RX)) {
+    const name = m[1] ?? m[2] ?? m[3] ?? m[4] ?? "";
+    if (name.length === 0) continue;
+    if (/[^\x20-\x7e]/.test(name)) continue;
+    if (!isKnownIconName(name)) unknown.add(name);
+  }
+  return [...unknown];
+}
+function runIconNameKnown(input) {
+  if (input.compiledCode === null) return [];
+  const unknown = findUnknownIconNames(input.sourceCode);
+  if (unknown.length === 0) return [];
+  const list = unknown.map((n) => `"${n}"`).join(", ");
+  return [
+    mkIssue(
+      "universal.icon_name_known",
+      `<Icon name=\u2026> uses ${unknown.length} name(s) outside the design system's Lucide subset: ${list} \u2014 an unknown name renders an empty box.`,
+      "Call get_available_icons and pick a listed name (kebab-case), or use an emoji directly."
+    )
+  ];
+}
+var LADDER_STOP_AS_TEXT_RX = /(?<![\w-])color\s*(?:=\s*\{?\s*|:\s*)["'`]?\s*var\(--ggui-color-primary-(\d{2,3})\s*[,)]/g;
+var TEXT_INK_STOP_MIN = 300;
+var TEXT_INK_STOP_MAX = 600;
+function findLadderStopsAsText(sourceCode) {
+  const found = /* @__PURE__ */ new Set();
+  for (const m of sourceCode.matchAll(LADDER_STOP_AS_TEXT_RX)) {
+    const digits = m[1] ?? "";
+    const stop = Number(digits);
+    if (stop >= TEXT_INK_STOP_MIN && stop <= TEXT_INK_STOP_MAX) found.add(`primary-${digits}`);
+  }
+  return [...found];
+}
+function runAccentTextInk(input) {
+  if (input.compiledCode === null) return [];
+  const stops = findLadderStopsAsText(input.sourceCode);
+  if (stops.length === 0) return [];
+  const list = stops.map((s) => `\`${s}\``).join(", ");
+  return [
+    mkIssue(
+      "universal.accent_text_ink",
+      `Text is painted with a brand-ladder fill stop as its color (${list}) \u2014 on a low-saturation brand these stops are mid-grey on the surface and the text fails readability.`,
+      'Accent text (eyebrows, taglines, links, labels, inline arrows) takes var(--ggui-color-link) or <Text tone="emphasized">; body text takes var(--ggui-color-onContainer); keep primary-* stops on fills and borders.'
+    )
+  ];
+}
+var SCOPED_SURFACE_TAG_RX = /<(Card|Box)\b([^<>]*?)surface\s*=\s*["'](inverted|hero)["']([^<>]*?)>/g;
+var STYLE_BACKGROUND_RX = /\bstyle\s*=\s*\{\{[^}]*\b(background|backgroundColor|backgroundImage)\s*:/;
+function findScopedSurfaceBackgrounds(sourceCode) {
+  const hits = [];
+  for (const m of sourceCode.matchAll(SCOPED_SURFACE_TAG_RX)) {
+    const attrs = `${m[2] ?? ""} ${m[4] ?? ""}`;
+    if (STYLE_BACKGROUND_RX.test(attrs)) hits.push([m[1] ?? "", m[3] ?? ""]);
+  }
+  return hits;
+}
+function runScopedSurfaceOwnsGround(input) {
+  if (input.compiledCode === null) return [];
+  if (input.designMode === "free") return [];
+  const hits = findScopedSurfaceBackgrounds(input.sourceCode);
+  if (hits.length === 0) return [];
+  const [tag, surface] = hits[0];
+  return [
+    mkIssue(
+      "universal.scoped_surface_owns_ground",
+      `<${tag} surface="${surface}"> sets its own background in style \u2014 a scoped surface owns its ground; repainting it puts the scope's swapped inks over the wrong ground (ink on ink).`,
+      `Remove the background from that ${tag}'s style \u2014 surface="${surface}" paints the ground; pick another surface if a different ground is wanted.`
+    )
+  ];
+}
+var CAPS_TEXT_RX = /<Text\b(?=[^>]*\bcaps\b)[^>]*>([\s\S]*?)<\/Text>/g;
+function findInventedCapsLabels(sourceCode) {
+  const out = [];
+  for (const m of sourceCode.matchAll(CAPS_TEXT_RX)) {
+    const inner = (m[1] ?? "").trim();
+    if (inner.length === 0) continue;
+    if (inner.includes("{")) continue;
+    out.push(inner.replace(/\s+/g, " ").slice(0, 60));
+  }
+  return out;
+}
+function runCapsLabelInvented(input) {
+  if (input.compiledCode === null) return [];
+  const invented = findInventedCapsLabels(input.sourceCode);
+  if (invented.length === 0) return [];
+  const list = invented.map((t) => `"${t}"`).join(", ");
+  return [
+    mkIssue(
+      "universal.caps_label_invented",
+      `${invented.length} caps label(s) carry invented copy the props do not supply: ${list} \u2014 an eyebrow, kicker or overline the agent cannot change is chatter on every render.`,
+      "Remove the label, or bind its text to a prop (`<Text caps>{props.section}</Text>`); copy comes from the contract, never from the component."
+    )
+  ];
+}
+var VIEWPORT_UNIT = String.raw`(?:calc\(\s*)?100(?:vh|dvh|svh|lvh)\b(?:[^)"'\x60;\n]*\))?`;
+var VIEWPORT_STYLE_OBJECT_RX = new RegExp(
+  String.raw`\b(?:minHeight|height|minBlockSize|blockSize)\s*:\s*["'\x60]\s*${VIEWPORT_UNIT}["'\x60]?`,
+  "g"
+);
+var VIEWPORT_CSS_RX = new RegExp(
+  String.raw`(?<![\w-])(?:min-)?(?:height|block-size)\s*:\s*${VIEWPORT_UNIT}`,
+  "g"
+);
+var VIEWPORT_CLASS_RX = /(?<![\w-])(?:min-)?h-(?:screen|dvh|svh|lvh)\b/g;
+function findViewportSizing(sourceCode) {
+  const hits = [];
+  for (const rx of [VIEWPORT_STYLE_OBJECT_RX, VIEWPORT_CSS_RX, VIEWPORT_CLASS_RX]) {
+    for (const m of sourceCode.matchAll(rx)) {
+      hits.push({ at: m.index ?? 0, text: m[0].replace(/\s+/g, " ").trim().slice(0, 60) });
+    }
+  }
+  return hits.sort((a, b) => a.at - b.at).map((h) => h.text);
+}
+function runViewportSized(input) {
+  if (input.compiledCode === null) return [];
+  const sized = findViewportSizing(input.sourceCode);
+  if (sized.length === 0) return [];
+  const list = sized.map((t) => "`" + t + "`").join(", ");
+  return [
+    mkIssue(
+      "universal.viewport_sized",
+      `${sized.length} element(s) are sized to the viewport: ${list} \u2014 the frame owns the height; a content-sized frame is measured from the content, so a viewport-sized root never shrinks and grows the frame on every re-measure.`,
+      "Remove the viewport height \u2014 size to content, never to the viewport. Under fullscreen the frame stretches your root already (centre inside it with `display: flex; flex-direction: column; justify-content: center`); to fill a parent that has a height use `height: 100%` or `flex: 1`."
+    )
+  ];
+}
+var TERMINAL_WORDS = /* @__PURE__ */ new Set([
+  "submit",
+  "confirm",
+  "approve",
+  "schedule",
+  "reserve",
+  "book",
+  "pay",
+  "checkout",
+  "purchase",
+  "order"
+]);
+var TERMINAL_LABEL_RX = /\b(submit|confirm|approve|schedule|reserve|book|pay|checkout|purchase|place\s+order)\b/i;
+var GUARD_RX = /\b(disabled|aria-disabled)\s*=/;
+function nameWords(name) {
+  return name.split(/(?=[A-Z])|[_\-\s]+/).map((w) => w.toLowerCase()).filter((w) => w.length > 0);
+}
+function findUnguardedTerminalControls(sourceCode) {
+  if (GUARD_RX.test(sourceCode)) return [];
+  const names = /* @__PURE__ */ new Set();
+  for (const m of sourceCode.matchAll(/useAction(?:<[^>]*>)?\(\s*['"`]([^'"`]+)['"`]/g)) {
+    const name = m[1] ?? "";
+    if (nameWords(name).some((w) => TERMINAL_WORDS.has(w))) names.add(name);
+  }
+  for (const m of sourceCode.matchAll(/>([^<>{}]{1,60})<\/Button>/g)) {
+    const label = (m[1] ?? "").replace(/\s+/g, " ").trim();
+    if (label.length > 0 && TERMINAL_LABEL_RX.test(label)) names.add(label.slice(0, 40));
+  }
+  return [...names];
+}
+function runTerminalActionUnguarded(input) {
+  if (input.compiledCode === null) return [];
+  const found = findUnguardedTerminalControls(input.sourceCode);
+  if (found.length === 0) return [];
+  const list = found.map((t) => `"${t}"`).join(", ");
+  return [
+    mkIssue(
+      "universal.terminal_action_unguarded",
+      `${list} reads as an action the user means once, and nothing in this component disables the control after it fires \u2014 a double-click sends it twice.`,
+      'Hold the fired state (`const [submitted, setSubmitted] = useState(false)`), set it in the handler, and pass `disabled={submitted}` to that control with a word that says so ("Submitted"). If the action IS meant to repeat \u2014 sending a message, adding an item \u2014 leave it armed and ignore this.',
+      "warn"
+    )
+  ];
+}
+function rootOpeningTag(sourceCode) {
+  const start = sourceCode.indexOf("export default function");
+  const body = start >= 0 ? sourceCode.slice(start) : sourceCode;
+  const ret = /\breturn\s*\(?\s*</.exec(body);
+  if (ret === null) return null;
+  const at = ret.index + ret[0].length - 1;
+  const nameMatch = /^<([A-Za-z][\w.]*)/.exec(body.slice(at));
+  if (nameMatch === null) return null;
+  let j = at + nameMatch[0].length;
+  let depth = 0;
+  let quote = null;
+  for (; j < body.length; j++) {
+    const ch = body[j];
+    if (quote !== null) {
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") quote = ch;
+    else if (ch === "{") depth++;
+    else if (ch === "}") depth--;
+    else if (ch === ">" && depth === 0) break;
+  }
+  return { name: nameMatch[1], attrs: body.slice(at + nameMatch[0].length, j) };
+}
+var CONTAINER_PRESETS = maxWidth;
+var NOT_A_CAP = /* @__PURE__ */ new Set(["full", "none", "100%", "unset", "initial", "inherit"]);
+function capPx(value) {
+  const v = value.trim();
+  if (NOT_A_CAP.has(v)) return void 0;
+  const resolved = CONTAINER_PRESETS[v] ?? v;
+  if (NOT_A_CAP.has(resolved)) return void 0;
+  const px = /^(\d+(?:\.\d+)?)px$/.exec(resolved);
+  return px === null ? null : Number(px[1]);
+}
+function findRootWidthCap(sourceCode) {
+  const root = rootOpeningTag(sourceCode);
+  if (root === null) return null;
+  const { name, attrs } = root;
+  const prop = /\bmaxWidth\s*=\s*(?:"([^"]*)"|'([^']*)'|\{\s*(?:"([^"]*)"|'([^']*)'|(\d+(?:\.\d+)?))\s*\})/.exec(attrs);
+  if (prop !== null) {
+    const raw = prop[1] ?? prop[2] ?? prop[3] ?? prop[4] ?? `${prop[5]}px`;
+    const px = capPx(raw);
+    return px === void 0 ? null : { element: name, cap: `maxWidth="${raw}"`, px };
+  }
+  const style = /\bmaxWidth\s*:\s*(?:"([^"]*)"|'([^']*)'|`([^`]*)`|(\d+(?:\.\d+)?))/.exec(attrs);
+  if (style !== null) {
+    const raw = style[1] ?? style[2] ?? style[3] ?? `${style[4]}px`;
+    const px = capPx(raw);
+    return px === void 0 ? null : { element: name, cap: `maxWidth: '${raw}'`, px };
+  }
+  const cls = /(?<![\w-])max-w-([\w[\]%.-]+)/.exec(attrs);
+  if (cls !== null) {
+    if (cls[1] === "full" || cls[1] === "none") return null;
+    return { element: name, cap: `max-w-${cls[1]}`, px: null };
+  }
+  if (name === "Container") return { element: name, cap: "lg (Container default)", px: capPx("lg") ?? null };
+  return null;
+}
+var WIDE_CANVASES = /* @__PURE__ */ new Set(["md", "lg", "xl"]);
+function runRootWidthCap(input) {
+  if (input.compiledCode === null) return [];
+  if (input.canvas === void 0 || !WIDE_CANVASES.has(input.canvas)) return [];
+  const cap2 = findRootWidthCap(input.sourceCode);
+  if (cap2 === null) return [];
+  const width = CANVAS_VIEWPORTS[input.canvas].width;
+  if (cap2.px !== null && cap2.px >= width) return [];
+  const sized = cap2.px !== null ? `${cap2.px}px on a ${width}px canvas` : `on a ${width}px canvas`;
+  return [
+    mkIssue(
+      "universal.root_width_cap",
+      `The outermost element <${cap2.element}> carries a width cap (${cap2.cap}, ${sized}): on this canvas the card becomes a narrow strip with the frame's ground on either side. The frame owns the width; a cap belongs INSIDE the root, on the column that holds text.`,
+      'Let the root fill the frame \u2014 drop the cap on the element you return at the top (or `maxWidth="full"`) \u2014 and put the reading measure on an inner column: `<Box padding="lg"><Container maxWidth="sm">\u2026</Container></Box>`.',
+      "warn"
+    )
+  ];
+}
+var LABEL_SPECIAL_CHAR = /[^a-z0-9\s]/i;
+var normText = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
+var alnumText = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+function visibleText(sourceCode) {
+  const jsx = (sourceCode.match(/>([^<>]*)</g) ?? []).map((m2) => m2.slice(1, -1).replace(/\{[^}]*\}/g, " ")).join(" ");
+  let attrs = "";
+  const attrRx = /\b(?:aria-label|placeholder|title|alt)\s*=\s*(?:"([^"]*)"|'([^']*)')/gi;
+  let m;
+  while ((m = attrRx.exec(sourceCode)) !== null) attrs += " " + (m[1] ?? m[2] ?? "");
+  return jsx + " " + attrs;
+}
+function findDroppedActionLabels(sourceCode, contract) {
+  const actionSpec = contract?.actionSpec;
+  if (actionSpec === void 0) return [];
+  if (/\.label\b/.test(sourceCode)) return [];
+  const vis = visibleText(sourceCode);
+  const normVis = normText(vis);
+  const alnumVis = alnumText(vis);
+  const out = [];
+  for (const [name, entry] of Object.entries(actionSpec)) {
+    const label = entry.label;
+    if (typeof label !== "string" || label.length === 0 || label === name) continue;
+    if (!LABEL_SPECIAL_CHAR.test(label)) continue;
+    if (alnumText(label).length < 3) continue;
+    if (normVis.includes(normText(label))) continue;
+    if (alnumVis.includes(alnumText(label))) out.push({ name, label });
+  }
+  return out;
+}
+function runActionLabelDropped(input) {
+  if (input.compiledCode === null) return [];
+  return findDroppedActionLabels(input.sourceCode, input.contract).map(
+    ({ name, label }) => mkIssue(
+      "universal.action_label_dropped",
+      `The action "${name}" declares label "${label}", but the rendered control appears to drop its "${label.replace(/[a-z0-9\s]/gi, "").trim()}": the label's words are in the generated source, the full label is not \u2014 a transcription drop (ggui#1190).`,
+      `Render the label EXACTLY as the contract states it \u2014 button text should be the verbatim \`actionSpec.${name}.label\`, or render it from data (\`{x.label}\`), never a re-typed copy that drops "&", "/", "+", etc.`,
+      "warn"
+    )
+  );
+}
+var MIN_ECHO_CHARS = 12;
+function collectStrings(value, out) {
+  if (typeof value === "string") {
+    out.push(value);
+  } else if (Array.isArray(value)) {
+    for (const v of value) collectStrings(v, out);
+  } else if (value !== null && typeof value === "object") {
+    for (const v of Object.values(value)) collectStrings(v, out);
+  }
+}
+function fixtureOnlyStrings(input) {
+  if (input.fixtureProps === void 0) return [];
+  const values = [];
+  collectStrings(input.fixtureProps, values);
+  const stated = `${input.originalPrompt}
+${input.contract === void 0 ? "" : JSON.stringify(input.contract)}`;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const v of values) {
+    const t = v.trim();
+    if (t.length < MIN_ECHO_CHARS || !t.includes(" ") || seen.has(t)) continue;
+    seen.add(t);
+    if (stated.includes(t)) continue;
+    out.push(t);
+  }
+  return out;
+}
+function runFixtureDefaultEcho(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const issues = [];
+  for (const value of fixtureOnlyStrings(input)) {
+    if (!src.includes(value)) continue;
+    issues.push(
+      mkIssue(
+        "universal.fixture_default_echo",
+        `A literal in the source equals a fixture value the request never stated: "${value.length > 60 ? `${value.slice(0, 57)}\u2026` : value}". The fixture is judging data; a visitor sees this copy whenever the agent leaves the prop out.`,
+        "Take that copy from the prop it renders and drop the literal \u2014 no default, fallback or placeholder that repeats a fixture value. A default may only carry text the request itself states.",
+        "warn"
+      )
+    );
+  }
+  return issues;
+}
+var FORM_OPEN_RX = /<form\b[^<>]*\bonSubmit\s*=[^<>]*>/g;
+var CONTROL_TAG_RX = /<(?:Button|button|input)\b[^<>]*>/g;
+var SUBMIT_TYPE_RX = /\btype\s*=\s*(?:["']submit["']|\{\s*["']submit["']\s*\})/;
+function submitForms(sourceCode) {
+  const out = [];
+  for (const m of sourceCode.matchAll(FORM_OPEN_RX)) {
+    const start = m.index ?? 0;
+    const end = sourceCode.indexOf("</form>", start + m[0].length);
+    out.push(end === -1 ? sourceCode.slice(start) : sourceCode.slice(start, end + "</form>".length));
+  }
+  return out;
+}
+function runFormSubmitControl(input) {
+  if (input.compiledCode === null) return [];
+  const issues = [];
+  for (const form of submitForms(input.sourceCode)) {
+    const controls = [...form.matchAll(CONTROL_TAG_RX)].map((m) => m[0]);
+    if (controls.length === 0) continue;
+    if (controls.some((tag) => SUBMIT_TYPE_RX.test(tag))) continue;
+    const named = controls.find((tag) => /<Button\b/.test(tag)) ?? controls[0];
+    issues.push(
+      mkIssue(
+        "universal.form_submit_control",
+        `A <form onSubmit> renders ${controls.length} control(s) and none submits it: the design Button defaults to type="button", so clicking ${named.length > 60 ? `${named.slice(0, 57)}\u2026` : named} does nothing \u2014 only Enter in a field submits.`,
+        'Give the control that submits this form type="submit" \u2014 a Button inside a form defaults to type="button" and never submits on click; keep type="button" on the others.',
+        "fail"
+      )
+    );
+  }
+  return issues;
+}
+var UNIVERSAL_CHECKS = [
+  {
+    id: "universal.icon_name_known",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runIconNameKnown
+  },
+  {
+    id: "universal.caps_label_invented",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runCapsLabelInvented
+  },
+  {
+    id: "universal.viewport_sized",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runViewportSized
+  },
+  {
+    id: "universal.root_width_cap",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runRootWidthCap
+  },
+  {
+    id: "universal.action_label_dropped",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runActionLabelDropped
+  },
+  {
+    id: "universal.terminal_action_unguarded",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runTerminalActionUnguarded
+  },
+  {
+    id: "universal.form_submit_control",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runFormSubmitControl
+  },
+  {
+    id: "universal.fixture_default_echo",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runFixtureDefaultEcho
+  },
+  {
+    id: "universal.accent_text_ink",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runAccentTextInk
+  },
+  {
+    id: "universal.scoped_surface_owns_ground",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runScopedSurfaceOwnsGround
+  },
+  {
+    id: "universal.prop_coverage",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runPropCoverage
+  },
+  {
+    id: "universal.no_prop_mirror",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runNoPropMirror
+  },
+  {
+    id: "universal.no_phantom_useState",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runNoPhantomUseState
+  },
+  {
+    id: "universal.prop_seed_no_resync",
+    axis: "render",
+    values: ALL_RENDER_VALUES,
+    run: runPropSeedNoResync
+  }
+];
+
+// src/evaluation/axis-checks/checks/tint.ts
+var ALL_RENDER_VALUES2 = [
+  "static",
+  "list",
+  "grid",
+  "spatial",
+  "timeline",
+  "chart",
+  "master-detail"
+];
+function scanOpenTag(src, from, nameLength) {
+  let depth = 0;
+  let quote = "";
+  for (let i = from + 1 + nameLength; i < src.length; i++) {
+    const ch = src[i];
+    if (quote !== "") {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = "";
+    } else if (ch === '"' || ch === "'" || ch === "`") {
+      quote = ch;
+    } else if (ch === "{") {
+      depth++;
+    } else if (ch === "}") {
+      depth--;
+    } else if (ch === ">" && depth === 0) {
+      const attrs = src.slice(from + 1 + nameLength, i);
+      return { attrs, end: i + 1, selfClosing: attrs.trimEnd().endsWith("/") };
+    }
+  }
+  return null;
+}
+function readTintAttr(attrs) {
+  let depth = 0;
+  let quote = "";
+  for (let i = 0; i < attrs.length; i++) {
+    const ch = attrs[i];
+    if (quote !== "") {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = "";
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") quote = ch;
+    else if (ch === "{") depth++;
+    else if (ch === "}") depth--;
+    else if (depth === 0 && /\s/.test(attrs[i - 1] ?? " ")) {
+      const m = /^tint\s*=\s*/.exec(attrs.slice(i));
+      if (m === null) continue;
+      const v = i + m[0].length;
+      const open = attrs[v];
+      if (open === '"' || open === "'") {
+        const close = attrs.indexOf(open, v + 1);
+        return close < 0 ? null : attrs.slice(v, close + 1);
+      }
+      if (open !== "{") return null;
+      let d = 0;
+      for (let j = v; j < attrs.length; j++) {
+        if (attrs[j] === "{") d++;
+        else if (attrs[j] === "}" && --d === 0) return attrs.slice(v, j + 1);
+      }
+      return null;
+    }
+  }
+  return null;
+}
+function findTintedElements(sourceCode) {
+  const found = [];
+  for (const m of sourceCode.matchAll(/<(Box|Card)\b/g)) {
+    const tag = m[1] === "Card" ? "Card" : "Box";
+    const from = m.index ?? 0;
+    const open = scanOpenTag(sourceCode, from, tag.length);
+    if (open === null) continue;
+    const tint = readTintAttr(open.attrs);
+    if (tint === null) continue;
+    if (open.selfClosing) {
+      const close = sourceCode.indexOf("</", open.end);
+      found.push({ tag, tint, inner: "", next: sourceCode.slice(open.end, close < 0 ? sourceCode.length : close) });
+      continue;
+    }
+    const tagRx = new RegExp(`<(/?)${tag}\\b`, "g");
+    tagRx.lastIndex = open.end;
+    let depth = 1;
+    let end = sourceCode.length;
+    for (let t = tagRx.exec(sourceCode); t !== null; t = tagRx.exec(sourceCode)) {
+      if (t[1] === "/") {
+        if (--depth === 0) {
+          end = t.index;
+          break;
+        }
+        continue;
+      }
+      const nested = scanOpenTag(sourceCode, t.index, tag.length);
+      if (nested === null) break;
+      tagRx.lastIndex = nested.end;
+      if (!nested.selfClosing) depth++;
+    }
+    found.push({ tag, tint, inner: sourceCode.slice(open.end, end), next: "" });
+  }
+  return found;
+}
+var STATE_WORD_RX = /\b(status|state|isLive|live|draft|signal|error|success|warning|danger|isActive|active|selected|isSelected|online|offline|pending|loading|disabled)\b/i;
+function hasWords(inner) {
+  if (/<(Text|Heading|Label|Badge|Caption|Link)\b/.test(inner)) return true;
+  if (/\{[^{}]+\}/.test(inner.replace(/\b[a-zA-Z]+=\{[^{}]*\}/g, ""))) return true;
+  return />\s*[^<>{}\s][^<>{}]*</.test(`>${inner}<`);
+}
+function runTintStateBound(input) {
+  if (input.compiledCode === null) return [];
+  const bound = findTintedElements(input.sourceCode).filter((e) => e.tint.startsWith("{") && STATE_WORD_RX.test(e.tint));
+  if (bound.length === 0) return [];
+  return [
+    mkIssue(
+      "universal.tint_state_bound",
+      `\`tint\` reads as bound to a state (${bound.map((e) => `\`${e.tint}\``).join(", ")}) \u2014 tints are for data categories, never for state.`,
+      "A status takes live, draft or signal, not a tint. Keep `tint` for a data category (series, lane, kind, group), and show state with its own props.",
+      "warn"
+    )
+  ];
+}
+function runTintCategoryInWords(input) {
+  if (input.compiledCode === null) return [];
+  const tinted = findTintedElements(input.sourceCode);
+  if (tinted.length === 0) return [];
+  if (/\blegend\b/i.test(input.sourceCode)) return [];
+  if (tinted.every((e) => hasWords(e.inner) || hasWords(e.next))) return [];
+  return [
+    mkIssue(
+      "universal.tint_category_in_words",
+      "A tinted cell carries no words, and the card has no legend \u2014 colour is the only way to tell its category.",
+      "Give this cell a label, or add a legend to the card. The category is always also in words.",
+      "warn"
+    )
+  ];
+}
+var MUTED_TONE_RX = /\btone\s*=\s*["'](subtle|muted)["']/;
+function runTintMutedText(input) {
+  if (input.compiledCode === null) return [];
+  if (!findTintedElements(input.sourceCode).some((e) => MUTED_TONE_RX.test(e.inner))) return [];
+  return [
+    mkIssue(
+      "universal.tint_muted_text",
+      'Muted text (`tone="subtle"` / `tone="muted"`) sits on a tint \u2014 it can read under 4.5:1 there.',
+      "Text on a tint is the theme's ink only, one short line (a label, a symbol, a value). Put secondary or muted text beside the cell or in the legend.",
+      "warn"
+    )
+  ];
+}
+var TINT_CHECKS = [
+  { id: "universal.tint_state_bound", axis: "render", values: ALL_RENDER_VALUES2, run: runTintStateBound },
+  { id: "universal.tint_category_in_words", axis: "render", values: ALL_RENDER_VALUES2, run: runTintCategoryInWords },
+  { id: "universal.tint_muted_text", axis: "render", values: ALL_RENDER_VALUES2, run: runTintMutedText }
+];
+
+// src/evaluation/axis-checks/checks/state-merge.ts
+function runStateSeededFromProps(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const all = getEntityCollections(input.contract);
+  const entities = getMutatedEntityCollections(input.contract, all);
+  const issues = [];
+  for (const e of entities) {
+    if (seedsFromProp(src, e.name)) continue;
+    issues.push(
+      mkIssue(
+        "state.merge.seeded_from_props",
+        `Entity collection "${e.name}" is not seeded from props \u2014 no useState initializer reads props.${e.name}.`,
+        `Add \`const [${e.name}, set${cap(e.name)}] = useState(props.${e.name});\` paired with \`useEffect(() => set${cap(e.name)}(props.${e.name}), [props.${e.name}]);\` so stream/action updates merge into live state AND agent repaints (ggui_amend) re-seed it (#480).`
+      )
+    );
+  }
+  return issues;
+}
+function runNoHardcodedEntities(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const all = getEntityCollections(input.contract);
+  const entities = getMutatedEntityCollections(input.contract, all);
+  if (entities.length === 0) return [];
+  const uncommented = src.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+  const issues = [];
+  const idFields = [...new Set(entities.map((e) => e.idField))];
+  for (const idField of idFields) {
+    const re = new RegExp(
+      `\\[\\s*\\{[^}]*\\b${idField}\\s*:[^}]*\\}\\s*,\\s*\\{[^}]*\\b${idField}\\s*:`,
+      "g"
+    );
+    if (!re.test(uncommented)) continue;
+    issues.push(
+      mkIssue(
+        "state.merge.no_hardcoded_entities",
+        `Hardcoded entity array literal (multiple objects with "${idField}") in the component \u2014 entity data should come from state/props.`,
+        `Remove the literal array: this data comes from ${all.filter((e) => e.idField === idField).map((e) => `props.${e.name}`).join(" / ") || "props"}. Read it there (\`?? []\` for an absent value, never a literal default), seed state from it, and merge updates via stream.`
+      )
+    );
+  }
+  return issues;
+}
+function runDerivedViewMemoized(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const all = getEntityCollections(input.contract);
+  const entities = getMutatedEntityCollections(input.contract, all);
+  if (entities.length === 0) return [];
+  const returnIdx = src.indexOf("return (");
+  if (returnIdx < 0) return [];
+  const renderBody = src.slice(returnIdx);
+  const issues = [];
+  for (const e of entities) {
+    const re = new RegExp(`\\b${e.name}\\s*\\.(filter|reduce|sort)\\s*\\(`);
+    if (re.test(renderBody)) {
+      issues.push(
+        mkIssue(
+          "state.merge.derived_view_memoized",
+          `Derived view (${e.name}.filter/reduce/sort) computed inside the render body \u2014 should be wrapped in useMemo.`,
+          `Extract to \`const ${e.name}Filtered = useMemo(() => ${e.name}.filter(...), [${e.name}, ...]);\` before the return.`,
+          "warn"
+        )
+      );
+    }
+  }
+  return issues;
+}
+function runMapKeyIsId(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const INDEX_NAMES = /* @__PURE__ */ new Set(["index", "idx", "i", "j", "k", "n", "ix"]);
+  const re = /key\s*=\s*\{\s*(\w+)\s*\}/g;
+  const issues = [];
+  for (const m of src.matchAll(re)) {
+    const key = m[1];
+    if (!INDEX_NAMES.has(key)) continue;
+    issues.push(
+      mkIssue(
+        "render.map_key_is_id",
+        `Array key uses index variable "${key}" \u2014 reorders and stream merges will break React reconciliation.`,
+        `Replace key={${key}} with key={item.id} \u2014 or, when the items carry no id, with the field that names each one (item.label / item.symbol / item.name).`
+      )
+    );
+  }
+  return issues;
+}
+var STATE_MERGE_CHECKS = [
+  {
+    id: "state.merge.seeded_from_props",
+    axis: "state",
+    values: ["merge"],
+    run: runStateSeededFromProps
+  },
+  {
+    id: "state.merge.no_hardcoded_entities",
+    axis: "state",
+    values: ["merge"],
+    run: runNoHardcodedEntities
+  },
+  {
+    id: "state.merge.derived_view_memoized",
+    axis: "state",
+    values: ["merge"],
+    run: runDerivedViewMemoized
+  },
+  // Map-key check: gated on any iterating render. state=merge always
+  // implies iteration, so the render gate already covers it.
+  {
+    id: "render.map_key_is_id",
+    axis: "render",
+    values: ["list", "grid", "timeline", "master-detail"],
+    run: runMapKeyIsId
+  }
+];
+
+// src/evaluation/axis-checks/checks/state-ui-affordance.ts
+var STATE_ARIA_OR_ROLE = /aria-(checked|pressed|selected|expanded|current)\s*=|role\s*=/;
+var STATE_PRIMITIVE_IN_SUBTREE = /<(Checkbox|Toggle|Tabs|Accordion)[\s/>]/;
+var SEMANTIC_PRIMITIVES = /* @__PURE__ */ new Set(["Button", "Checkbox", "Toggle", "Link", "MenuItem"]);
+function collectSetters(src) {
+  const setters = /* @__PURE__ */ new Set();
+  for (const m of src.matchAll(/const\s*\[\s*\w+\s*,\s*(set\w+)\s*\]\s*=\s*useState/g)) {
+    setters.add(m[1]);
+  }
+  return setters;
+}
+function collectHandlers(src, setters) {
+  const handlers = /* @__PURE__ */ new Set();
+  for (const m of src.matchAll(/const\s+(\w+)\s*=\s*(?:\([^)]*\)|\w+)\s*=>\s*\{?/g)) {
+    const body = src.slice(m.index + m[0].length, m.index + m[0].length + 400);
+    for (const s of setters) {
+      if (body.includes(s)) {
+        handlers.add(m[1]);
+        break;
+      }
+    }
+  }
+  return handlers;
+}
+function attrBlock(src, start) {
+  let depth = 0;
+  for (let i = start; i < src.length; i++) {
+    const c = src[i];
+    if (c === "{") depth++;
+    else if (c === "}") depth--;
+    else if (c === ">" && depth === 0) return { block: src.slice(start, i), end: i };
+  }
+  return { block: src.slice(start, start + 900), end: start + 900 };
+}
+function onClickValue(block) {
+  const m = block.match(/onClick\s*=\s*\{/);
+  if (!m || m.index === void 0) return null;
+  const open = m.index + m[0].length - 1;
+  let depth = 0;
+  for (let i = open; i < block.length; i++) {
+    if (block[i] === "{") depth++;
+    else if (block[i] === "}") {
+      depth--;
+      if (depth === 0) return block.slice(open + 1, i);
+    }
+  }
+  return block.slice(open + 1);
+}
+function subtree(src, pos, tag) {
+  const close = src.indexOf(`</${tag}>`, pos);
+  return src.slice(pos, close === -1 ? pos + 700 : close);
+}
+function runStateAriaPresent(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const setters = collectSetters(src);
+  const handlers = collectHandlers(src, setters);
+  const issues = [];
+  const flaggedLines = /* @__PURE__ */ new Set();
+  const localComponents = /* @__PURE__ */ new Set();
+  for (const m of src.matchAll(/(?:function\s+([A-Z]\w*)\s*\(|const\s+([A-Z]\w*)\s*=)/g)) {
+    localComponents.add(m[1] ?? m[2]);
+  }
+  for (const m of src.matchAll(/<([A-Za-z][A-Za-z0-9]*)\b/g)) {
+    const tag = m[1];
+    if (m.index === void 0) continue;
+    if (localComponents.has(tag)) continue;
+    const { block, end } = attrBlock(src, m.index + m[0].length);
+    const clickValue = onClickValue(block);
+    if (clickValue === null) continue;
+    const mutatesAffordance = [...setters].some((s) => clickValue.includes(s)) || [...handlers].some((h) => new RegExp(`\\b${h}\\b`).test(clickValue)) || // Extracted-subcomponent shape: the toggle handler arrives as an
+    // `on[A-Z]…` callback prop and is invoked from onClick — inside a
+    // ui-affordance component that IS the affordance mutation.
+    /\bon[A-Z]\w*\b/.test(clickValue);
+    if (!mutatesAffordance) continue;
+    if (SEMANTIC_PRIMITIVES.has(tag)) continue;
+    if (STATE_ARIA_OR_ROLE.test(block)) continue;
+    if (STATE_PRIMITIVE_IN_SUBTREE.test(subtree(src, end, tag))) continue;
+    const line = src.slice(0, m.index).split("\n").length;
+    if (flaggedLines.has(line)) continue;
+    flaggedLines.add(line);
+    issues.push(
+      mkIssue(
+        "state.ui_affordance.state_aria_present",
+        `Line ${line}: <${tag}> toggles the UI affordance from its onClick but exposes no state ARIA \u2014 its checked/selected/expanded state is invisible to assistive technology (styling is the only carrier).`,
+        `Add the matching state attribute to the SAME element that carries the onClick: \`role="checkbox"\` + \`aria-checked={\u2026}\` for a toggle row, \`aria-pressed\` for a toggle button, \`aria-selected\` for a selection, \`aria-expanded\` for an open/close affordance \u2014 or replace the hand-rolled control with the state-carrying primitive (Checkbox / Toggle / Tabs / Accordion). \`as={Clickable}\` adds button + keyboard semantics but NOT state.`
+      )
+    );
+  }
+  return issues;
+}
+var STATE_UI_AFFORDANCE_CHECKS = [
+  {
+    id: "state.ui_affordance.state_aria_present",
+    axis: "state",
+    values: ["ui-affordance"],
+    run: runStateAriaPresent
+  }
+];
+
+// src/evaluation/axis-checks/checks/realtime.ts
+var REALTIME_ACTIVE = ["merge", "append", "status", "presence", "mixed"];
+function runStreamHandlerPerEvent(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const eventNames = getStreamEventNames(input.contract);
+  const issues = [];
+  for (const name of eventNames) {
+    const re = new RegExp(`useStream(?:<[^>]*>)?\\s*\\(\\s*['"\`]${name}['"\`]`);
+    if (re.test(src)) continue;
+    issues.push(
+      mkIssue(
+        "realtime.stream_handler_per_event",
+        `Stream event "${name}" declared in the contract has no useStream('${name}') call.`,
+        `Add \`const ${name} = useStream<...>('${name}');\` and handle ${name}.latest in a useEffect.`
+      )
+    );
+  }
+  return issues;
+}
+function runStreamMergesById(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const eventNames = getStreamEventNames(input.contract);
+  const all = getEntityCollections(input.contract);
+  const entities = getMutatedEntityCollections(input.contract, all);
+  if (eventNames.length === 0 || entities.length === 0) return [];
+  const issues = [];
+  const idFields = new Set(entities.map((e) => e.idField));
+  for (const idField of idFields) {
+    const re = new RegExp(`\\.${idField}\\b`);
+    if (re.test(src)) continue;
+    issues.push(
+      mkIssue(
+        "realtime.merge.stream_merges_by_id",
+        `Entity id field "${idField}" is never referenced in the source \u2014 stream merge likely does not key by id.`,
+        `In the stream handler, merge by id: setItems(prev => prev.map(x => x.${idField} === update.${idField} ? {...x, ...update} : x)).`,
+        "warn"
+      )
+    );
+  }
+  return issues;
+}
+var REALTIME_CHECKS = [
+  {
+    id: "realtime.stream_handler_per_event",
+    axis: "realtime",
+    values: REALTIME_ACTIVE,
+    run: runStreamHandlerPerEvent
+  },
+  {
+    id: "realtime.merge.stream_merges_by_id",
+    axis: "realtime",
+    values: ["merge", "mixed"],
+    run: runStreamMergesById
+  }
+];
+
+// src/evaluation/axis-checks/checks/writes.ts
+var ACTIVE_WRITES = [
+  "commit",
+  "multi-commit",
+  "per-item",
+  "submit",
+  "compose"
+];
+function runActionHookWired(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const actionNames = getActionNames(input.contract);
+  const issues = [];
+  for (const name of actionNames) {
+    const re = new RegExp(`useAction(?:<[^>]*>)?\\s*\\(\\s*['"\`]${name}['"\`]`);
+    if (re.test(src)) continue;
+    issues.push(
+      mkIssue(
+        "writes.action_hook_wired",
+        `Contract action "${name}" has no useAction('${name}') call.`,
+        `Add \`const ${name} = useAction<...>('${name}');\` and wire it to the relevant control.`
+      )
+    );
+  }
+  return issues;
+}
+function runActionHandlerAttached(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const actionNames = getActionNames(input.contract);
+  const issues = [];
+  for (const name of actionNames) {
+    const declRe = new RegExp(
+      `const\\s+(\\w+)\\s*=\\s*useAction(?:<[^>]*>)?\\s*\\(\\s*['"\`]${name}['"\`]`
+    );
+    const m = src.match(declRe);
+    if (!m) continue;
+    const constName = m[1];
+    const rest = src.replace(m[0], "");
+    if (new RegExp(`\\b${constName}\\s*\\(`).test(rest)) continue;
+    issues.push(
+      mkIssue(
+        "writes.action_handler_attached",
+        `useAction result "${constName}" (for action "${name}") is declared but never invoked.`,
+        `Call ${constName}({...}) from an interactive element (e.g., <Button onClick={() => ${constName}(payload)}>).`
+      )
+    );
+  }
+  return issues;
+}
+function runSubmitDisabledPath(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const submits = getSubmitActions(input.contract);
+  if (submits.length === 0) return [];
+  if (/disabled\s*=\s*\{/.test(src)) return [];
+  return [
+    mkIssue(
+      "writes.submit.disabled_path",
+      `Form has no \`disabled={...}\` expression anywhere \u2014 submit is likely unconditional.`,
+      `Gate submit on validation: e.g. \`<Button disabled={!isValid} onClick={handleSubmit}>\`.`,
+      "warn"
+    )
+  ];
+}
+var WRITES_CHECKS = [
+  {
+    id: "writes.action_hook_wired",
+    axis: "writes",
+    values: ACTIVE_WRITES,
+    run: runActionHookWired
+  },
+  {
+    id: "writes.action_handler_attached",
+    axis: "writes",
+    values: ACTIVE_WRITES,
+    run: runActionHandlerAttached
+  },
+  {
+    id: "writes.submit.disabled_path",
+    axis: "writes",
+    values: ["submit"],
+    run: runSubmitDisabledPath
+  }
+];
+
+// src/evaluation/axis-checks/checks/state-payload.ts
+function runSubmitHookPresent(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const submits = getSubmitActions(input.contract);
+  const issues = [];
+  for (const s of submits) {
+    const re = new RegExp(`useAction(?:<[^>]*>)?\\s*\\(\\s*['"\`]${s.name}['"\`]`);
+    if (re.test(src)) continue;
+    issues.push(
+      mkIssue(
+        "writes.submit.hook_present",
+        `Submit action "${s.name}" has no useAction('${s.name}') call.`,
+        `Add \`const ${s.name} = useAction<...>('${s.name}');\` and invoke it from the submit button.`
+      )
+    );
+  }
+  return issues;
+}
+function runSubmitHandlerAttached(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const submits = getSubmitActions(input.contract);
+  const issues = [];
+  for (const s of submits) {
+    const declRe = new RegExp(
+      `const\\s+(\\w+)\\s*=\\s*useAction(?:<[^>]*>)?\\s*\\(\\s*['"\`]${s.name}['"\`]`
+    );
+    const m = src.match(declRe);
+    if (!m) continue;
+    const constName = m[1];
+    const rest = src.replace(m[0], "");
+    if (new RegExp(`\\b${constName}\\s*\\(`).test(rest)) continue;
+    issues.push(
+      mkIssue(
+        "writes.submit.handler_attached",
+        `useAction result "${constName}" (for submit "${s.name}") is declared but never invoked.`,
+        `Call ${constName}(payload) from the submit button's onClick handler, after validation.`
+      )
+    );
+  }
+  return issues;
+}
+function runStateCoversPayload(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const submits = getSubmitActions(input.contract);
+  if (submits.length === 0) return [];
+  const stateKeys = collectStateKeys(src);
+  const issues = [];
+  for (const s of submits) {
+    const missing = s.payloadKeys.filter((k) => !stateKeys.has(k));
+    if (missing.length === 0) continue;
+    issues.push(
+      mkIssue(
+        "state.payload.covers_submit",
+        `Submit action "${s.name}" expects payload keys [${s.payloadKeys.join(", ")}] but state does not cover: ${missing.join(", ")}.`,
+        `Add a state slot for each missing key so the final payload can be assembled.`
+      )
+    );
+  }
+  return issues;
+}
+function runInitialValuesSeeded(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const initialProps = getInitialValuePropNames(input.contract);
+  const issues = [];
+  for (const name of initialProps) {
+    if (seedsFromProp(src, name)) continue;
+    issues.push(
+      mkIssue(
+        "state.payload.initial_values_seeded",
+        `Prop "${name}" (pre-filled initial values) is never read in a useState initializer.`,
+        `Seed form state from props.${name} so edit mode pre-fills.`
+      )
+    );
+  }
+  return issues;
+}
+function runOptionListsConsumed(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const arrStrNames = getArrStrProps(input.contract);
+  const hasAnyMap = /\.map\s*\(/.test(src);
+  const issues = [];
+  for (const name of arrStrNames) {
+    const referenced = new RegExp(`\\bprops\\.${name}\\b`).test(src);
+    if (referenced && hasAnyMap) continue;
+    const reason = !referenced ? `Option list prop "${name}" (arr<str>) is never referenced \u2014 users cannot see the options.` : `Option list prop "${name}" (arr<str>) is referenced but the component has no .map() \u2014 options are not rendered as choices.`;
+    issues.push(
+      mkIssue(
+        "state.payload.option_lists_consumed",
+        reason,
+        `Render options with \`props.${name}.map(option => <RadioOption value={option} ... />)\`.`
+      )
+    );
+  }
+  return issues;
+}
+function runNoOrphanPayloadKey(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const submits = getSubmitActions(input.contract);
+  if (submits.length === 0) return [];
+  const body = src.replace(/interface\s+Action\w+[\s\S]*?\n}/g, "").replace(/type\s+Action\w+[\s\S]*?\n;/g, "");
+  const issues = [];
+  for (const s of submits) {
+    const orphans = [];
+    for (const key of s.payloadKeys) {
+      const re = new RegExp(`\\b${key}\\b`);
+      if (!re.test(body)) orphans.push(key);
+    }
+    if (orphans.length === 0) continue;
+    issues.push(
+      mkIssue(
+        "state.payload.no_orphan_key",
+        `Submit payload keys [${orphans.join(", ")}] never appear in the component body \u2014 missing from the submitted payload.`,
+        `Add UI and state for these keys, or remove them from the ActionEntry if not needed.`,
+        "warn"
+      )
+    );
+  }
+  return issues;
+}
+var STATE_PAYLOAD_CHECKS = [
+  {
+    id: "writes.submit.hook_present",
+    axis: "writes",
+    values: ["submit"],
+    run: runSubmitHookPresent
+  },
+  {
+    id: "writes.submit.handler_attached",
+    axis: "writes",
+    values: ["submit"],
+    run: runSubmitHandlerAttached
+  },
+  {
+    id: "state.payload.covers_submit",
+    axis: "state",
+    values: ["payload"],
+    run: runStateCoversPayload
+  },
+  {
+    id: "state.payload.initial_values_seeded",
+    axis: "state",
+    values: ["payload", "draft"],
+    run: runInitialValuesSeeded
+  },
+  {
+    id: "state.payload.option_lists_consumed",
+    axis: "state",
+    values: ["payload"],
+    run: runOptionListsConsumed
+  },
+  {
+    id: "state.payload.no_orphan_key",
+    axis: "state",
+    values: ["payload"],
+    run: runNoOrphanPayloadKey
+  }
+];
+
+// src/evaluation/axis-checks/checks/tooling.ts
+var CLIENT_PRESENT = ["client", "both"];
+var ALL_TOOLING_VALUES = ["none", "wired", "client", "both"];
+var REALTIME_ACTIVE2 = [
+  "merge",
+  "append",
+  "status",
+  "presence",
+  "mixed"
+];
+function runGadgetHookCalled(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const names = getGadgetNames(input.contract);
+  const issues = [];
+  for (const name of names) {
+    const re = new RegExp(`const\\s+${name}\\s*=`);
+    if (re.test(src)) continue;
+    issues.push(
+      mkIssue(
+        "tooling.clientCapability.hook_called",
+        `Contract clientCapability "${name}" has no \`const ${name} = \u2026()\` hook call.`,
+        `Import the declared hook (default package: @ggui-ai/gadgets) and bind its return value to \`const ${name}\` at the top of the component; surface \`.value\` / \`.status\` in JSX.`
+      )
+    );
+  }
+  return issues;
+}
+function runClientCapabilityStartCalled(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const names = getStdlibGadgetNames(input.contract);
+  const issues = [];
+  for (const name of names) {
+    const bindingRe = new RegExp(`const\\s+${name}\\s*=`);
+    if (!bindingRe.test(src)) continue;
+    const startRe = new RegExp(`\\b${name}\\s*\\.\\s*start\\s*\\(`);
+    if (startRe.test(src)) continue;
+    issues.push(
+      mkIssue(
+        "tooling.clientCapability.start_called",
+        `clientCapability "${name}" is bound but \`${name}.start(\u2026)\` is never invoked \u2014 the capability stays in 'idle' and the feature won't fire.`,
+        `Wire \`${name}.start({...})\` to a UI control (Button onClick, effect, etc.). Read \`.status\` to gate the UI between 'idle' / 'prompting' / 'active' / 'completed' / 'denied' / 'error'.`
+      )
+    );
+  }
+  return issues;
+}
+function collectStreamSourceTools(contract) {
+  const result = /* @__PURE__ */ new Map();
+  const streamSpec = contract?.streamSpec;
+  if (!streamSpec || typeof streamSpec !== "object") return result;
+  for (const [channelName, entryRaw] of Object.entries(streamSpec)) {
+    const entry = entryRaw;
+    if (!entry || typeof entry !== "object") continue;
+    const tool = entry.source?.tool;
+    if (typeof tool !== "string" || tool.length === 0) continue;
+    result.set(channelName, tool);
+  }
+  return result;
+}
+function runStreamSourceNoDirectCall(input) {
+  if (input.compiledCode === null) return [];
+  const src = input.sourceCode;
+  const map = collectStreamSourceTools(input.contract);
+  if (map.size === 0) return [];
+  const issues = [];
+  for (const [channelName, toolName] of map) {
+    const callRe = new RegExp(`\\b${toolName}\\s*\\(`);
+    if (!callRe.test(src)) continue;
+    issues.push(
+      mkIssue(
+        "realtime.stream_source.no_direct_call",
+        `Source code calls \`${toolName}(...)\` directly but the contract declares it as the source tool for streamSpec.${channelName}. Source tools are agent-side / runtime-polled; the component MUST NOT invoke them.`,
+        `Subscribe to the channel via \`const ${channelName} = useStream('${channelName}');\` and read \`${channelName}.latest\` / \`${channelName}.all\` \u2014 the runtime polls or subscribes to '${toolName}' on the component's behalf.`
+      )
+    );
+  }
+  return issues;
+}
+var RETIRED_IDENTIFIERS = [
+  {
+    pattern: /\buseWiredTool\b/,
+    id: "useWiredTool",
+    label: "`useWiredTool(...)` hook",
+    replacement: "Use `useAction(name)` for user gestures the agent should react to. `agentCapabilities.tools` entries are agent-side catalog declarations \u2014 the component never calls them directly."
+  },
+  {
+    pattern: /\buseAgentTool\b/,
+    id: "useAgentTool",
+    label: "`useAgentTool(...)` hook",
+    replacement: "Agent-side tools are NEVER imported as component hooks. The contract declares them under `agentCapabilities.tools` for cross-ref (actionSpec.nextStep / streamSpec.source.tool); the component reacts via `useAction` / `useStream`."
+  },
+  {
+    pattern: /\bcallWiredTool\b/,
+    id: "callWiredTool",
+    label: "`callWiredTool(...)` call",
+    replacement: "Component-side direct invocation of agent-side tools is retired. Fire a UI gesture via `useAction(name)`; the agent reacts on its next turn (`nextStep` hint optional)."
+  },
+  {
+    pattern: /\buseClientTool\b/,
+    id: "useClientTool",
+    label: "`useClientTool(name, handler)` hook",
+    replacement: "Use a gadget hook from `@ggui-ai/gadgets` (e.g., `useGeolocation`, `useClipboardWrite`) and thread the result into a contextSpec slot or actionSpec payload."
+  },
+  {
+    pattern: /\bdispatch\s*:\s*\{\s*kind\s*:/,
+    id: "dispatch.kind",
+    label: "`dispatch: { kind: '...' }` discriminated union",
+    replacement: "ActionEntry.dispatch is retired. Use the flat `nextStep?: '<tool>'` field on the action entry instead."
+  },
+  {
+    pattern: /\bintendedTool\b/,
+    id: "intendedTool",
+    label: "`intendedTool` field",
+    replacement: "Use the flat `nextStep` field \u2014 the hint surface is one optional advisory string, not a nested discriminator."
+  },
+  {
+    pattern: /\bmode\s*:\s*['"`]host-routed['"`]/,
+    id: "mode.host-routed",
+    label: "`mode: 'host-routed'`",
+    replacement: "The `mode` field on action entries is retired. All actions are agent-routed; use `nextStep` for the optional tool hint."
+  },
+  {
+    pattern: /\bbroadcast\s*:\s*\{/,
+    id: "broadcast",
+    label: "`broadcast: { \u2026 }` contract field",
+    replacement: "Move the channel source declaration to `streamSpec[channel].source = { tool, args? }`."
+  },
+  {
+    // Match `agentTools` only as a contract-shaped object key or
+    // property access — not as a local variable name in unrelated
+    // code. `\bagentTools\s*[:.]` catches `{ agentTools: {...} }` /
+    // `contract.agentTools` while ignoring `const agentTools = ...`.
+    pattern: /\bagentTools\s*[:.]/,
+    id: "contract.agentTools",
+    label: "`agentTools` top-level contract field",
+    replacement: "The top-level `agentTools` field is retired. Declare agent-side tools under `agentCapabilities.tools` (catalog nested under a capabilities parent for symmetry with `clientCapabilities`)."
+  },
+  {
+    pattern: /\bclientCapabilities\s*\.\s*capabilities\b/,
+    id: "clientCapabilities.capabilities",
+    label: "`clientCapabilities.capabilities` inner key",
+    replacement: "The inner `capabilities` key is retired. Use `clientCapabilities.gadgets` \u2014 entries are library-hook declarations, not RPC capabilities."
+  },
+  {
+    pattern: /['"`]@ggui-ai\/client-tools['"`]/,
+    id: "package.@ggui-ai/client-tools",
+    label: "`@ggui-ai/client-tools` package import",
+    replacement: "The package was renamed to `@ggui-ai/gadgets`. Update the import string."
+  },
+  {
+    pattern: /\bPushStory\b/,
+    id: "PushStory",
+    label: "`PushStory` type / `pushStorySchema` schema",
+    replacement: "`PushStory` was retired when the handshake input was flattened. The current wire is `ggui_handshake({intent, blueprintDraft: {contract, variance?, generator?}})` + `ggui_render({handshakeId, props, override?: {contract?, variance?}})` (omit `override` to accept the proposal as-is)."
+  },
+  {
+    pattern: /\bpushStorySchema\b/,
+    id: "pushStorySchema",
+    label: "`pushStorySchema` zod schema",
+    replacement: "`pushStorySchema` was retired alongside `PushStory`. Current schemas: `handshakeInputSchema` + `renderInputSchema` (with the optional `override` re-aim) in `@ggui-ai/protocol`."
+  },
+  {
+    pattern: /\bstory\s*\.\s*adapters\b/,
+    id: "story.adapters",
+    label: "`story.adapters` field access",
+    replacement: "The story.adapters gate was retired alongside `PushStory`. Per-app permission gates flow through `clientCapabilities.gadgets[*].permission` (Permissions-Policy derivation)."
+  },
+  {
+    pattern: /\bdeclaredAdapters\b/,
+    id: "declaredAdapters",
+    label: "`declaredAdapters` field / runtime gate",
+    replacement: "App-level `declaredAdapters` was retired. Per-app permission gates derive from `clientCapabilities.gadgets[*].permission` instead."
+  },
+  {
+    pattern: /\bassertAdaptersDeclared\b/,
+    id: "assertAdaptersDeclared",
+    label: "`assertAdaptersDeclared(...)` runtime call",
+    replacement: "The runtime adapter-gate function is retired. Permissions-Policy is derived per-contract at render commit time and threaded through the bootstrap projection."
+  },
+  {
+    pattern: /\bHandshakeStoredStory\b/,
+    id: "HandshakeStoredStory",
+    label: "`HandshakeStoredStory` storage type",
+    replacement: "The OSS handler's stored type is now `HandshakeStoredInput` with the MVB-5 `{intent, blueprintDraft, forceCreate?}` shape."
+  },
+  {
+    pattern: /\brecord\s*\.\s*story\b/,
+    id: "record.story",
+    label: "`record.story.*` access on handshake storage",
+    replacement: "Handshake storage was flattened. Read `record.input.*` (intent / blueprintDraft) \u2014 the nested `story` wrapper is gone. MVB-5 also adds `record.suggestion` + `record.effectiveContract`."
+  }
+];
+function runNoRetiredIdentifiers(input) {
+  const src = input.sourceCode;
+  const issues = [];
+  for (const rule of RETIRED_IDENTIFIERS) {
+    if (!rule.pattern.test(src)) continue;
+    issues.push(
+      mkIssue(
+        `universal.no_retired_identifiers.${rule.id}`,
+        `Source contains ${rule.label} \u2014 retired from the contract surface.`,
+        rule.replacement
+      )
+    );
+  }
+  return issues;
+}
+var TOOLING_CHECKS = [
+  {
+    id: "tooling.clientCapability.hook_called",
+    axis: "tooling",
+    values: CLIENT_PRESENT,
+    run: runGadgetHookCalled
+  },
+  {
+    id: "tooling.clientCapability.start_called",
+    axis: "tooling",
+    values: CLIENT_PRESENT,
+    run: runClientCapabilityStartCalled
+  },
+  {
+    // Stream-source direct-call check. Gated on realtime axis (rather
+    // than tooling) since stream sources are a realtime concern — but
+    // logically lives in tooling.ts alongside the other tool-reference
+    // checks since the issue class is about referenced agentTools.
+    id: "realtime.stream_source.no_direct_call",
+    axis: "realtime",
+    values: REALTIME_ACTIVE2,
+    run: runStreamSourceNoDirectCall
+  },
+  {
+    // Universal — fires on every tooling-axis value. The check itself
+    // is contract-agnostic; the axis gate is "every contract" via the
+    // full ALL_TOOLING_VALUES list (rather than the universal-check
+    // module's "render" gate convention) so the anti-pattern stays
+    // co-located with the other tooling-related rules.
+    id: "universal.no_retired_identifiers",
+    axis: "tooling",
+    values: ALL_TOOLING_VALUES,
+    run: runNoRetiredIdentifiers
+  }
+];
+
+// src/evaluation/axis-checks/checks/grid.ts
+var BOARD_PROP_RX = /^(columns?|lanes?|stages?|lists?|buckets?|swimlanes?)$/i;
+var BOARD_PROMPT_RX = /\b(kanban|board)\b/i;
+var BOARD_NAMES = ["columns", "lanes", "stages", "lists", "buckets", "swimlanes"];
+var LAYOUT_TAG_RX = /<(\/?)(Grid|Row|Stack|Card|Box|Container|ScrollArea|div|section)\b([^<>]*?)>/g;
+var SIDE_BY_SIDE = /* @__PURE__ */ new Set(["Grid", "Row"]);
+function boardPropNames(contract) {
+  const propsField = contract?.propsSpec;
+  const properties = propsField?.properties ?? {};
+  return Object.entries(properties).filter(([name, p]) => BOARD_PROP_RX.test(name) && (p?.type === "array" || p?.schema?.type === "array")).map(([name]) => name);
+}
+function jsxMapPositions(sourceCode, name) {
+  const rx = new RegExp(
+    `\\b${name}(?:\\?\\.)?\\.map\\(\\s*\\(?\\s*\\w+(?:\\s*,\\s*\\w+)?\\s*\\)?\\s*=>\\s*(?:\\(?\\s*<|\\{[^{}]{0,600}?\\breturn\\s*\\(?\\s*<)`,
+    "g"
+  );
+  return [...sourceCode.matchAll(rx)].map((m) => m.index ?? 0);
+}
+function enclosingLayoutTag(sourceCode, pos) {
+  const stack = [];
+  for (const m of sourceCode.slice(0, pos).matchAll(LAYOUT_TAG_RX)) {
+    const closing = m[1] === "/";
+    const name = m[2] ?? "";
+    const attrs = m[3] ?? "";
+    if (closing) {
+      if (stack[stack.length - 1] === name) stack.pop();
+      continue;
+    }
+    if (attrs.trimEnd().endsWith("/")) continue;
+    stack.push(name);
+  }
+  return stack[stack.length - 1];
+}
+function describeBoardRead(input) {
+  const declared = boardPropNames(input.contract);
+  const names = declared.length > 0 ? declared : BOARD_PROMPT_RX.test(input.originalPrompt) ? [...BOARD_NAMES] : BOARD_NAMES.filter((n) => jsxMapPositions(input.sourceCode, n).length > 0);
+  const perName = names.map((name) => {
+    const positions = jsxMapPositions(input.sourceCode, name);
+    return { name, maps: positions.length, enclosing: positions.map((pos) => enclosingLayoutTag(input.sourceCode, pos) ?? "nothing") };
+  });
+  return { declared, names, perName };
+}
+function findStackedBoardColumns(input) {
+  const stacked = [];
+  for (const { name, enclosing } of describeBoardRead(input).perName) {
+    for (const tag of enclosing) if (!SIDE_BY_SIDE.has(tag)) stacked.push([name, tag]);
+  }
+  return stacked;
+}
+function runBoardColumnsSideBySide(input) {
+  if (input.compiledCode === null) return [];
+  const standDown = input.designMode === "free";
+  const stacked = standDown ? [] : findStackedBoardColumns(input);
+  if (axisCheckTraceEnabled()) {
+    const line = {
+      ...describeBoardRead(input),
+      designMode: input.designMode ?? "constrained",
+      standDown,
+      result: standDown ? "stand-down" : stacked.length > 0 ? "fail" : "pass"
+    };
+    console.log(JSON.stringify({ boardColumnsTrace: line }));
+  }
+  if (stacked.length === 0) return [];
+  const [name, tag] = stacked[0];
+  return [
+    mkIssue(
+      "grid.board_columns_side_by_side",
+      `The board's \`${name}\` are composed under <${tag}> \u2014 a vertical stack of column sections; at md and wider the columns must sit side by side.`,
+      `Wrap the ${name} map in <Grid columns={{ base: 1, md: ${name}.length }} gap="md"> (each column its own <Stack> of cards); never a <Stack> of column sections.`
+    )
+  ];
+}
+var GRID_CHECKS = [
+  {
+    id: "grid.board_columns_side_by_side",
+    axis: "render",
+    values: ["grid"],
+    run: runBoardColumnsSideBySide
+  }
+];
+
+// src/evaluation/axis-checks/extras.ts
+function mkIssue2(subcategory, description, fix, result = "warn") {
+  return { tier: 0, result, category: "mode", subcategory, description, fix };
+}
+var dragTriggerWired = {
+  id: "writeTrigger.drag.handlers_wired",
+  axis: "writeTrigger",
+  values: ["drag"],
+  run(input) {
+    if (input.compiledCode === null) return [];
+    const src = input.sourceCode;
+    const hasStart = /onDragStart\s*=/.test(src);
+    const hasDrop = /onDrop\s*=/.test(src);
+    if (hasStart && hasDrop) return [];
+    return [
+      mkIssue2(
+        "writeTrigger.drag.handlers_wired",
+        `Classified as writeTrigger=drag but component lacks ${!hasStart ? "onDragStart" : ""}${!hasStart && !hasDrop ? " + " : ""}${!hasDrop ? "onDrop" : ""} handlers.`,
+        "Attach onDragStart to draggable items and onDrop (with onDragOver preventDefault) to drop zones.",
+        "fail"
+      )
+    ];
+  }
+};
+var swipeTriggerWired = {
+  id: "writeTrigger.swipe.handlers_wired",
+  axis: "writeTrigger",
+  values: ["swipe"],
+  run(input) {
+    if (input.compiledCode === null) return [];
+    const src = input.sourceCode;
+    const hasTouch = /onTouchStart\s*=/.test(src) && /onTouchEnd\s*=/.test(src);
+    if (!hasTouch) {
+      return [
+        mkIssue2(
+          "writeTrigger.swipe.handlers_wired",
+          "Classified as writeTrigger=swipe but component lacks onTouchStart + onTouchEnd handlers.",
+          "Wire onTouchStart to record the start X/Y, onTouchEnd to classify direction and fire the action.",
+          "fail"
+        )
+      ];
+    }
+    return [];
+  }
+};
+var composeCrossEntity = {
+  id: "writes.compose.cross_entity_ids",
+  axis: "writes",
+  values: ["compose"],
+  run(input) {
+    if (input.compiledCode === null) return [];
+    const src = input.sourceCode;
+    const re = /\{\s*[^}]*?\b(\w*Id|id)\b[^}]*?,\s*[^}]*?\b(\w*Id|id)\b[^}]*?\}/s;
+    if (re.test(src)) return [];
+    return [
+      mkIssue2(
+        "writes.compose.cross_entity_ids",
+        "Classified as writes=compose but no action invocation passes two id-bearing keys together.",
+        "The compose action must receive both entity ids in one payload, e.g. `schedule({ eventId, calendarId })`.",
+        "warn"
+      )
+    ];
+  }
+};
+var multiStepHasState = {
+  id: "layout.multi_step.state_present",
+  axis: "layout",
+  values: ["multi-step"],
+  run(input) {
+    if (input.compiledCode === null) return [];
+    const src = input.sourceCode;
+    const hasIntStep = /useState(?:<number>)?\s*\(\s*[0-9]+\s*\)/.test(src);
+    if (hasIntStep) return [];
+    return [
+      mkIssue2(
+        "layout.multi_step.state_present",
+        "Classified as layout=multi-step but no integer-typed useState tracks the current step.",
+        "Add `const [step, setStep] = useState(0);` and branch rendering on it.",
+        "fail"
+      )
+    ];
+  }
+};
+var stepperAdopted = {
+  id: "layout.multi_step.stepper_adopted",
+  axis: "layout",
+  values: ["multi-step"],
+  run(input) {
+    if (input.compiledCode === null) return [];
+    if (input.designMode === "free") return [];
+    if (/<Stepper[\s/>]/.test(input.sourceCode)) return [];
+    return [
+      mkIssue2(
+        "layout.multi_step.stepper_adopted",
+        "Classified as layout=multi-step but the design system's Stepper composite is never rendered.",
+        "Render <Stepper steps={STEPS} current={step} /> above the step body \u2014 STEPS is a top-level const array of step labels and `step` is your own useState index. Stepper is display-only: it never stores or advances the step itself.",
+        "fail"
+      )
+    ];
+  }
+};
+var mixedStreamsHaveHandlers = {
+  id: "realtime.mixed.handlers_per_event",
+  axis: "realtime",
+  values: ["mixed"],
+  run(input) {
+    if (input.compiledCode === null) return [];
+    const src = input.sourceCode;
+    const matches = src.match(/useStream\s*(?:<[^>]*>)?\s*\(/g);
+    const count = matches?.length ?? 0;
+    if (count >= 2) return [];
+    return [
+      mkIssue2(
+        "realtime.mixed.handlers_per_event",
+        `Classified as realtime=mixed but only ${count} useStream call(s) found \u2014 mixed streams need one handler per event.`,
+        "Add a separate `useStream('eventName')` for each event in the contract.",
+        "fail"
+      )
+    ];
+  }
+};
+var EXTRA_CHECKS = [
+  dragTriggerWired,
+  swipeTriggerWired,
+  composeCrossEntity,
+  multiStepHasState,
+  stepperAdopted,
+  mixedStreamsHaveHandlers
+];
+
+// src/evaluation/axis-checks/registry.ts
+var REGISTRY = [
+  ...UNIVERSAL_CHECKS,
+  ...TINT_CHECKS,
+  ...STATE_MERGE_CHECKS,
+  ...STATE_UI_AFFORDANCE_CHECKS,
+  ...REALTIME_CHECKS,
+  ...WRITES_CHECKS,
+  ...STATE_PAYLOAD_CHECKS,
+  ...TOOLING_CHECKS,
+  ...GRID_CHECKS,
+  ...EXTRA_CHECKS
+];
+
+export { EXTRA_CHECKS, REGISTRY, axisCheckTraceEnabled };
+//# sourceMappingURL=chunk-GYINWMPR.js.map
+//# sourceMappingURL=chunk-GYINWMPR.js.map